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

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

Disable non-working SOS constraints
Add non-working attempt at problem modification

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