source: trunk/Cbc/src/Cbc_C_Interface.cpp @ 2128

Last change on this file since 2128 was 2039, checked in by mlubin, 5 years ago

reenable SOS code

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.8 KB
RevLine 
[1573]1// $Id: Cbc_C_Interface.cpp 2039 2014-06-20 02:34:45Z forrest $
[2]2// Copyright (C) 2004, International Business Machines
3// Corporation and others.  All Rights Reserved.
[1573]4// This code is licensed under the terms of the Eclipse Public License (EPL).
[2]5
[2021]6#include <cmath>
[2]7#include <cfloat>
8
9#include "CoinPragma.hpp"
[571]10//#include "CoinHelperFunctions.hpp"
11//#include "CoinPackedMatrix.hpp"
[2]12#include "CoinTime.hpp"
13
14#include "CbcModel.hpp"
15#include "CbcBranchActual.hpp"
16
17#include "CoinMessageHandler.hpp"
18#include "OsiClpSolverInterface.hpp"
19
20//  bobe including extras.h to get strdup()
[1286]21#if defined(__MWERKS__)
[571]22// #include <extras.h>  // bobe 06-02-14
[2]23#endif
24
25// Get C stuff but with extern C
26#define CBC_EXTERN_C
27#include "Coin_C_defines.h"
28
[2019]29#define CbcGetProperty(T,prop) \
30COINLIBAPI T COINLINKAGE \
31Cbc_ ## prop (Cbc_Model *m) \
32{ \
33    return m->model_->prop(); \
34}
35
[2036]36#define CbcSetSolverProperty(T,prop) \
37COINLIBAPI void COINLINKAGE \
38Cbc_ ## prop (Cbc_Model *m, int index, T val) \
39{ \
40    m->model_->solver()->prop(index,val); \
41}
42
[2]43const int  VERBOSE = 0;
44
45// To allow call backs
[1286]46class Cbc_MessageHandler
47            : public CoinMessageHandler {
48
[2]49public:
[1286]50    /**@name Overrides */
51    //@{
52    virtual int print();
53    //@}
54    /**@name set and get */
55    //@{
56    /// Model
57    const Cbc_Model * model() const;
58    void setModel(Cbc_Model * model);
59    /// Call back
60    void setCallBack(cbc_callback callback);
61    //@}
[2]62
[1286]63    /**@name Constructors, destructor */
64    //@{
65    /** Default constructor. */
66    Cbc_MessageHandler();
67    /// Constructor with pointer to model
68    Cbc_MessageHandler(Cbc_Model * model,
69                       FILE * userPointer = NULL);
70    /** Destructor */
71    virtual ~Cbc_MessageHandler();
72    //@}
[2]73
[1286]74    /**@name Copy method */
75    //@{
76    /** The copy constructor. */
77    Cbc_MessageHandler(const Cbc_MessageHandler&);
78    /** The copy constructor from an CoinSimplexMessageHandler. */
79    Cbc_MessageHandler(const CoinMessageHandler&);
80
81    Cbc_MessageHandler& operator=(const Cbc_MessageHandler&);
82    /// Clone
83    virtual CoinMessageHandler * clone() const ;
84    //@}
85
86
[2]87protected:
[1286]88    /**@name Data members
89       The data members are protected to allow access for derived classes. */
90    //@{
91    /// Pointer back to model
92    Cbc_Model * model_;
93    /// call back
94    cbc_callback callback_;
95    //@}
[2]96};
97
98
99//-------------------------------------------------------------------
[1286]100// Default Constructor
[2]101//-------------------------------------------------------------------
[1286]102Cbc_MessageHandler::Cbc_MessageHandler ()
103        : CoinMessageHandler(),
104        model_(NULL),
105        callback_(NULL)
[2]106{
107}
108
109//-------------------------------------------------------------------
[1286]110// Copy constructor
[2]111//-------------------------------------------------------------------
[1286]112Cbc_MessageHandler::Cbc_MessageHandler (const Cbc_MessageHandler & rhs)
113        : CoinMessageHandler(rhs),
114        model_(rhs.model_),
115        callback_(rhs.callback_)
116{
[2]117}
118
[1286]119Cbc_MessageHandler::Cbc_MessageHandler (const CoinMessageHandler & rhs)
120        : CoinMessageHandler(rhs),
121        model_(NULL),
122        callback_(NULL)
123{
[2]124}
125
126// Constructor with pointer to model
127Cbc_MessageHandler::Cbc_MessageHandler(Cbc_Model * model,
[1286]128                                       FILE * /*userPointer*/)
129        : CoinMessageHandler(),
130        model_(model),
131        callback_(NULL)
[2]132{
133}
134
135//-------------------------------------------------------------------
[1286]136// Destructor
[2]137//-------------------------------------------------------------------
138Cbc_MessageHandler::~Cbc_MessageHandler ()
139{
140}
141
142//----------------------------------------------------------------
[1286]143// Assignment operator
[2]144//-------------------------------------------------------------------
145Cbc_MessageHandler &
[1286]146Cbc_MessageHandler::operator=(const Cbc_MessageHandler & rhs)
[2]147{
[1286]148    if (this != &rhs) {
149        CoinMessageHandler::operator=(rhs);
150        model_ = rhs.model_;
151        callback_ = rhs.callback_;
152    }
153    return *this;
[2]154}
155//-------------------------------------------------------------------
156// Clone
157//-------------------------------------------------------------------
158CoinMessageHandler * Cbc_MessageHandler::clone() const
159{
[1286]160    return new Cbc_MessageHandler(*this);
[2]161}
[1286]162int
[2]163Cbc_MessageHandler::print()
164{
[1286]165    if (callback_) {
166        int messageNumber = currentMessage().externalNumber();
167        if (currentSource() != "Cbc")
168            messageNumber += 1000000;
169        int i;
170        int nDouble = numberDoubleFields();
171        assert (nDouble <= 200);
172        double vDouble[200];
173        for (i = 0; i < nDouble; i++)
174            vDouble[i] = doubleValue(i);
175        int nInt = numberIntFields();
176        assert (nInt <= 200);
177        int vInt[200];
178        for (i = 0; i < nInt; i++)
179            vInt[i] = intValue(i);
180        int nString = numberStringFields();
181        assert (nString <= 200);
182        char * vString[200];
183        for (i = 0; i < nString; i++) {
184            std::string value = stringValue(i);
[1336]185            vString[i] = CoinStrdup(value.c_str());
[1286]186        }
187        callback_(model_, messageNumber,
188                  nDouble, vDouble,
189                  nInt, vInt,
190                  nString, vString);
191        for (i = 0; i < nString; i++)
192            free(vString[i]);
193
[2]194    }
[1286]195    return CoinMessageHandler::print();
196    return 0;
[2]197}
198const Cbc_Model *
199Cbc_MessageHandler::model() const
200{
[1286]201    return model_;
[2]202}
[1286]203void
[2]204Cbc_MessageHandler::setModel(Cbc_Model * model)
205{
[1286]206    model_ = model;
[2]207}
208// Call back
[1286]209void
[2]210Cbc_MessageHandler::setCallBack(cbc_callback callback)
211{
[1286]212    callback_ = callback;
[2]213}
214/**
215  *
216  *  C Interface Routines
217  *
218  */
219#include "Cbc_C_Interface.h"
220#include <string>
221#include <stdio.h>
222#include <iostream>
223
[1286]224#if defined(__MWERKS__)
[2]225#pragma export on
226#endif
227
[571]228/* Version */
[2021]229COINLIBAPI const char* COINLINKAGE Cbc_getVersion()
[571]230{
[2021]231    return CBC_VERSION;
[571]232}
233
[2]234/* Default Cbc_Model constructor */
[1286]235COINLIBAPI Cbc_Model *  COINLINKAGE
[2]236Cbc_newModel()
237{
[1286]238    const char prefix[] = "Cbc_C_Interface::Cbc_newModel(): ";
[571]239//  const int  VERBOSE = 1;
[1286]240    if (VERBOSE > 0) printf("%s begin\n", prefix);
241
[2019]242    Cbc_Model * model = new Cbc_Model();
[1286]243    OsiClpSolverInterface solver1;
244    model->solver_    = &solver1;
245    model->model_     = new CbcModel(solver1);
[2016]246    CbcMain0(*model->model_);
[1286]247    model->handler_   = NULL;
248
249    if (VERBOSE > 0) printf("%s return\n", prefix);
250    return model;
[2]251}
252/* Cbc_Model Destructor */
[1286]253COINLIBAPI void COINLINKAGE
[2]254Cbc_deleteModel(Cbc_Model * model)
255{
[1286]256    const char prefix[] = "Cbc_C_Interface::Cbc_deleteModel(): ";
[571]257//  const int  VERBOSE = 1;
[1286]258    if (VERBOSE > 0) printf("%s begin\n", prefix);
259    fflush(stdout);
[2]260
[1286]261    if (VERBOSE > 1) printf("%s delete model->model_\n", prefix);
262    fflush(stdout);
263    delete model->model_;
264
265    if (VERBOSE > 1) printf("%s delete model->handler_\n", prefix);
266    fflush(stdout);
267    delete model->handler_;
268
269    if (VERBOSE > 1) printf("%s delete model\n", prefix);
270    fflush(stdout);
271    delete model;
272
273    if (VERBOSE > 0) printf("%s return\n", prefix);
274    fflush(stdout);
[2]275}
276
277/* Loads a problem (the constraints on the
278    rows are given by lower and upper bounds). If a pointer is NULL then the
279    following values are the default:
280    <ul>
281    <li> <code>colub</code>: all columns have upper bound infinity
[1286]282    <li> <code>collb</code>: all columns have lower bound 0
[2]283    <li> <code>rowub</code>: all rows have upper bound infinity
284    <li> <code>rowlb</code>: all rows have lower bound -infinity
285    <li> <code>obj</code>: all variables have 0 objective coefficient
286    </ul>
287
288   Just like the other loadProblem() method except that the matrix is
[1286]289   given in a standard column major ordered format (without gaps).
[2]290*/
[1286]291COINLIBAPI void COINLINKAGE
[2]292Cbc_loadProblem (Cbc_Model * model,  const int numcols, const int numrows,
[1286]293                 const CoinBigIndex * start, const int* index,
294                 const double* value,
295                 const double* collb, const double* colub,
296                 const double* obj,
297                 const double* rowlb, const double* rowub)
[2]298{
[1286]299    const char prefix[] = "Cbc_C_Interface::Cbc_loadProblem(): ";
[2]300//  const int  VERBOSE = 2;
[1286]301    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]302
[1286]303    OsiSolverInterface * solver = model->model_->solver();
[2]304
[1286]305    if (VERBOSE > 1) {
306        printf("%s numcols = %i, numrows = %i\n",
307               prefix, numcols, numrows);
308        printf("%s model = %p, start = %p, index = %p, value = %p\n",
309               prefix, static_cast<void*>(model), static_cast<const void*>(start),
310               static_cast<const void*>(index), static_cast<const void*>(value));
311        printf("%s collb = %p, colub = %p, obj = %p, rowlb = %p, rowub = %p\n",
312               prefix, static_cast<const void*>(collb),
313               static_cast<const void*>(colub), static_cast<const void*>(obj),
314               static_cast<const void*>(rowlb), static_cast<const void*>(rowub));
315    }
[2]316
[1286]317    if (VERBOSE > 1) printf("%s Calling solver->loadProblem()\n", prefix);
318    fflush(stdout);
[2]319
[2016]320    solver->loadProblem(numcols, numrows, start, index, value,
321                        collb, colub, obj, rowlb, rowub);
[1286]322    if (VERBOSE > 1) printf("%s Finished solver->loadProblem()\n", prefix);
323    fflush(stdout);
324
325    if (VERBOSE > 0) printf("%s return\n", prefix);
[2]326} //  Cbc_loadProblem()
327
328/* Read an mps file from the given filename */
[1286]329COINLIBAPI int COINLINKAGE
330Cbc_readMps(Cbc_Model * model, const char *filename)
[2]331{
[1286]332    const char prefix[] = "Cbc_C_Interface::Cbc_readMps(): ";
[2]333//  const int  VERBOSE = 2;
[1286]334    if (VERBOSE > 0) printf("%s begin\n", prefix);
335    if (VERBOSE > 1) printf("%s filename = '%s'\n", prefix, filename);
[2]336
[1286]337    int result = 1;
338    result = model->model_->solver()->readMps(filename);
339    assert(result == 0);
[2]340
[1286]341    if (VERBOSE > 0) printf("%s return %i\n", prefix, result);
342    return result;
[2]343}
344/* Write an mps file from the given filename */
[1286]345COINLIBAPI void COINLINKAGE
346Cbc_writeMps(Cbc_Model * model, const char *filename)
[2]347{
[1286]348    const char prefix[] = "Cbc_C_Interface::Cbc_writeMps(): ";
[2]349//  const int  VERBOSE = 2;
[1286]350    if (VERBOSE > 0) printf("%s begin\n", prefix);
351    if (VERBOSE > 1) printf("%s filename = '%s'\n", prefix, filename);
[2]352
[2019]353    model->model_->solver()->writeMps(filename, "mps", Cbc_getObjSense(model));
[2]354
[1286]355    if (VERBOSE > 0) printf("%s return\n", prefix);
356    return;
[2]357}
358
[2032]359
360COINLIBAPI void COINLINKAGE
361Cbc_setInitialSolution(Cbc_Model *model, const double * sol)
362{
363    int n = Cbc_getNumCols(model);
364    // We need to manually compute the objective here for some reason
365    const double *objvec = Cbc_getObjCoefficients(model);
366    double objval = 0;
367    for (int i = 0; i < n; i++) {
368        objval += objvec[i]*sol[i];
369    }
370    model->model_->setBestSolution(sol, n, objval, true);
371}
372
[1286]373COINLIBAPI void COINLINKAGE
[2020]374Cbc_setParameter(Cbc_Model * model, const char * name, const char * value)
[2]375{
[2020]376    model->cmdargs_.push_back(std::string("-")+name);
377    model->cmdargs_.push_back(value);
378}
[2]379
380/* Fills in array with problem name  */
[1286]381COINLIBAPI void COINLINKAGE
[2]382Cbc_problemName(Cbc_Model * model, int maxNumberCharacters, char * array)
383{
[1286]384    std::string name;
385    model->model_->solver()->getStrParam(OsiProbName, name);
[2020]386    strncpy(array, name.c_str(), maxNumberCharacters);
[2]387}
388/* Sets problem name.  Must have \0 at end.  */
[1286]389COINLIBAPI int COINLINKAGE
[2020]390Cbc_setProblemName(Cbc_Model * model, const char * array)
[2]391{
[1286]392    bool result = false;
393    result = model->model_->solver()->setStrParam(OsiProbName, array);
[2]394
[1286]395    return (result) ? 1 : 0;
[2]396}
[2021]397
[2019]398CbcGetProperty(int, status)
[2]399
[2019]400CbcGetProperty(int, secondaryStatus)
[2]401
402/* Number of elements in matrix */
[1286]403COINLIBAPI int COINLINKAGE
[2]404Cbc_getNumElements(Cbc_Model * model)
405{
[1286]406    const char prefix[] = "Cbc_C_Interface::Cbc_getNumElements(): ";
[2]407//  const int  VERBOSE = 1;
[1286]408    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]409
[1286]410    int result = 0;
411    result = model->model_->getNumElements();
[2]412
[1286]413    if (VERBOSE > 0) printf("%s return %i\n", prefix, result);
414    return result;
[2]415}
416
[1286]417// Column starts in matrix
418COINLIBAPI const CoinBigIndex * COINLINKAGE
[703]419Cbc_getVectorStarts(Cbc_Model * model)
[2]420{
[1286]421    const CoinPackedMatrix * matrix = NULL;
422    matrix = model->model_->solver()->getMatrixByCol();
423    return (matrix == NULL) ? NULL : matrix->getVectorStarts();
[2]424}
[1286]425// Row indices in matrix
426COINLIBAPI const int * COINLINKAGE
[2]427Cbc_getIndices(Cbc_Model * model)
428{
[1286]429    const char prefix[] = "Cbc_C_Interface::Cbc_getIndices(): ";
[2]430//  const int  VERBOSE = 1;
[1286]431    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]432
[1286]433    const int * result = NULL;
434    const CoinPackedMatrix * matrix = NULL;
435    matrix = model->model_->solver()->getMatrixByCol();
436    result = (matrix == NULL) ? NULL : matrix->getIndices();
[2]437
[1286]438    if (VERBOSE > 0)
439        printf("%s return %p\n", prefix, static_cast<const void*>(result));
440    return result;
441}
[2]442
443
[1286]444// Element values in matrix
445COINLIBAPI const double * COINLINKAGE
[2]446Cbc_getElements(Cbc_Model * model)
447{
[1286]448    const char prefix[] = "Cbc_C_Interface::Cbc_getElements(): ";
[2]449//  const int  VERBOSE = 1;
[1286]450    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]451
[1286]452    const double * result = NULL;
453    const CoinPackedMatrix * matrix = NULL;
454    matrix = model->model_->solver()->getMatrixByCol();
455    result = (matrix == NULL) ? NULL : matrix->getElements();
[2]456
[1286]457    if (VERBOSE > 0)
458        printf("%s return %p\n", prefix, static_cast<const void*>(result));
459    return result;
[2]460}
461// ======================================================================
462
463
464
465/* Pass in Callback function */
[1286]466COINLIBAPI void COINLINKAGE
467Cbc_registerCallBack(Cbc_Model * model,
468                     cbc_callback userCallBack)
[2]469{
[1286]470    const char prefix[] = "Cbc_C_Interface::Cbc_registerCallBack(): ";
[2]471//  const int  VERBOSE = 1;
[1286]472    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]473
[1286]474    // Will be copy of users one
475    delete model->handler_;
476    model->handler_ = new Cbc_MessageHandler(*(model->model_->messageHandler()));
477    model->handler_->setCallBack(userCallBack);
478    model->handler_->setModel(model);
479    model->model_->passInMessageHandler(model->handler_);
[2]480
[1286]481    if (VERBOSE > 0) printf("%s return\n", prefix);
[2]482}
483/* Unset Callback function */
[1286]484COINLIBAPI void COINLINKAGE
[2]485Cbc_clearCallBack(Cbc_Model * model)
486{
[1286]487    const char prefix[] = "Cbc_C_Interface::Cbc_clearCallBack(): ";
[2]488//  const int  VERBOSE = 1;
[1286]489    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]490
[1286]491    delete model->handler_;
492    model->handler_ = NULL;
493
494    if (VERBOSE > 0) printf("%s return\n", prefix);
[2]495}
496/* length of names (0 means no names0 */
[2021]497COINLIBAPI size_t COINLINKAGE
498Cbc_maxNameLength(Cbc_Model * model)
[2]499{
[2021]500    size_t result = 0;
501    OsiSolverInterface::OsiNameVec const & rownames = model->model_->solver()->getRowNames();
502    for (size_t i = 0; i < rownames.size(); i++) {
503        if (rownames[i].length() > result) result = rownames[i].length();
504    }
505    OsiSolverInterface::OsiNameVec const & colnames = model->model_->solver()->getColNames();
506    for (size_t i = 0; i < colnames.size(); i++) {
507        if (colnames[i].length() > result) result = colnames[i].length();
508    }
[1286]509    return result;
[2]510}
[1286]511COINLIBAPI void COINLINKAGE
[2021]512Cbc_getRowName(Cbc_Model * model, int iRow, char * name, size_t maxLength)
[2]513{
[2021]514    std::string rowname = model->model_->solver()->getRowName(iRow);
515    strncpy(name, rowname.c_str(), maxLength);
516    name[maxLength-1] = '\0';
[2]517}
[1286]518COINLIBAPI void COINLINKAGE
[2021]519Cbc_getColName(Cbc_Model * model, int iRow, char * name, size_t maxLength)
[2]520{
[2021]521    std::string colname = model->model_->solver()->getColName(iRow);
522    strncpy(name, colname.c_str(), maxLength);
523    name[maxLength-1] = '\0';
524}
[1286]525
[2021]526COINLIBAPI void COINLINKAGE
527Cbc_setColName(Cbc_Model * model, int iColumn, const char * name)
528{
529    model->model_->solver()->setColName(iColumn, name);
530}
[2]531
[2021]532COINLIBAPI void COINLINKAGE
533Cbc_setRowName(Cbc_Model * model, int iRow, const char * name)
534{
535    model->model_->solver()->setRowName(iRow, name);
[2]536}
537
[2021]538
[1286]539COINLIBAPI int COINLINKAGE
[2016]540Cbc_solve(Cbc_Model * model)
541{
542    const char prefix[] = "Cbc_C_Interface::Cbc_solve(): ";
543    int result = 0;
[2020]544    std::vector<const char*> argv;
545    argv.push_back("Cbc_C_Interface");
546    for (size_t i = 0; i < model->cmdargs_.size(); i++) {
547        argv.push_back(model->cmdargs_[i].c_str());
548    }
549    argv.push_back("-solve");
550    argv.push_back("-quit");
[2016]551    try {
552       
[2020]553        CbcMain1((int)argv.size(), &argv[0], *model->model_);
[2016]554    } catch (CoinError e) {
555        printf("%s ERROR: %s::%s, %s\n", prefix,
556               e.className().c_str(), e.methodName().c_str(), e.message().c_str());
557    }
558    result = model->model_->status();
559
560    return result;
561}
[2]562
563/* Sum of primal infeasibilities */
[1286]564COINLIBAPI double COINLINKAGE
[1271]565Cbc_sumPrimalInfeasibilities(Cbc_Model * /*model*/)
[2]566{
[1286]567    const char prefix[] = "Cbc_C_Interface::Cbc_sumPrimalInfeasibilities(): ";
[2]568//  const int  VERBOSE = 1;
[1286]569    if (VERBOSE > 0) printf("%s begin\n", prefix);
570
571    double result = 0;
[2]572// cannot find names in Cbc, Osi, or OsiClp
573//tbd result = model->model_->sumPrimalInfeasibilities();
[1286]574    if (VERBOSE > 0) printf("%s WARNING:  NOT IMPLEMENTED\n", prefix);
[2]575
[1286]576    if (VERBOSE > 0) printf("%s return %g\n", prefix, result);
577    return result;
[2]578}
579/* Number of primal infeasibilities */
[1286]580COINLIBAPI int COINLINKAGE
[1271]581Cbc_numberPrimalInfeasibilities(Cbc_Model * /*model*/)
[2]582{
[1286]583    const char prefix[] = "Cbc_C_Interface::Cbc_numberPrimalInfeasibilities(): ";
[2]584//  const int  VERBOSE = 1;
[1286]585    if (VERBOSE > 0) printf("%s begin\n", prefix);
586
587    int result = 0;
[2]588//tbd  result = model->model_->getContinuousInfeasibilities();
[1286]589    if (VERBOSE > 0) printf("%s WARNING:  NOT IMPLEMENTED\n", prefix);
[2]590
[1286]591    if (VERBOSE > 0) printf("%s return %i\n", prefix, result);
592    return result;
[2]593}
[1286]594
[2]595
596/** Call this to really test if a valid solution can be feasible
597    Solution is number columns in size.
598    If fixVariables true then bounds of continuous solver updated.
599    Returns objective value (worse than cutoff if not feasible)
600*/
[1286]601COINLIBAPI void COINLINKAGE
[1271]602Cbc_checkSolution(Cbc_Model * /*model*/)
[2]603{
[1286]604    const char prefix[] = "Cbc_C_Interface::Cbc_checkSolution(): ";
[2]605//  const int  VERBOSE = 1;
[1286]606    if (VERBOSE > 0) printf("%s begin\n", prefix);
607
608    // see CbcModel::checkSolution(double cutoff, const double * solution,
609    //         bool fixVariables);
[2]610//  model->model_->checkSolution();
611
[1286]612    if (VERBOSE > 0) printf("%s return\n", prefix);
613    return;
[2]614}
615
[1286]616
[2]617
[2019]618CbcGetProperty(int, getNumCols)
619CbcGetProperty(int, getNumRows)
620CbcGetProperty(int, getIterationCount)
621CbcGetProperty(int, isAbandoned)
622CbcGetProperty(int, isProvenOptimal)
623CbcGetProperty(int, isProvenInfeasible)
624CbcGetProperty(int, isContinuousUnbounded)
625CbcGetProperty(int, isNodeLimitReached)
626CbcGetProperty(int, isSecondsLimitReached)
627CbcGetProperty(int, isSolutionLimitReached)
628CbcGetProperty(int, isInitialSolveAbandoned)
629CbcGetProperty(int, isInitialSolveProvenOptimal)
630CbcGetProperty(int, isInitialSolveProvenPrimalInfeasible)
[1286]631
[2019]632CbcGetProperty(double, getObjSense)
[2]633
[2019]634COINLIBAPI void COINLINKAGE
635Cbc_setObjSense(Cbc_Model * model, double sense)
[2]636{
[2019]637    model->model_->setObjSense(sense);
[2]638}
639
[2019]640CbcGetProperty(const double*, getRowActivity)
641CbcGetProperty(const double*, getColSolution)
[1286]642
[2019]643CbcGetProperty(const double*, getRowLower)
[2036]644CbcSetSolverProperty(double, setRowLower)
[2019]645CbcGetProperty(const double*, getRowUpper)
[2036]646CbcSetSolverProperty(double, setRowUpper)
[2019]647CbcGetProperty(const double*, getObjCoefficients)
[2036]648CbcSetSolverProperty(double, setObjCoeff)
[2019]649CbcGetProperty(const double*, getColLower)
[2036]650CbcSetSolverProperty(double, setColLower)
[2019]651CbcGetProperty(const double*, getColUpper)
[2036]652CbcSetSolverProperty(double, setColUpper)
[1286]653
[2019]654CbcGetProperty(double, getObjValue)
[2021]655CbcGetProperty(double, getBestPossibleObjValue)
[2]656
657/* Print model */
[1286]658COINLIBAPI void COINLINKAGE
[2]659Cbc_printModel(Cbc_Model * model, const char * argPrefix)
660{
[1286]661    const char prefix[] = "Cbc_C_Interface::Cbc_printModel(): ";
662    const int  VERBOSE = 4;
663    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]664
[1286]665    CbcModel *cbc_model = model->model_;
666    int numrows    = cbc_model->getNumRows();
667    int numcols    = cbc_model->getNumCols();
668    int numelem    = cbc_model->getNumElements();
669    const CoinPackedMatrix * matrix = cbc_model->solver()->getMatrixByCol();
670    const CoinBigIndex     * start  = matrix->getVectorStarts();
671    const int              * index  = matrix->getIndices();
672    const double           * value  = matrix->getElements();
673    const double           * collb  = cbc_model->getColLower();
674    const double           * colub  = cbc_model->getColUpper();
675    const double           * obj    = cbc_model->getObjCoefficients();
676    const double           * rowlb  = cbc_model->getRowLower();
677    const double           * rowub  = cbc_model->getRowUpper();
[2]678
[1286]679    printf("%s numcols = %i, numrows = %i, numelem = %i\n",
680           argPrefix, numcols, numrows, numelem);
681    printf("%s model = %p, start = %p, index = %p, value = %p\n",
682           argPrefix, static_cast<void*>(model), static_cast<const void*>(start),
683           static_cast<const void*>(index), static_cast<const void*>(value));
684    matrix->dumpMatrix(NULL);
685    {
686        int i;
687        for (i = 0; i <= numcols; i++)
688            printf("%s start[%i] = %i\n", argPrefix, i, start[i]);
689        for (i = 0; i < numelem; i++)
690            printf("%s index[%i] = %i, value[%i] = %g\n",
691                   argPrefix, i, index[i], i, value[i]);
692    }
693
694    printf("%s collb = %p, colub = %p, obj = %p, rowlb = %p, rowub = %p\n",
695           argPrefix, static_cast<const void*>(collb),
696           static_cast<const void*>(colub), static_cast<const void*>(obj),
697           static_cast<const void*>(rowlb), static_cast<const void*>(rowub));
[2019]698    printf("%s optimization direction = %g\n", argPrefix, Cbc_getObjSense(model));
[1286]699    printf("  (1 - minimize, -1 - maximize, 0 - ignore)\n");
700    {
701        int i;
702        for (i = 0; i < numcols; i++)
703            printf("%s collb[%i] = %g, colub[%i] = %g, obj[%i] = %g\n",
704                   argPrefix, i, collb[i], i, colub[i], i, obj[i]);
705        for (i = 0; i < numrows; i++)
706            printf("%s rowlb[%i] = %g, rowub[%i] = %g\n",
707                   argPrefix, i, rowlb[i], i, rowub[i]);
708    }
709
710    if (VERBOSE > 0) printf("%s return\n", prefix);
[2]711}  // Cbc_printModel()
712
[1286]713COINLIBAPI int COINLINKAGE
[2]714Cbc_isInteger(Cbc_Model * model, int i)
715{
[1286]716    const char prefix[] = "Cbc_C_Interface::Cbc_isInteger(): ";
[2]717//  const int  VERBOSE = 1;
[1286]718    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]719
[1286]720    bool result = false;
721    result = model->model_->isInteger(i);
722
723    if (VERBOSE > 0) printf("%s return %i\n", prefix, result);
724    return (result) ? 1 : 0;
[2]725}
726
[2019]727CbcGetProperty(int, getNodeCount)
[1286]728
[2]729/** Return a copy of this model */
[1286]730COINLIBAPI Cbc_Model * COINLINKAGE
[703]731Cbc_clone(Cbc_Model * model)
[2]732{
[1286]733    const char prefix[] = "Cbc_C_Interface::Cbc_clone(): ";
[703]734//  const int  VERBOSE = 1;
[1286]735    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]736
[2019]737    Cbc_Model * result = new Cbc_Model();
[1286]738    result->model_     = new CbcModel(*(model->model_));
739    result->solver_    = dynamic_cast< OsiClpSolverInterface*> (result->model_->solver());
740    result->handler_   = NULL;
[2021]741    result->cmdargs_   = model->cmdargs_;
[1286]742
743    if (VERBOSE > 0) printf("%s return\n", prefix);
744    return model;
[2]745}
746/** Set this the variable to be continuous */
[2038]747COINLIBAPI void COINLINKAGE
[703]748Cbc_setContinuous(Cbc_Model * model, int iColumn)
[2]749{
[1286]750    const char prefix[] = "Cbc_C_Interface::Cbc_setContinuous(): ";
[2]751//  const int  VERBOSE = 1;
[1286]752    if (VERBOSE > 0) printf("%s begin\n", prefix);
[2]753
[1286]754    model->model_->solver()->setContinuous(iColumn);
755
756    if (VERBOSE > 0) printf("%s return\n", prefix);
[2]757}
[2019]758/** Set this the variable to be integer */
[2038]759COINLIBAPI void COINLINKAGE
[2019]760Cbc_setInteger(Cbc_Model * model, int iColumn)
761{
762    const char prefix[] = "Cbc_C_Interface::Cbc_setContinuous(): ";
763//  const int  VERBOSE = 1;
764    if (VERBOSE > 0) printf("%s begin\n", prefix);
765
766    model->model_->solver()->setInteger(iColumn);
767
768    if (VERBOSE > 0) printf("%s return\n", prefix);
769}
[703]770/** Add SOS constraints to the model using row-order matrix */
[2039]771
[1286]772COINLIBAPI void  COINLINKAGE
[2033]773Cbc_addSOS(Cbc_Model * model, int numRows, const int * rowStarts,
774           const int * colIndices, const double * weights, const int type)
[571]775{
[2033]776    const char prefix[] = "Cbc_C_Interface::Cbc_addSOS(): ";
777  //const int  VERBOSE = 4;
[1286]778    if (VERBOSE > 0) printf("%sbegin\n", prefix);
779
780    if (VERBOSE > 0) printf("%s numRows = %i\n", prefix, numRows);
781
782    int row, i;
783    const int *colIndex;
784    const double *colWeight;
785
786    // loop on rows and count number of objects according to numWeights>0
787    int numObjects = 0;
788    for (row = 0; row < numRows; row++) {
789        if (VERBOSE > 2) {
790            printf("%s row = %i\n", prefix, row);
791            printf("%s rowStarts[%i] = %i\n", prefix, row, rowStarts[row]);
792            printf("%s rowStarts[%i+1] = %i\n", prefix, row, rowStarts[row+1]);
793            fflush(stdout);
794        }
795        const int numWeights = rowStarts[row+1] - rowStarts[row];
796        if (VERBOSE > 2) printf("%s  numWeights = %i\n", prefix, numWeights);
797        if (numWeights > 0) numObjects++;
[571]798    }
[1286]799
800    // make objects
801    CbcObject ** objects = new CbcObject * [numObjects];
[571]802//  if (VERBOSE>1) printf("%s numObjects = %i, objects = %X\n",prefix,numObjects,objects);
803
[1286]804    // loop on rows and make an object when numWeights>0
805    int objNum = 0;
806    for (row = 0; row < numRows; row++) {
807        if (VERBOSE > 2) {
808            printf("%s row = %i\n", prefix, row);
809            printf("%s rowStarts[%i] = %i\n", prefix, row, rowStarts[row]);
810            printf("%s rowStarts[%i+1] = %i\n", prefix, row, rowStarts[row+1]);
[571]811        }
[1286]812        const int numWeights = rowStarts[row+1] - rowStarts[row];
813        if (VERBOSE > 2) printf("%s  numWeights = %i\n", prefix, numWeights);
[2033]814        colIndex    = colIndices + rowStarts[row];
[1286]815        colWeight   = weights + rowStarts[row];
816        if (numWeights > 0) {
817            // Make a CbcSOS and assign it to objects
818            if (VERBOSE > 3) {
819                for (i = 0; i < numWeights; i++) {
820                    printf("%s  colIndex [%i] = %i\n", prefix, i, colIndex[i]);
821                    printf("%s  colWeight[%i] = %f\n", prefix, i, colWeight[i]);
822                }
823                fflush(stdout);
824            }
825            objects[objNum] = new CbcSOS(model->model_, (int)(numWeights),
826                                         (const int*)colIndex, (const double*)colWeight, (int)objNum, (int)type);
[571]827//      if (VERBOSE>2) printf("%s objects[%i] = %X\n",prefix,objNum,objects[objNum]);
[1286]828            if (objects[objNum] == NULL) {
829                printf("%s ERROR: objects[%i] == NULL\n", prefix, objNum);
830                fflush(stdout);
831                assert(objects[objNum] != NULL);
832            }
833            objNum++;
834        }
835    }
836    if (VERBOSE > 2) {
837        printf("%s calling addObjects()\n", prefix);
[2036]838       
839        //    printf("%s numObjects = %i, objects = %X\n",prefix,numObjects,objects);
840        //    for (row=0; row<numObjects; row++)
841        //      printf("%s  objects[%i] = %X\n",prefix,row,objects[row]);
842       
[1286]843    }
844    fflush(stdout);
845    model->model_->addObjects(numObjects, objects);
846    if (VERBOSE > 1) printf("%s finished addObjects()\n", prefix);
[571]847
[1286]848    for (objNum = 0; objNum < numObjects; objNum++) delete objects[objNum];
849    delete [] objects;
850
851    if (VERBOSE > 0) printf("%sreturn\n", prefix);
852    return;
[2039]853}
[571]854
[703]855/** Print the solution */
[1286]856COINLIBAPI void  COINLINKAGE
[2]857Cbc_printSolution(Cbc_Model * model)
858{
[1286]859    {
860        //
861        //  Now to print out row solution.  The methods used return const
862        //  pointers - which is of course much more virtuous.
863        //
864        //  This version just does non-zero columns
865        //
[2]866
[1286]867        // * Rows
868
869        int numberRows = Cbc_getNumRows(model);
870        int iRow;
871
872
873        const double * rowPrimal = Cbc_getRowActivity(model);
874        const double * rowLower = Cbc_getRowLower(model);
875        const double * rowUpper = Cbc_getRowUpper(model);
876        printf("--------------------------------------\n");
877
878        // * If we have not kept names (parameter to readMps) this will be 0
879        //    assert(Cbc_lengthNames(model));
880
[2019]881        printf("                       Primal          Lower         Upper\n");
[1286]882        for (iRow = 0; iRow < numberRows; iRow++) {
883            double value;
884            value = rowPrimal[iRow];
885            if (value > 1.0e-8 || value < -1.0e-8) {
886                char name[20];
887                //              Cbc_columnName(model,iColumn,name);
888                sprintf(name, "ROW%5i", iRow);
889                printf("%6d %8s", iRow, name);
890                printf(" %13g", rowPrimal[iRow]);
891                printf(" %13g", rowLower[iRow]);
892                printf(" %13g", rowUpper[iRow]);
893                printf("\n");
894            }
895        }
896        printf("--------------------------------------\n");
[2]897    }
[1286]898    {
899        //
900        //  Now to print out column solution.  The methods used return const
901        //  pointers - which is of course much more virtuous.
902        //
903        //  This version just does non-zero columns
904        //
905        //
[2]906
[1286]907        // * Columns
[2]908
[2019]909        int numberColumns = Cbc_getNumCols(model);
[1286]910        int iColumn;
[2]911
[1286]912
913        const double * columnPrimal = Cbc_getColSolution(model);
914        const double * columnLower = Cbc_getColLower(model);
915        const double * columnUpper = Cbc_getColUpper(model);
916        const double * columnObjective = Cbc_getObjCoefficients(model);
917
918        printf("--------------------------------------\n");
919
920        // * If we have not kept names (parameter to readMps) this will be 0
[2]921//    assert(Cbc_lengthNames(model));
[1286]922
[2019]923        printf("                       Primal          Lower         Upper          Cost     isInteger\n");
[1286]924        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
925            double value;
926            value = columnPrimal[iColumn];
927            if (value > 1.0e-8 || value < -1.0e-8) {
928                char name[20];
[2]929//              Cbc_columnName(model,iColumn,name);
[1286]930                sprintf(name, "COL%5i", iColumn);
931                printf("%6d %8s", iColumn, name);
932                printf(" %13g", columnPrimal[iColumn]);
933                printf(" %13g", columnLower[iColumn]);
934                printf(" %13g", columnUpper[iColumn]);
935                printf(" %13g", columnObjective[iColumn]);
[2019]936                printf(" %13i", Cbc_isInteger(model,iColumn));
[1286]937                printf("\n");
938            }
939        }
940        printf("--------------------------------------\n");
[2]941    }
[1286]942    if (0) Cbc_printModel(model, "cbc::main(): ");
943    return;
[2]944}
[2019]945
[1286]946#if defined(__MWERKS__)
[2]947#pragma export off
948#endif
[1432]949
Note: See TracBrowser for help on using the repository browser.