Clp_C_Interface.h

Go to the documentation of this file.

/* $Id: Clp_C_Interface.h 2019 2014-01-31 05:18:01Z stefan $ */
/*
  Copyright (C) 2002, 2003 International Business Machines Corporation
  and others.  All Rights Reserved.

  This code is licensed under the terms of the Eclipse Public License (EPL).
*/
#ifndef ClpSimplexC_H
#define ClpSimplexC_H

/* include all defines and ugly stuff */
#include "Coin_C_defines.h"

#if defined (CLP_EXTERN_C)
typedef struct {
  ClpSolve options;
} Clp_Solve;
#else
typedef void Clp_Solve;
#endif

#ifdef __cplusplus
extern "C" {
#endif

     COINLIBAPI const char* COINLINKAGE Clp_Version(void);
     COINLIBAPI int COINLINKAGE Clp_VersionMajor(void);
     COINLIBAPI int COINLINKAGE Clp_VersionMinor(void);
     COINLIBAPI int COINLINKAGE Clp_VersionRelease(void);

     COINLIBAPI Clp_Simplex * COINLINKAGE Clp_newModel(void);
     COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex * model);
     COINLIBAPI Clp_Solve * COINLINKAGE ClpSolve_new();
     COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve * solve);
     COINLIBAPI void COINLINKAGE Clp_loadProblem (Clp_Simplex * model,  const int numcols, const int numrows,
               const CoinBigIndex * start, const int* index,
               const double* value,
               const double* collb, const double* colub,
               const double* obj,
               const double* rowlb, const double* rowub);

     /* read quadratic part of the objective (the matrix part) */
     COINLIBAPI void COINLINKAGE
     Clp_loadQuadraticObjective(Clp_Simplex * model,
                                const int numberColumns,
                                const CoinBigIndex * start,
                                const int * column,
                                const double * element);
     COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex * model, const char *filename,
                                            int keepNames,
                                            int ignoreErrors);
     COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex * model, const char * information);
     COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_resize (Clp_Simplex * model, int newNumberRows, int newNumberColumns);
     COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex * model, int number, const int * which);
     COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex * model, int number, const double * rowLower,
                                             const double * rowUpper,
                                             const int * rowStarts, const int * columns,
                                             const double * elements);

     COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex * model, int number, const int * which);
     COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex * model, int number, const double * columnLower,
               const double * columnUpper,
               const double * objective,
               const int * columnStarts, const int * rows,
               const double * elements);
     COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex * model, const double * rowLower);
     COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex * model, const double * rowUpper);
     COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex * model, const double * columnLower);
     COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex * model, const double * columnUpper);
     COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex * model, const double * objIn);
     COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex * model, const char * const * rowNames,
               const char * const * columnNames);

     COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex * model);
     COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex * model,  double value) ;
     COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex * model,  double value) ;
     COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex * model, double value);
     COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex * model, double value);
     COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex * model, int maxNumberCharacters, char * array);
     /* Sets problem name.  Must have \0 at end.  */
     COINLIBAPI int COINLINKAGE
     Clp_setProblemName(Clp_Simplex * model, int maxNumberCharacters, char * array);
     COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex * model, int numberIterations);
     COINLIBAPI int maximumIterations(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex * model, int value);
     COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex * model, double value);
     COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex * model, int problemStatus);
     COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex * model, int status);
     COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex * model, double value);
     COINLIBAPI double * COINLINKAGE Clp_primalRowSolution(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_primalColumnSolution(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_dualRowSolution(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_dualColumnSolution(Clp_Simplex * model);
     COINLIBAPI double* COINLINKAGE Clp_rowLower(Clp_Simplex * model);
     COINLIBAPI double* COINLINKAGE Clp_rowUpper(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_objective(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_columnLower(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_columnUpper(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_getNumElements(Clp_Simplex * model);
     /* Column starts in matrix */
     COINLIBAPI const CoinBigIndex * COINLINKAGE Clp_getVectorStarts(Clp_Simplex * model);
     /* Row indices in matrix */
     COINLIBAPI const int * COINLINKAGE Clp_getIndices(Clp_Simplex * model);
     /* Column vector lengths in matrix */
     COINLIBAPI const int * COINLINKAGE Clp_getVectorLengths(Clp_Simplex * model);
     /* Element values in matrix */
     COINLIBAPI const double * COINLINKAGE Clp_getElements(Clp_Simplex * model);
     COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex * model);
     COINLIBAPI char * COINLINKAGE Clp_integerInformation(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_infeasibilityRay(Clp_Simplex * model);
     COINLIBAPI double * COINLINKAGE Clp_unboundedRay(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex * model, double * ray);
     COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex * model);
     COINLIBAPI unsigned char *  COINLINKAGE Clp_statusArray(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex * model, const unsigned char * statusArray);
     /* status values are as in ClpSimplex.hpp i.e. 0 - free, 1 basic, 2 at upper,
        3 at lower, 4 superbasic, (5 fixed) */
     /* Get variable basis info */
     COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex * model, int sequence);
     /* Get row basis info */
     COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex * model, int sequence);
     /* Set variable basis info (and value if at bound) */
     COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex * model,
               int sequence, int value);
     /* Set row basis info (and value if at bound) */
     COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex * model,
               int sequence, int value);

     COINLIBAPI void COINLINKAGE Clp_setUserPointer (Clp_Simplex * model, void * pointer);
     COINLIBAPI void * COINLINKAGE Clp_getUserPointer (Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex * model,
               clp_callback userCallBack);
     COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex * model, int value);
     COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex * model, int iRow, char * name);
     COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex * model, int iColumn, char * name);

     COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex * model, Clp_Solve *);
     COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex * model, int ifValuesPass);
     COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex * model, int ifValuesPass);
#ifndef SLIM_CLP

     COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex * model, int tryhard);
#endif

     COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex * model, int mode);
     COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex * model, double gap, int pivot);
     COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex * model);
     COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex * model, double value);
     COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex * model, double value);
     COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex * model, int value);
     COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex * model, int value);
     COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex * model);
     COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex * model, const char * fileName);
     COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex * model, const char * fileName);

     COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex * model);
     /******************** End of most useful part **************/
     COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex * model);
     COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex * model) ;
     COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex * model) ;
     COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex * model);
     COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex * model, double objsen);
     COINLIBAPI const double * COINLINKAGE Clp_getRowActivity(Clp_Simplex * model);
     COINLIBAPI const double * COINLINKAGE Clp_getColSolution(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex * model, const double * input);
     COINLIBAPI const double * COINLINKAGE Clp_getRowPrice(Clp_Simplex * model);
     COINLIBAPI const double * COINLINKAGE Clp_getReducedCost(Clp_Simplex * model);
     COINLIBAPI const double* COINLINKAGE Clp_getRowLower(Clp_Simplex * model);
     COINLIBAPI const double* COINLINKAGE Clp_getRowUpper(Clp_Simplex * model);
     COINLIBAPI const double * COINLINKAGE Clp_getObjCoefficients(Clp_Simplex * model);
     COINLIBAPI const double * COINLINKAGE Clp_getColLower(Clp_Simplex * model);
     COINLIBAPI const double * COINLINKAGE Clp_getColUpper(Clp_Simplex * model);
     COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex * model, const char * prefix);
     /* Small element value - elements less than this set to zero,
        default is 1.0e-20 */
     COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex * model);
     COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex * model, double value);
     COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo);
     COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which);

     COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo);
     COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *);

     COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo);
     COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *);

     COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *);
     COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which);
     COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse);
     COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *);

     COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual);

     COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton);

     COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton);

     COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton);

     COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten);

     COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing);

     COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree);
     
     COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol);
     
     COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow);

     COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton);

     COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action);

     COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *);
     COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value);

#ifdef __cplusplus
}
#endif
#endif