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

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

remove some unimplemented functions from C interface

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