Clp_C_Interface.h

Go to the documentation of this file.

/* $Id: Clp_C_Interface.h 2385 2019-01-06 19:43:06Z unxusr $ */
/*
  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 CoinBigIndex *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 CoinBigIndex *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 CoinBigIndex 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

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/