Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (3 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/Clp_C_Interface.h

    r2271 r2385  
    1212#include "Coin_C_defines.h"
    1313
    14 #if defined (CLP_EXTERN_C)
     14#if defined(CLP_EXTERN_C)
    1515typedef struct {
    1616  ClpSolve options;
     
    2929#endif
    3030
    31      /**@name Version info
     31/**@name Version info
    3232      *
    3333      * A Clp library has a version number of the form <major>.<minor>.<release>,
     
    3636      * For a checkout of the Clp development branch, major, minor, and release are 9999.
    3737      */
    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
     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
    5050        These do not have an exact analogue in C++.
    5151        The user does not need to know structure of Clp_Simplex or Clp_Solve.
     
    5959        from name and applying the method to an object of type ClpSolve.
    6060     */
    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
     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
    7676         rows are given by lower and upper bounds). If a pointer is NULL then the
    7777         following values are the default:
     
    8484         </ul>
    8585     */
    86      /** Just like the other loadProblem() method except that the matrix is
     86/** Just like the other loadProblem() method except that the matrix is
    8787     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 CoinBigIndex * rowStarts, const int * columns,
    118                                              const double * elements);
    119 
    120      /** Deletes columns */
    121      COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex * model, int number, const int * which);
    122      /** Add columns */
    123      COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex * model, int number, const double * columnLower,
    124                const double * columnUpper,
    125                const double * objective,
    126                const CoinBigIndex * columnStarts, const int * rows,
    127                const double * elements);
    128      /** Change row lower bounds */
    129      COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex * model, const double * rowLower);
    130      /** Change row upper bounds */
    131      COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex * model, const double * rowUpper);
    132      /** Change column lower bounds */
    133      COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex * model, const double * columnLower);
    134      /** Change column upper bounds */
    135      COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex * model, const double * columnUpper);
    136      /** Change objective coefficients */
    137      COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex * model, const double * objIn);
    138      /** Drops names - makes lengthnames 0 and names empty */
    139      COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex * model);
    140      /** Copies in names */
    141      COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex * model, const char * const * rowNames,
    142                const char * const * columnNames);
    143 
    144      /*@}*/
    145      /**@name gets and sets - you will find some synonyms at the end of this file */
    146      /*@{*/
    147      /** Number of rows */
    148      COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex * model);
    149      /** Number of columns */
    150      COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex * model);
    151      /** Primal tolerance to use */
    152      COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex * model);
    153      COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex * model,  double value) ;
    154      /** Dual tolerance to use */
    155      COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex * model);
    156      COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex * model,  double value) ;
    157      /** Dual objective limit */
    158      COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex * model);
    159      COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex * model, double value);
    160      /** Objective offset */
    161      COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex * model);
    162      COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex * model, double value);
    163      /** Fills in array with problem name  */
    164      COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex * model, int maxNumberCharacters, char * array);
    165      /* Sets problem name.  Must have \0 at end.  */
    166      COINLIBAPI int COINLINKAGE
    167      Clp_setProblemName(Clp_Simplex * model, int maxNumberCharacters, char * array);
    168      /** Number of iterations */
    169      COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex * model);
    170      COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex * model, int numberIterations);
    171      /** Maximum number of iterations */
    172      COINLIBAPI int maximumIterations(Clp_Simplex * model);
    173      COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex * model, int value);
    174      /** Maximum time in seconds (from when set called) */
    175      COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex * model);
    176      COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex * model, double value);
    177      /** Returns true if hit maximum iterations (or time) */
    178      COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex * model);
    179      /** Status of problem:
     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/** Copy in integer informations */
     107COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex *model, const char *information);
     108/** Drop integer informations */
     109COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex *model);
     110/** Resizes rim part of model  */
     111COINLIBAPI void COINLINKAGE Clp_resize(Clp_Simplex *model, int newNumberRows, int newNumberColumns);
     112/** Deletes rows */
     113COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex *model, int number, const int *which);
     114/** Add rows */
     115COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex *model, int number, const double *rowLower,
     116  const double *rowUpper,
     117  const CoinBigIndex *rowStarts, const int *columns,
     118  const double *elements);
     119
     120/** Deletes columns */
     121COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex *model, int number, const int *which);
     122/** Add columns */
     123COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex *model, int number, const double *columnLower,
     124  const double *columnUpper,
     125  const double *objective,
     126  const CoinBigIndex *columnStarts, const int *rows,
     127  const double *elements);
     128/** Change row lower bounds */
     129COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex *model, const double *rowLower);
     130/** Change row upper bounds */
     131COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex *model, const double *rowUpper);
     132/** Change column lower bounds */
     133COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex *model, const double *columnLower);
     134/** Change column upper bounds */
     135COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex *model, const double *columnUpper);
     136/** Change objective coefficients */
     137COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex *model, const double *objIn);
     138/** Drops names - makes lengthnames 0 and names empty */
     139COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex *model);
     140/** Copies in names */
     141COINLIBAPI 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 */
     148COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex *model);
     149/** Number of columns */
     150COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex *model);
     151/** Primal tolerance to use */
     152COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex *model);
     153COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex *model, double value);
     154/** Dual tolerance to use */
     155COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex *model);
     156COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex *model, double value);
     157/** Dual objective limit */
     158COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex *model);
     159COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex *model, double value);
     160/** Objective offset */
     161COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex *model);
     162COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex *model, double value);
     163/** Fills in array with problem name  */
     164COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex *model, int maxNumberCharacters, char *array);
     165/* Sets problem name.  Must have \0 at end.  */
     166COINLIBAPI int COINLINKAGE
     167Clp_setProblemName(Clp_Simplex *model, int maxNumberCharacters, char *array);
     168/** Number of iterations */
     169COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex *model);
     170COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex *model, int numberIterations);
     171/** Maximum number of iterations */
     172COINLIBAPI int maximumIterations(Clp_Simplex *model);
     173COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex *model, int value);
     174/** Maximum time in seconds (from when set called) */
     175COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex *model);
     176COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex *model, double value);
     177/** Returns true if hit maximum iterations (or time) */
     178COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex *model);
     179/** Status of problem:
    180180         0 - optimal
    181181         1 - primal infeasible
     
    184184         4 - stopped due to errors
    185185     */
    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
     186COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex *model);
     187/** Set problem status */
     188COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex *model, int problemStatus);
     189/** Secondary status of problem - may get extended
    190190         0 - none
    191191         1 - primal infeasible because dual limit reached
     
    194194         4 - scaled problem optimal - unscaled has both dual and primal infeasibilities
    195195     */
    196      COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex * model);
    197      COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex * model, int status);
    198      /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
    199      COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex * model);
    200      COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex * model, double value);
    201      /** Primal row solution */
    202      COINLIBAPI double * COINLINKAGE Clp_primalRowSolution(Clp_Simplex * model);
    203      /** Primal column solution */
    204      COINLIBAPI double * COINLINKAGE Clp_primalColumnSolution(Clp_Simplex * model);
    205      /** Dual row solution */
    206      COINLIBAPI double * COINLINKAGE Clp_dualRowSolution(Clp_Simplex * model);
    207      /** Reduced costs */
    208      COINLIBAPI double * COINLINKAGE Clp_dualColumnSolution(Clp_Simplex * model);
    209      /** Row lower */
    210      COINLIBAPI double* COINLINKAGE Clp_rowLower(Clp_Simplex * model);
    211      /** Row upper  */
    212      COINLIBAPI double* COINLINKAGE Clp_rowUpper(Clp_Simplex * model);
    213      /** Objective */
    214      COINLIBAPI double * COINLINKAGE Clp_objective(Clp_Simplex * model);
    215      /** Column Lower */
    216      COINLIBAPI double * COINLINKAGE Clp_columnLower(Clp_Simplex * model);
    217      /** Column Upper */
    218      COINLIBAPI double * COINLINKAGE Clp_columnUpper(Clp_Simplex * model);
    219      /** Number of elements in matrix */
    220      COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex * model);
    221      /* Column starts in matrix */
    222      COINLIBAPI const CoinBigIndex * COINLINKAGE Clp_getVectorStarts(Clp_Simplex * model);
    223      /* Row indices in matrix */
    224      COINLIBAPI const int * COINLINKAGE Clp_getIndices(Clp_Simplex * model);
    225      /* Column vector lengths in matrix */
    226      COINLIBAPI const int * COINLINKAGE Clp_getVectorLengths(Clp_Simplex * model);
    227      /* Element values in matrix */
    228      COINLIBAPI const double * COINLINKAGE Clp_getElements(Clp_Simplex * model);
    229      /** Objective value */
    230      COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex * model);
    231      /** Integer information */
    232      COINLIBAPI char * COINLINKAGE Clp_integerInformation(Clp_Simplex * model);
    233      /** Gives Infeasibility ray.
     196COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex *model);
     197COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex *model, int status);
     198/** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
     199COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex *model);
     200COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex *model, double value);
     201/** Primal row solution */
     202COINLIBAPI double *COINLINKAGE Clp_primalRowSolution(Clp_Simplex *model);
     203/** Primal column solution */
     204COINLIBAPI double *COINLINKAGE Clp_primalColumnSolution(Clp_Simplex *model);
     205/** Dual row solution */
     206COINLIBAPI double *COINLINKAGE Clp_dualRowSolution(Clp_Simplex *model);
     207/** Reduced costs */
     208COINLIBAPI double *COINLINKAGE Clp_dualColumnSolution(Clp_Simplex *model);
     209/** Row lower */
     210COINLIBAPI double *COINLINKAGE Clp_rowLower(Clp_Simplex *model);
     211/** Row upper  */
     212COINLIBAPI double *COINLINKAGE Clp_rowUpper(Clp_Simplex *model);
     213/** Objective */
     214COINLIBAPI double *COINLINKAGE Clp_objective(Clp_Simplex *model);
     215/** Column Lower */
     216COINLIBAPI double *COINLINKAGE Clp_columnLower(Clp_Simplex *model);
     217/** Column Upper */
     218COINLIBAPI double *COINLINKAGE Clp_columnUpper(Clp_Simplex *model);
     219/** Number of elements in matrix */
     220COINLIBAPI CoinBigIndex COINLINKAGE Clp_getNumElements(Clp_Simplex *model);
     221/* Column starts in matrix */
     222COINLIBAPI const CoinBigIndex *COINLINKAGE Clp_getVectorStarts(Clp_Simplex *model);
     223/* Row indices in matrix */
     224COINLIBAPI const int *COINLINKAGE Clp_getIndices(Clp_Simplex *model);
     225/* Column vector lengths in matrix */
     226COINLIBAPI const int *COINLINKAGE Clp_getVectorLengths(Clp_Simplex *model);
     227/* Element values in matrix */
     228COINLIBAPI const double *COINLINKAGE Clp_getElements(Clp_Simplex *model);
     229/** Objective value */
     230COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex *model);
     231/** Integer information */
     232COINLIBAPI char *COINLINKAGE Clp_integerInformation(Clp_Simplex *model);
     233/** Gives Infeasibility ray.
    234234      *
    235235      * Use Clp_freeRay to free the returned array.
     
    237237      * @return infeasibility ray, or NULL returned if none/wrong.
    238238      */
    239      COINLIBAPI double * COINLINKAGE Clp_infeasibilityRay(Clp_Simplex * model);
    240      /** Gives ray in which the problem is unbounded.
     239COINLIBAPI double *COINLINKAGE Clp_infeasibilityRay(Clp_Simplex *model);
     240/** Gives ray in which the problem is unbounded.
    241241      *
    242242      * Use Clp_freeRay to free the returned array.
     
    244244      * @return unbounded ray, or NULL returned if none/wrong.
    245245      */
    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,
     246COINLIBAPI double *COINLINKAGE Clp_unboundedRay(Clp_Simplex *model);
     247/** Frees a infeasibility or unbounded ray. */
     248COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex *model, double *ray);
     249/** See if status array exists (partly for OsiClp) */
     250COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex *model);
     251/** Return address of status array (char[numberRows+numberColumns]) */
     252COINLIBAPI unsigned char *COINLINKAGE Clp_statusArray(Clp_Simplex *model);
     253/** Copy in status vector */
     254COINLIBAPI 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,
    256256        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.
     257/* Get variable basis info */
     258COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex *model, int sequence);
     259/* Get row basis info */
     260COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex *model, int sequence);
     261/* Set variable basis info (and value if at bound) */
     262COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex *model,
     263  int sequence, int value);
     264/* Set row basis info (and value if at bound) */
     265COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex *model,
     266  int sequence, int value);
     267
     268/** User pointer for whatever reason */
     269COINLIBAPI void COINLINKAGE Clp_setUserPointer(Clp_Simplex *model, void *pointer);
     270COINLIBAPI 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.
    275275      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:
     276COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex *model,
     277  clp_callback userCallBack);
     278/** Unset Callback function */
     279COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex *model);
     280/** Amount of print out:
    281281         0 - none
    282282         1 - just final
     
    286286         above that 8,16,32 etc just for selective debug
    287287     */
    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.
     288COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex *model, int value);
     289COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex *model);
     290/** length of names (0 means no names0 */
     291COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex *model);
     292/** Fill in array (at least lengthNames+1 long) with a row name */
     293COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex *model, int iRow, char *name);
     294/** Fill in array (at least lengthNames+1 long) with a column name */
     295COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex *model, int iColumn, char *name);
     296
     297/*@}*/
     298
     299/**@name Functions most useful to user */
     300/*@{*/
     301/** General solve algorithm which can do presolve.
    303302         See  ClpSolve.hpp for options
    304303      */
    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);
     304COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex *model);
     305/** Pass solve options. (Exception to direct analogue rule) */
     306COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex *model, Clp_Solve *);
     307/** Dual initial solve */
     308COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex *model);
     309/** Primal initial solve */
     310COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex *model);
     311/** Barrier initial solve */
     312COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex *model);
     313/** Barrier initial solve, no crossover */
     314COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex *model);
     315/** Dual algorithm - see ClpSimplexDual.hpp for method */
     316COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex *model, int ifValuesPass);
     317/** Primal algorithm - see ClpSimplexPrimal.hpp for method */
     318COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex *model, int ifValuesPass);
    320319#ifndef SLIM_CLP
    321      /** Solve the problem with the idiot code */
    322      COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex * model, int tryhard);
     320/** Solve the problem with the idiot code */
     321COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex *model, int tryhard);
    323322#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
     323/** Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */
     324COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex *model, int mode);
     325/** Gets scalingFlag */
     326COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex *model);
     327/** Crash - at present just aimed at dual, returns
    329328         -2 if dual preferred and crash basis created
    330329         -1 if dual preferred and all slack basis preferred
     
    340339          2 Mini iterations
    341340     */
    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:
     341COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex *model, double gap, int pivot);
     342/*@}*/
     343
     344/**@name most useful gets and sets */
     345/*@{*/
     346/** If problem is primal feasible */
     347COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex *model);
     348/** If problem is dual feasible */
     349COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex *model);
     350/** Dual bound */
     351COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex *model);
     352COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex *model, double value);
     353/** Infeasibility cost */
     354COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex *model);
     355COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex *model, double value);
     356/** Perturbation:
    359357         50  - switch on perturbation
    360358         100 - auto perturb if takes too long (1.0e-6 largest nonzero)
     
    364362         others are for playing
    365363     */
    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
     364COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex *model);
     365COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex *model, int value);
     366/** Current (or last) algorithm */
     367COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex *model);
     368/** Set algorithm */
     369COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex *model, int value);
     370/** Sum of dual infeasibilities */
     371COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex *model);
     372/** Number of dual infeasibilities */
     373COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex *model);
     374/** Sum of primal infeasibilities */
     375COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex *model);
     376/** Number of primal infeasibilities */
     377COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex *model);
     378/** Save model to file, returns 0 if success.  This is designed for
    381379         use outside algorithms so does not save iterating arrays etc.
    382380     It does not save any messaging information.
     
    384382     It does not know about all types of virtual functions.
    385383     */
    386      COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex * model, const char * fileName);
    387      /** Restore model from file, returns 0 if success,
     384COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex *model, const char *fileName);
     385/** Restore model from file, returns 0 if success,
    388386         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
     387COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex *model, const char *fileName);
     388
     389/** Just check solution (for external use) - sets sum of
    392390         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,
     391COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex *model);
     392/*@}*/
     393
     394/******************** End of most useful part **************/
     395/**@name gets and sets - some synonyms */
     396/*@{*/
     397/** Number of rows */
     398COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex *model);
     399/** Number of columns */
     400COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex *model);
     401/** Number of iterations */
     402COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex *model);
     403/** Are there a numerical difficulties? */
     404COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex *model);
     405/** Is optimality proven? */
     406COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex *model);
     407/** Is primal infeasiblity proven? */
     408COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex *model);
     409/** Is dual infeasiblity proven? */
     410COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex *model);
     411/** Is the given primal objective limit reached? */
     412COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex *model);
     413/** Is the given dual objective limit reached? */
     414COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex *model);
     415/** Iteration limit reached? */
     416COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex *model);
     417/** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
     418COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex *model);
     419/** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */
     420COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex *model, double objsen);
     421/** Primal row solution */
     422COINLIBAPI const double *COINLINKAGE Clp_getRowActivity(Clp_Simplex *model);
     423/** Primal column solution */
     424COINLIBAPI const double *COINLINKAGE Clp_getColSolution(Clp_Simplex *model);
     425COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex *model, const double *input);
     426/** Dual row solution */
     427COINLIBAPI const double *COINLINKAGE Clp_getRowPrice(Clp_Simplex *model);
     428/** Reduced costs */
     429COINLIBAPI const double *COINLINKAGE Clp_getReducedCost(Clp_Simplex *model);
     430/** Row lower */
     431COINLIBAPI const double *COINLINKAGE Clp_getRowLower(Clp_Simplex *model);
     432/** Row upper  */
     433COINLIBAPI const double *COINLINKAGE Clp_getRowUpper(Clp_Simplex *model);
     434/** Objective */
     435COINLIBAPI const double *COINLINKAGE Clp_getObjCoefficients(Clp_Simplex *model);
     436/** Column Lower */
     437COINLIBAPI const double *COINLINKAGE Clp_getColLower(Clp_Simplex *model);
     438/** Column Upper */
     439COINLIBAPI const double *COINLINKAGE Clp_getColUpper(Clp_Simplex *model);
     440/** Objective value */
     441COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex *model);
     442/** Print model for debugging purposes */
     443COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex *model, const char *prefix);
     444/* Small element value - elements less than this set to zero,
    447445        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)
     446COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex *model);
     447COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex *model, double value);
     448/*@}*/
     449
     450/**@name Get and set ClpSolve options
     451     */
     452/*@{*/
     453COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo);
     454COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which);
     455
     456/** method: (see ClpSolve::SolveType)
    460457         0 - dual simplex
    461458         1 - primal simplex
     
    466463         6 - not implemented
    467464       -- 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)
     465COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo);
     466COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *);
     467
     468/** amount: (see ClpSolve::PresolveType)
    472469         0 - presolve on
    473470         1 - presolve off
     
    475472         3 - presolve number cost
    476473       -- 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      /*@}*/
     474COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo);
     475COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *);
     476
     477COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *);
     478COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which);
     479COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse);
     480COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *);
     481
     482COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *);
     483COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual);
     484
     485COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *);
     486COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton);
     487
     488COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *);
     489COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton);
     490
     491COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *);
     492COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton);
     493
     494COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *);
     495COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten);
     496
     497COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *);
     498COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing);
     499
     500COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *);
     501COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree);
     502
     503COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *);
     504COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol);
     505
     506COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *);
     507COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow);
     508
     509COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *);
     510COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton);
     511
     512COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *);
     513COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action);
     514
     515COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *);
     516COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value);
     517
     518/*@}*/
    522519#ifdef __cplusplus
    523520}
    524521#endif
    525522#endif
     523
     524/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     525*/
Note: See TracChangeset for help on using the changeset viewer.