# CbcLinked.hpp

Go to the documentation of this file.

    00001 /* $Id: CbcLinked.hpp 1902 2013-04-10 16:58:16Z stefan $ */
    00002 // Copyright (C) 2006, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00005
    00006 #ifndef CglLinked_H
    00007 #define CglLinked_H
    00008 /* THIS CONTAINS STUFF THAT SHOULD BE IN
    00009    OsiSolverLink
    00010    OsiBranchLink
    00011    CglTemporary
    00012 */
    00013 #include "CoinModel.hpp"
    00014 #include "OsiClpSolverInterface.hpp"
    00015 #include "OsiChooseVariable.hpp"
    00016 #include "CbcFathom.hpp"
    00017 class CbcModel;
    00018 class CoinPackedMatrix;
    00019 class OsiLinkedBound;
    00020 class OsiObject;
    00021 class CglStored;
    00022 class CglTemporary;
    00029 class OsiSolverLink : public CbcOsiSolver {
    00030
    00031 public:
    00032     //---------------------------------------------------------------------------
    00035
    00036     virtual void initialSolve();
    00037
    00039     virtual void resolve();
    00040
    00048     virtual int fathom(bool allFixed) ;
    00055     double * nonlinearSLP(int numberPasses, double deltaTolerance);
    00059     double linearizedBAB(CglStored * cut) ;
    00068     double * heuristicSolution(int numberPasses, double deltaTolerance, int mode);
    00069
    00071     int doAOCuts(CglTemporary * cutGen, const double * solution, const double * solution2);
    00073
    00074
    00077
    00078     OsiSolverLink ();
    00079
    00092     OsiSolverLink(  CoinModel & modelObject);
    00093     // Other way with existing object
    00094     void load(  CoinModel & modelObject, bool tightenBounds = false, int logLevel = 1);
    00096     virtual OsiSolverInterface * clone(bool copyData = true) const;
    00097
    00099     OsiSolverLink (const OsiSolverLink &);
    00100
    00102     OsiSolverLink & operator=(const OsiSolverLink& rhs);
    00103
    00105     virtual ~OsiSolverLink ();
    00106
    00108
    00109
    00112
    00113     void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable, int whichVariableAffected,
    00114                           double multiplier = 1.0);
    00116     int updateCoefficients(ClpSimplex * solver, CoinPackedMatrix * matrix);
    00118     void analyzeObjects();
    00120     void addTighterConstraints();
    00122     inline double bestObjectiveValue() const {
    00123         return bestObjectiveValue_;
    00124     }
    00126     inline void setBestObjectiveValue(double value) {
    00127         bestObjectiveValue_ = value;
    00128     }
    00130     inline const double * bestSolution() const {
    00131         return bestSolution_;
    00132     }
    00134     void setBestSolution(const double * solution, int numberColumns);
    00136     inline void setSpecialOptions2(int value) {
    00137         specialOptions2_ = value;
    00138     }
    00140     void sayConvex(bool convex);
    00142     inline int specialOptions2() const {
    00143         return specialOptions2_;
    00144     }
    00148     CoinPackedMatrix * cleanMatrix() const {
    00149         return matrix_;
    00150     }
    00155     CoinPackedMatrix * originalRowCopy() const {
    00156         return originalRowCopy_;
    00157     }
    00159     ClpSimplex * quadraticModel() const {
    00160         return quadraticModel_;
    00161     }
    00163     CoinPackedMatrix * quadraticRow(int rowNumber, double * linear) const;
    00165     inline double defaultMeshSize() const {
    00166         return defaultMeshSize_;
    00167     }
    00168     inline void setDefaultMeshSize(double value) {
    00169         defaultMeshSize_ = value;
    00170     }
    00172     inline double defaultBound() const {
    00173         return defaultBound_;
    00174     }
    00175     inline void setDefaultBound(double value) {
    00176         defaultBound_ = value;
    00177     }
    00179     inline void setIntegerPriority(int value) {
    00180         integerPriority_ = value;
    00181     }
    00183     inline int integerPriority() const {
    00184         return integerPriority_;
    00185     }
    00187     inline int objectiveVariable() const {
    00188         return objectiveVariable_;
    00189     }
    00191     inline void setBiLinearPriority(int value) {
    00192         biLinearPriority_ = value;
    00193     }
    00195     inline int biLinearPriority() const {
    00196         return biLinearPriority_;
    00197     }
    00199     inline const CoinModel * coinModel() const {
    00200         return &coinModel_;
    00201     }
    00203     void setBiLinearPriorities(int value, double meshSize = 1.0);
    00211     void setBranchingStrategyOnVariables(int strategyValue, int priorityValue = -1,
    00212                                          int mode = 7);
    00214     void setMeshSizes(double value);
    00218     void setFixedPriority(int priorityValue);
    00220
    00221     //---------------------------------------------------------------------------
    00222
    00223 protected:
    00224
    00225
    00228
    00229     //void initialize(ClpSimplex * & solver, OsiObject ** & object) const;
    00231     void gutsOfDestructor(bool justNullify = false);
    00233     void gutsOfCopy(const OsiSolverLink & rhs) ;
    00235
    00241     CoinPackedMatrix * matrix_;
    00245     CoinPackedMatrix * originalRowCopy_;
    00247     ClpSimplex * quadraticModel_;
    00249     int numberNonLinearRows_;
    00251     int * startNonLinear_;
    00253     int * rowNonLinear_;
    00257     int * convex_;
    00259     int * whichNonLinear_;
    00261     CoinModel coinModel_;
    00263     int numberVariables_;
    00265     OsiLinkedBound * info_;
    00273     int specialOptions2_;
    00275     int objectiveRow_;
    00277     int objectiveVariable_;
    00279     double bestObjectiveValue_;
    00281     double defaultMeshSize_;
    00283     double defaultBound_;
    00285     double * bestSolution_;
    00287     int integerPriority_;
    00289     int biLinearPriority_;
    00291     int numberFix_;
    00293     int * fixVariables_;
    00295 };
    00300 class OsiLinkedBound {
    00301
    00302 public:
    00303     //---------------------------------------------------------------------------
    00306
    00307     void updateBounds(ClpSimplex * solver);
    00309
    00310
    00313
    00314     OsiLinkedBound ();
    00316     OsiLinkedBound(OsiSolverInterface * model, int variable,
    00317                    int numberAffected, const int * positionL,
    00318                    const int * positionU, const double * multiplier);
    00319
    00321     OsiLinkedBound (const OsiLinkedBound &);
    00322
    00324     OsiLinkedBound & operator=(const OsiLinkedBound& rhs);
    00325
    00327     ~OsiLinkedBound ();
    00328
    00330
    00333
    00334     inline int variable() const {
    00335         return variable_;
    00336     }
    00338     void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable,
    00339                           double multiplier = 1.0);
    00341
    00342 private:
    00343     typedef struct {
    00344         double multiplier; // to use in computation
    00345         int affected; // variable or element affected
    00346         /*
    00347           0 - LB of variable affected
    00348           1 - UB of variable affected
    00349           2 - element in position (affected) affected
    00350         */
    00351         unsigned char affect;
    00352         unsigned char ubUsed; // nonzero if UB of this variable is used
    00353         /*
    00354            0 - use x*multiplier
    00355            1 - use multiplier/x
    00356            2 - if UB use min of current upper and x*multiplier, if LB use max of current lower and x*multiplier
    00357         */
    00358         unsigned char type; // type of computation
    00359     } boundElementAction;
    00360
    00363
    00364     OsiSolverInterface * model_;
    00366     int variable_;
    00368     int numberAffected_;
    00370     int maximumAffected_;
    00372     boundElementAction * affected_;
    00374 };
    00375 #include "CbcHeuristic.hpp"
    00379 class CbcHeuristicDynamic3 : public CbcHeuristic {
    00380 public:
    00381
    00382     // Default Constructor
    00383     CbcHeuristicDynamic3 ();
    00384
    00385     /* Constructor with model
    00386      */
    00387     CbcHeuristicDynamic3 (CbcModel & model);
    00388
    00389     // Copy constructor
    00390     CbcHeuristicDynamic3 ( const CbcHeuristicDynamic3 &);
    00391
    00392     // Destructor
    00393     ~CbcHeuristicDynamic3 ();
    00394
    00396     virtual CbcHeuristic * clone() const;
    00397
    00399     virtual void setModel(CbcModel * model);
    00400
    00401     using CbcHeuristic::solution ;
    00412     virtual int solution(double & objectiveValue,
    00413                          double * newSolution);
    00415     virtual void resetModel(CbcModel * model);
    00417     virtual bool canDealWithOdd() const {
    00418         return true;
    00419     }
    00420
    00421 protected:
    00422 private:
    00424     CbcHeuristicDynamic3 & operator=(const CbcHeuristicDynamic3& rhs);
    00425 };
    00426
    00427 #include "OsiBranchingObject.hpp"
    00428
    00432 class CoinWarmStartBasis;
    00433
    00434 class OsiOldLink : public OsiSOS {
    00435
    00436 public:
    00437
    00438     // Default Constructor
    00439     OsiOldLink ();
    00440
    00447     OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
    00448                 int numberLinks, int first,
    00449                 const double * weights, int setNumber);
    00456     OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
    00457                 int numberLinks, int typeSOS, const int * which,
    00458                 const double * weights, int setNumber);
    00459
    00460     // Copy constructor
    00461     OsiOldLink ( const OsiOldLink &);
    00462
    00464     virtual OsiObject * clone() const;
    00465
    00466     // Assignment operator
    00467     OsiOldLink & operator=( const OsiOldLink& rhs);
    00468
    00469     // Destructor
    00470     virtual ~OsiOldLink ();
    00471
    00472     using OsiObject::infeasibility ;
    00474     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
    00475
    00476     using OsiObject::feasibleRegion ;
    00482     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
    00483
    00488     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
    00489
    00491     virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
    00492
    00494     inline int numberLinks() const {
    00495         return numberLinks_;
    00496     }
    00497
    00500     virtual bool canDoHeuristics() const {
    00501         return false;
    00502     }
    00505     virtual bool boundBranch() const {
    00506         return false;
    00507     }
    00508
    00509 private:
    00511
    00513     int numberLinks_;
    00514 };
    00518 class OsiOldLinkBranchingObject : public OsiSOSBranchingObject {
    00519
    00520 public:
    00521
    00522     // Default Constructor
    00523     OsiOldLinkBranchingObject ();
    00524
    00525     // Useful constructor
    00526     OsiOldLinkBranchingObject (OsiSolverInterface * solver,  const OsiOldLink * originalObject,
    00527                                int way,
    00528                                double separator);
    00529
    00530     // Copy constructor
    00531     OsiOldLinkBranchingObject ( const OsiOldLinkBranchingObject &);
    00532
    00533     // Assignment operator
    00534     OsiOldLinkBranchingObject & operator=( const OsiOldLinkBranchingObject& rhs);
    00535
    00537     virtual OsiBranchingObject * clone() const;
    00538
    00539     // Destructor
    00540     virtual ~OsiOldLinkBranchingObject ();
    00541
    00542     using OsiBranchingObject::branch ;
    00544     virtual double branch(OsiSolverInterface * solver);
    00545
    00546     using OsiBranchingObject::print ;
    00549     virtual void print(const OsiSolverInterface * solver = NULL);
    00550 private:
    00552 };
    00558 class OsiOneLink {
    00559
    00560 public:
    00561
    00562     // Default Constructor
    00563     OsiOneLink ();
    00564
    00568     OsiOneLink (const OsiSolverInterface * solver, int xRow, int xColumn, int xyRow,
    00569                 const char * functionString);
    00570
    00571     // Copy constructor
    00572     OsiOneLink ( const OsiOneLink &);
    00573
    00574     // Assignment operator
    00575     OsiOneLink & operator=( const OsiOneLink& rhs);
    00576
    00577     // Destructor
    00578     virtual ~OsiOneLink ();
    00579
    00581
    00583     int xRow_;
    00585     int xColumn_;
    00587     int xyRow;
    00589     std::string function_;
    00590 };
    00600 class OsiLink : public OsiSOS {
    00601
    00602 public:
    00603
    00604     // Default Constructor
    00605     OsiLink ();
    00606
    00610     OsiLink (const OsiSolverInterface * solver, int yRow,
    00611              int yColumn, double meshSize);
    00612
    00613     // Copy constructor
    00614     OsiLink ( const OsiLink &);
    00615
    00617     virtual OsiObject * clone() const;
    00618
    00619     // Assignment operator
    00620     OsiLink & operator=( const OsiLink& rhs);
    00621
    00622     // Destructor
    00623     virtual ~OsiLink ();
    00624
    00625     using OsiObject::infeasibility ;
    00627     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
    00628
    00629     using OsiObject::feasibleRegion ;
    00635     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
    00636
    00641     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
    00642
    00644     virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
    00645
    00647     inline int numberLinks() const {
    00648         return numberLinks_;
    00649     }
    00650
    00653     virtual bool canDoHeuristics() const {
    00654         return false;
    00655     }
    00658     virtual bool boundBranch() const {
    00659         return false;
    00660     }
    00661
    00662 private:
    00665     double meshSize_;
    00667     OsiOneLink * data_;
    00669     int numberLinks_;
    00671     int yRow_;
    00673     int yColumn_;
    00674 };
    00678 class OsiLinkBranchingObject : public OsiTwoWayBranchingObject {
    00679
    00680 public:
    00681
    00682     // Default Constructor
    00683     OsiLinkBranchingObject ();
    00684
    00685     // Useful constructor
    00686     OsiLinkBranchingObject (OsiSolverInterface * solver,  const OsiLink * originalObject,
    00687                             int way,
    00688                             double separator);
    00689
    00690     // Copy constructor
    00691     OsiLinkBranchingObject ( const OsiLinkBranchingObject &);
    00692
    00693     // Assignment operator
    00694     OsiLinkBranchingObject & operator=( const OsiLinkBranchingObject& rhs);
    00695
    00697     virtual OsiBranchingObject * clone() const;
    00698
    00699     // Destructor
    00700     virtual ~OsiLinkBranchingObject ();
    00701
    00702     using OsiBranchingObject::branch ;
    00704     virtual double branch(OsiSolverInterface * solver);
    00705
    00706     using OsiBranchingObject::print ;
    00709     virtual void print(const OsiSolverInterface * solver = NULL);
    00710 private:
    00712 };
    00720 class OsiBiLinear : public OsiObject2 {
    00721
    00722 public:
    00723
    00724     // Default Constructor
    00725     OsiBiLinear ();
    00726
    00732     OsiBiLinear (OsiSolverInterface * solver, int xColumn,
    00733                  int yColumn, int xyRow, double coefficient,
    00734                  double xMesh, double yMesh,
    00735                  int numberExistingObjects = 0, const OsiObject ** objects = NULL );
    00736
    00742     OsiBiLinear (CoinModel * coinModel, int xColumn,
    00743                  int yColumn, int xyRow, double coefficient,
    00744                  double xMesh, double yMesh,
    00745                  int numberExistingObjects = 0, const OsiObject ** objects = NULL );
    00746
    00747     // Copy constructor
    00748     OsiBiLinear ( const OsiBiLinear &);
    00749
    00751     virtual OsiObject * clone() const;
    00752
    00753     // Assignment operator
    00754     OsiBiLinear & operator=( const OsiBiLinear& rhs);
    00755
    00756     // Destructor
    00757     virtual ~OsiBiLinear ();
    00758
    00759     using OsiObject::infeasibility ;
    00761     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
    00762
    00763     using OsiObject::feasibleRegion ;
    00769     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
    00770
    00775     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
    00776
    00778     virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
    00779
    00780     // This does NOT set mutable stuff
    00781     virtual double checkInfeasibility(const OsiBranchingInformation * info) const;
    00782
    00785     virtual bool canDoHeuristics() const {
    00786         return false;
    00787     }
    00790     virtual bool boundBranch() const {
    00791         return (branchingStrategy_&4) != 0;
    00792     }
    00794     inline int xColumn() const {
    00795         return xColumn_;
    00796     }
    00798     inline int yColumn() const {
    00799         return yColumn_;
    00800     }
    00802     inline int xRow() const {
    00803         return xRow_;
    00804     }
    00806     inline int yRow() const {
    00807         return yRow_;
    00808     }
    00810     inline int xyRow() const {
    00811         return xyRow_;
    00812     }
    00814     inline double coefficient() const {
    00815         return coefficient_;
    00816     }
    00818     inline void setCoefficient(double value) {
    00819         coefficient_ = value;
    00820     }
    00822     inline int firstLambda() const {
    00823         return firstLambda_;
    00824     }
    00826     inline double xSatisfied() const {
    00827         return xSatisfied_;
    00828     }
    00829     inline void setXSatisfied(double value) {
    00830         xSatisfied_ = value;
    00831     }
    00833     inline double ySatisfied() const {
    00834         return ySatisfied_;
    00835     }
    00836     inline void setYSatisfied(double value) {
    00837         ySatisfied_ = value;
    00838     }
    00840     inline double xOtherSatisfied() const {
    00841         return xOtherSatisfied_;
    00842     }
    00843     inline void setXOtherSatisfied(double value) {
    00844         xOtherSatisfied_ = value;
    00845     }
    00847     inline double yOtherSatisfied() const {
    00848         return yOtherSatisfied_;
    00849     }
    00850     inline void setYOtherSatisfied(double value) {
    00851         yOtherSatisfied_ = value;
    00852     }
    00854     inline double xMeshSize() const {
    00855         return xMeshSize_;
    00856     }
    00857     inline void setXMeshSize(double value) {
    00858         xMeshSize_ = value;
    00859     }
    00861     inline double yMeshSize() const {
    00862         return yMeshSize_;
    00863     }
    00864     inline void setYMeshSize(double value) {
    00865         yMeshSize_ = value;
    00866     }
    00868     inline double xySatisfied() const {
    00869         return xySatisfied_;
    00870     }
    00871     inline void setXYSatisfied(double value) {
    00872         xySatisfied_ = value;
    00873     }
    00875     void setMeshSizes(const OsiSolverInterface * solver, double x, double y);
    00886     inline int branchingStrategy() const {
    00887         return branchingStrategy_;
    00888     }
    00889     inline void setBranchingStrategy(int value) {
    00890         branchingStrategy_ = value;
    00891     }
    00899     inline int boundType() const {
    00900         return boundType_;
    00901     }
    00902     inline void setBoundType(int value) {
    00903         boundType_ = value;
    00904     }
    00906     void newBounds(OsiSolverInterface * solver, int way, short xOrY, double separator) const;
    00908     int updateCoefficients(const double * lower, const double * upper, double * objective,
    00909                            CoinPackedMatrix * matrix, CoinWarmStartBasis * basis) const;
    00911     double xyCoefficient(const double * solution) const;
    00913     void getCoefficients(const OsiSolverInterface * solver, double xB[2], double yB[2], double xybar[4]) const;
    00915     double computeLambdas(const double xB[3], const double yB[3], const double xybar[4], double lambda[4]) const;
    00917     void addExtraRow(int row, double multiplier);
    00919     void getPseudoShadow(const OsiBranchingInformation * info);
    00921     double getMovement(const OsiBranchingInformation * info);
    00922
    00923 protected:
    00925     void computeLambdas(const OsiSolverInterface * solver, double lambda[4]) const;
    00927
    00929     double coefficient_;
    00931     double xMeshSize_;
    00933     double yMeshSize_;
    00935     double xSatisfied_;
    00937     double ySatisfied_;
    00939     double xOtherSatisfied_;
    00941     double yOtherSatisfied_;
    00943     double xySatisfied_;
    00945     mutable double xyBranchValue_;
    00947     int xColumn_;
    00949     int yColumn_;
    00951     int firstLambda_;
    00962     int branchingStrategy_;
    00970     int boundType_;
    00972     int xRow_;
    00974     int yRow_;
    00976     int xyRow_;
    00978     int convexity_;
    00980     int numberExtraRows_;
    00982     double * multiplier_;
    00984     int * extraRow_;
    00986     mutable short chosen_;
    00987 };
    00991 class OsiBiLinearBranchingObject : public OsiTwoWayBranchingObject {
    00992
    00993 public:
    00994
    00995     // Default Constructor
    00996     OsiBiLinearBranchingObject ();
    00997
    00998     // Useful constructor
    00999     OsiBiLinearBranchingObject (OsiSolverInterface * solver,  const OsiBiLinear * originalObject,
    01000                                 int way,
    01001                                 double separator, int chosen);
    01002
    01003     // Copy constructor
    01004     OsiBiLinearBranchingObject ( const OsiBiLinearBranchingObject &);
    01005
    01006     // Assignment operator
    01007     OsiBiLinearBranchingObject & operator=( const OsiBiLinearBranchingObject& rhs);
    01008
    01010     virtual OsiBranchingObject * clone() const;
    01011
    01012     // Destructor
    01013     virtual ~OsiBiLinearBranchingObject ();
    01014
    01015     using OsiBranchingObject::branch ;
    01017     virtual double branch(OsiSolverInterface * solver);
    01018
    01019     using OsiBranchingObject::print ;
    01022     virtual void print(const OsiSolverInterface * solver = NULL);
    01025     virtual bool boundBranch() const;
    01026 private:
    01029     short chosen_;
    01030 };
    01038 class OsiBiLinearEquality : public OsiBiLinear {
    01039
    01040 public:
    01041
    01042     // Default Constructor
    01043     OsiBiLinearEquality ();
    01044
    01050     OsiBiLinearEquality (OsiSolverInterface * solver, int xColumn,
    01051                          int yColumn, int xyRow, double rhs,
    01052                          double xMesh);
    01053
    01054     // Copy constructor
    01055     OsiBiLinearEquality ( const OsiBiLinearEquality &);
    01056
    01058     virtual OsiObject * clone() const;
    01059
    01060     // Assignment operator
    01061     OsiBiLinearEquality & operator=( const OsiBiLinearEquality& rhs);
    01062
    01063     // Destructor
    01064     virtual ~OsiBiLinearEquality ();
    01065
    01067     virtual double improvement(const OsiSolverInterface * solver) const;
    01073     double newGrid(OsiSolverInterface * solver, int type) const;
    01075     inline int numberPoints() const {
    01076         return numberPoints_;
    01077     }
    01078     inline void setNumberPoints(int value) {
    01079         numberPoints_ = value;
    01080     }
    01081
    01082 private:
    01084     int numberPoints_;
    01085 };
    01087
    01088
    01089 class OsiSimpleFixedInteger : public OsiSimpleInteger {
    01090
    01091 public:
    01092
    01094     OsiSimpleFixedInteger ();
    01095
    01097     OsiSimpleFixedInteger (const OsiSolverInterface * solver, int iColumn);
    01098
    01100     OsiSimpleFixedInteger (int iColumn, double lower, double upper);
    01101
    01103     OsiSimpleFixedInteger (const OsiSimpleInteger &);
    01104
    01106     OsiSimpleFixedInteger ( const OsiSimpleFixedInteger &);
    01107
    01109     virtual OsiObject * clone() const;
    01110
    01112     OsiSimpleFixedInteger & operator=( const OsiSimpleFixedInteger& rhs);
    01113
    01115     virtual ~OsiSimpleFixedInteger ();
    01116
    01117     using OsiObject::infeasibility ;
    01119     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
    01120
    01125     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
    01126 protected:
    01128
    01129 };
    01139 class OsiUsesBiLinear : public OsiSimpleInteger {
    01140
    01141 public:
    01142
    01144     OsiUsesBiLinear ();
    01145
    01147     OsiUsesBiLinear (const OsiSolverInterface * solver, int iColumn, int type);
    01148
    01150     OsiUsesBiLinear (int iColumn, double lower, double upper, int type);
    01151
    01153     OsiUsesBiLinear (const OsiSimpleInteger & rhs, int type);
    01154
    01156     OsiUsesBiLinear ( const OsiUsesBiLinear & rhs);
    01157
    01159     virtual OsiObject * clone() const;
    01160
    01162     OsiUsesBiLinear & operator=( const OsiUsesBiLinear& rhs);
    01163
    01165     virtual ~OsiUsesBiLinear ();
    01166
    01167     using OsiObject::infeasibility ;
    01169     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
    01170
    01175     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
    01176
    01177     using OsiObject::feasibleRegion ;
    01183     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
    01184
    01186     void addBiLinearObjects(OsiSolverLink * solver);
    01187 protected:
    01190     int numberBiLinear_;
    01192     int type_;
    01194     OsiObject ** objects_;
    01195 };
    01203 class OsiChooseStrongSubset  : public OsiChooseStrong {
    01204
    01205 public:
    01206
    01208     OsiChooseStrongSubset ();
    01209
    01211     OsiChooseStrongSubset (const OsiSolverInterface * solver);
    01212
    01214     OsiChooseStrongSubset (const OsiChooseStrongSubset &);
    01215
    01217     OsiChooseStrongSubset & operator= (const OsiChooseStrongSubset& rhs);
    01218
    01220     virtual OsiChooseVariable * clone() const;
    01221
    01223     virtual ~OsiChooseStrongSubset ();
    01224
    01229     virtual int setupList ( OsiBranchingInformation *info, bool initialize);
    01243     virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
    01244
    01246     inline int numberObjectsToUse() const {
    01247         return numberObjectsToUse_;
    01248     }
    01250     inline void setNumberObjectsToUse(int value) {
    01251         numberObjectsToUse_ = value;
    01252     }
    01253
    01254 protected:
    01255     // Data
    01257     int numberObjectsToUse_;
    01258 };
    01259
    01260 #include <string>
    01261
    01262 #include "CglStored.hpp"
    01263
    01264 class CoinWarmStartBasis;
    01266 class CglTemporary : public CglStored {
    01267
    01268 public:
    01269
    01270
    01281     virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
    01282                                const CglTreeInfo info = CglTreeInfo());
    01284
    01287
    01288     CglTemporary ();
    01289
    01291     CglTemporary (const CglTemporary & rhs);
    01292
    01294     virtual CglCutGenerator * clone() const;
    01295
    01297     CglTemporary &
    01298     operator=(const CglTemporary& rhs);
    01299
    01301     virtual
    01302     ~CglTemporary ();
    01304
    01305 private:
    01306
    01307 // Private member methods
    01308
    01309     // Private member data
    01310 };
    01311 //#############################################################################
    01312
    01318 class OsiSolverLinearizedQuadratic : public OsiClpSolverInterface {
    01319
    01320 public:
    01321     //---------------------------------------------------------------------------
    01324
    01325     virtual void initialSolve();
    01327
    01328
    01331
    01332     OsiSolverLinearizedQuadratic ();
    01334     OsiSolverLinearizedQuadratic(  ClpSimplex * quadraticModel);
    01336     virtual OsiSolverInterface * clone(bool copyData = true) const;
    01337
    01339     OsiSolverLinearizedQuadratic (const OsiSolverLinearizedQuadratic &);
    01340
    01342     OsiSolverLinearizedQuadratic & operator=(const OsiSolverLinearizedQuadratic& rhs);
    01343
    01345     virtual ~OsiSolverLinearizedQuadratic ();
    01346
    01348
    01349
    01352
    01353     inline double bestObjectiveValue() const {
    01354         return bestObjectiveValue_;
    01355     }
    01357     const double * bestSolution() const {
    01358         return bestSolution_;
    01359     }
    01361     inline void setSpecialOptions3(int value) {
    01362         specialOptions3_ = value;
    01363     }
    01365     inline int specialOptions3() const {
    01366         return specialOptions3_;
    01367     }
    01369     ClpSimplex * quadraticModel() const {
    01370         return quadraticModel_;
    01371     }
    01373
    01374     //---------------------------------------------------------------------------
    01375
    01376 protected:
    01377
    01378
    01381
    01384
    01385     double bestObjectiveValue_;
    01387     ClpSimplex * quadraticModel_;
    01389     double * bestSolution_;
    01394     int specialOptions3_;
    01396 };
    01397 class ClpSimplex;
    01402 ClpSimplex * approximateSolution(CoinModel & coinModel,
    01403                                  int numberPasses, double deltaTolerance,
    01404                                  int mode = 0);
    01405 #endif
    01406

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines