• Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

/tmp/buildd/coinor-cbc-2.5.0/Cbc/src/CbcLinked.hpp

Go to the documentation of this file.
00001 /* $Id: CbcLinked.hpp 1200 2009-07-25 08:44:13Z forrest $ */
00002 // Copyright (C) 2006, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 #ifndef CglLinked_H
00005 #define CglLinked_H
00006 /* THIS CONTAINS STUFF THAT SHOULD BE IN
00007    OsiSolverLink
00008    OsiBranchLink
00009    CglTemporary
00010 */
00011 #include "CoinModel.hpp"
00012 #include "OsiClpSolverInterface.hpp"
00013 #include "OsiChooseVariable.hpp"
00014 #include "CbcFathom.hpp"
00015 class CbcModel;
00016 class CoinPackedMatrix;
00017 class OsiLinkedBound;
00018 class OsiObject;
00019 class CglStored;
00020 class CglTemporary;
00027 class OsiSolverLink : public CbcOsiSolver {
00028 
00029 public:
00030     //---------------------------------------------------------------------------
00033 
00034     virtual void initialSolve();
00035 
00037     virtual void resolve();
00038 
00046     virtual int fathom(bool allFixed) ;
00053     double * nonlinearSLP(int numberPasses, double deltaTolerance);
00057     double linearizedBAB(CglStored * cut) ;
00066     double * heuristicSolution(int numberPasses, double deltaTolerance, int mode);
00067 
00069     int doAOCuts(CglTemporary * cutGen, const double * solution, const double * solution2);
00071 
00072 
00075 
00076     OsiSolverLink ();
00077 
00090     OsiSolverLink(  CoinModel & modelObject);
00091     // Other way with existing object
00092     void load(  CoinModel & modelObject, bool tightenBounds = false, int logLevel = 1);
00094     virtual OsiSolverInterface * clone(bool copyData = true) const;
00095 
00097     OsiSolverLink (const OsiSolverLink &);
00098 
00100     OsiSolverLink & operator=(const OsiSolverLink& rhs);
00101 
00103     virtual ~OsiSolverLink ();
00104 
00106 
00107 
00110 
00111     void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable, int whichVariableAffected,
00112                           double multiplier = 1.0);
00114     int updateCoefficients(ClpSimplex * solver, CoinPackedMatrix * matrix);
00116     void analyzeObjects();
00118     void addTighterConstraints();
00120     inline double bestObjectiveValue() const {
00121         return bestObjectiveValue_;
00122     }
00124     inline void setBestObjectiveValue(double value) {
00125         bestObjectiveValue_ = value;
00126     }
00128     inline const double * bestSolution() const {
00129         return bestSolution_;
00130     }
00132     void setBestSolution(const double * solution, int numberColumns);
00134     inline void setSpecialOptions2(int value) {
00135         specialOptions2_ = value;
00136     }
00138     void sayConvex(bool convex);
00140     inline int specialOptions2() const {
00141         return specialOptions2_;
00142     }
00146     CoinPackedMatrix * cleanMatrix() const {
00147         return matrix_;
00148     }
00153     CoinPackedMatrix * originalRowCopy() const {
00154         return originalRowCopy_;
00155     }
00157     ClpSimplex * quadraticModel() const {
00158         return quadraticModel_;
00159     }
00161     CoinPackedMatrix * quadraticRow(int rowNumber, double * linear) const;
00163     inline double defaultMeshSize() const {
00164         return defaultMeshSize_;
00165     }
00166     inline void setDefaultMeshSize(double value) {
00167         defaultMeshSize_ = value;
00168     }
00170     inline double defaultBound() const {
00171         return defaultBound_;
00172     }
00173     inline void setDefaultBound(double value) {
00174         defaultBound_ = value;
00175     }
00177     inline void setIntegerPriority(int value) {
00178         integerPriority_ = value;
00179     }
00181     inline int integerPriority() const {
00182         return integerPriority_;
00183     }
00185     inline int objectiveVariable() const {
00186         return objectiveVariable_;
00187     }
00189     inline void setBiLinearPriority(int value) {
00190         biLinearPriority_ = value;
00191     }
00193     inline int biLinearPriority() const {
00194         return biLinearPriority_;
00195     }
00197     inline const CoinModel * coinModel() const {
00198         return &coinModel_;
00199     }
00201     void setBiLinearPriorities(int value, double meshSize = 1.0);
00209     void setBranchingStrategyOnVariables(int strategyValue, int priorityValue = -1,
00210                                          int mode = 7);
00212     void setMeshSizes(double value);
00216     void setFixedPriority(int priorityValue);
00218 
00219     //---------------------------------------------------------------------------
00220 
00221 protected:
00222 
00223 
00226 
00227     //void initialize(ClpSimplex * & solver, OsiObject ** & object) const;
00229     void gutsOfDestructor(bool justNullify = false);
00231     void gutsOfCopy(const OsiSolverLink & rhs) ;
00233 
00239     CoinPackedMatrix * matrix_;
00243     CoinPackedMatrix * originalRowCopy_;
00245     ClpSimplex * quadraticModel_;
00247     int numberNonLinearRows_;
00249     int * startNonLinear_;
00251     int * rowNonLinear_;
00255     int * convex_;
00257     int * whichNonLinear_;
00259     CoinModel coinModel_;
00261     int numberVariables_;
00263     OsiLinkedBound * info_;
00271     int specialOptions2_;
00273     int objectiveRow_;
00275     int objectiveVariable_;
00277     double bestObjectiveValue_;
00279     double defaultMeshSize_;
00281     double defaultBound_;
00283     double * bestSolution_;
00285     int integerPriority_;
00287     int biLinearPriority_;
00289     int numberFix_;
00291     int * fixVariables_;
00293 };
00298 class OsiLinkedBound {
00299 
00300 public:
00301     //---------------------------------------------------------------------------
00304 
00305     void updateBounds(ClpSimplex * solver);
00307 
00308 
00311 
00312     OsiLinkedBound ();
00314     OsiLinkedBound(OsiSolverInterface * model, int variable,
00315                    int numberAffected, const int * positionL,
00316                    const int * positionU, const double * multiplier);
00317 
00319     OsiLinkedBound (const OsiLinkedBound &);
00320 
00322     OsiLinkedBound & operator=(const OsiLinkedBound& rhs);
00323 
00325     ~OsiLinkedBound ();
00326 
00328 
00331 
00332     inline int variable() const {
00333         return variable_;
00334     }
00336     void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable,
00337                           double multiplier = 1.0);
00339 
00340 private:
00341     typedef struct {
00342         double multiplier; // to use in computation
00343         int affected; // variable or element affected
00344         /*
00345           0 - LB of variable affected
00346           1 - UB of variable affected
00347           2 - element in position (affected) affected
00348         */
00349         unsigned char affect;
00350         unsigned char ubUsed; // nonzero if UB of this variable is used
00351         /*
00352            0 - use x*multiplier
00353            1 - use multiplier/x
00354            2 - if UB use min of current upper and x*multiplier, if LB use max of current lower and x*multiplier
00355         */
00356         unsigned char type; // type of computation
00357     } boundElementAction;
00358 
00361 
00362     OsiSolverInterface * model_;
00364     int variable_;
00366     int numberAffected_;
00368     int maximumAffected_;
00370     boundElementAction * affected_;
00372 };
00373 #include "CbcHeuristic.hpp"
00377 class CbcHeuristicDynamic3 : public CbcHeuristic {
00378 public:
00379 
00380     // Default Constructor
00381     CbcHeuristicDynamic3 ();
00382 
00383     /* Constructor with model
00384      */
00385     CbcHeuristicDynamic3 (CbcModel & model);
00386 
00387     // Copy constructor
00388     CbcHeuristicDynamic3 ( const CbcHeuristicDynamic3 &);
00389 
00390     // Destructor
00391     ~CbcHeuristicDynamic3 ();
00392 
00394     virtual CbcHeuristic * clone() const;
00395 
00397     virtual void setModel(CbcModel * model);
00398 
00399     using CbcHeuristic::solution ;
00410     virtual int solution(double & objectiveValue,
00411                          double * newSolution);
00413     virtual void resetModel(CbcModel * model);
00415     virtual bool canDealWithOdd() const {
00416         return true;
00417     }
00418 
00419 protected:
00420 private:
00422     CbcHeuristicDynamic3 & operator=(const CbcHeuristicDynamic3& rhs);
00423 };
00424 
00425 #include "OsiBranchingObject.hpp"
00426 
00430 class CoinWarmStartBasis;
00431 
00432 class OsiOldLink : public OsiSOS {
00433 
00434 public:
00435 
00436     // Default Constructor
00437     OsiOldLink ();
00438 
00445     OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
00446                 int numberLinks, int first,
00447                 const double * weights, int setNumber);
00454     OsiOldLink (const OsiSolverInterface * solver, int numberMembers,
00455                 int numberLinks, int typeSOS, const int * which,
00456                 const double * weights, int setNumber);
00457 
00458     // Copy constructor
00459     OsiOldLink ( const OsiOldLink &);
00460 
00462     virtual OsiObject * clone() const;
00463 
00464     // Assignment operator
00465     OsiOldLink & operator=( const OsiOldLink& rhs);
00466 
00467     // Destructor
00468     virtual ~OsiOldLink ();
00469 
00470     using OsiObject::infeasibility ;
00472     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
00473 
00474     using OsiObject::feasibleRegion ;
00480     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
00481 
00486     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
00487 
00489     virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
00490 
00492     inline int numberLinks() const {
00493         return numberLinks_;
00494     }
00495 
00498     virtual bool canDoHeuristics() const {
00499         return false;
00500     }
00503     virtual bool boundBranch() const {
00504         return false;
00505     }
00506 
00507 private:
00509 
00511     int numberLinks_;
00512 };
00516 class OsiOldLinkBranchingObject : public OsiSOSBranchingObject {
00517 
00518 public:
00519 
00520     // Default Constructor
00521     OsiOldLinkBranchingObject ();
00522 
00523     // Useful constructor
00524     OsiOldLinkBranchingObject (OsiSolverInterface * solver,  const OsiOldLink * originalObject,
00525                                int way,
00526                                double separator);
00527 
00528     // Copy constructor
00529     OsiOldLinkBranchingObject ( const OsiOldLinkBranchingObject &);
00530 
00531     // Assignment operator
00532     OsiOldLinkBranchingObject & operator=( const OsiOldLinkBranchingObject& rhs);
00533 
00535     virtual OsiBranchingObject * clone() const;
00536 
00537     // Destructor
00538     virtual ~OsiOldLinkBranchingObject ();
00539 
00540     using OsiBranchingObject::branch ;
00542     virtual double branch(OsiSolverInterface * solver);
00543 
00544     using OsiBranchingObject::print ;
00547     virtual void print(const OsiSolverInterface * solver = NULL);
00548 private:
00550 };
00556 class OsiOneLink {
00557 
00558 public:
00559 
00560     // Default Constructor
00561     OsiOneLink ();
00562 
00566     OsiOneLink (const OsiSolverInterface * solver, int xRow, int xColumn, int xyRow,
00567                 const char * functionString);
00568 
00569     // Copy constructor
00570     OsiOneLink ( const OsiOneLink &);
00571 
00572     // Assignment operator
00573     OsiOneLink & operator=( const OsiOneLink& rhs);
00574 
00575     // Destructor
00576     virtual ~OsiOneLink ();
00577 
00579 
00581     int xRow_;
00583     int xColumn_;
00585     int xyRow;
00587     std::string function_;
00588 };
00598 class OsiLink : public OsiSOS {
00599 
00600 public:
00601 
00602     // Default Constructor
00603     OsiLink ();
00604 
00608     OsiLink (const OsiSolverInterface * solver, int yRow,
00609              int yColumn, double meshSize);
00610 
00611     // Copy constructor
00612     OsiLink ( const OsiLink &);
00613 
00615     virtual OsiObject * clone() const;
00616 
00617     // Assignment operator
00618     OsiLink & operator=( const OsiLink& rhs);
00619 
00620     // Destructor
00621     virtual ~OsiLink ();
00622 
00623     using OsiObject::infeasibility ;
00625     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
00626 
00627     using OsiObject::feasibleRegion ;
00633     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
00634 
00639     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
00640 
00642     virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
00643 
00645     inline int numberLinks() const {
00646         return numberLinks_;
00647     }
00648 
00651     virtual bool canDoHeuristics() const {
00652         return false;
00653     }
00656     virtual bool boundBranch() const {
00657         return false;
00658     }
00659 
00660 private:
00663     double meshSize_;
00665     OsiOneLink * data_;
00667     int numberLinks_;
00669     int yRow_;
00671     int yColumn_;
00672 };
00676 class OsiLinkBranchingObject : public OsiTwoWayBranchingObject {
00677 
00678 public:
00679 
00680     // Default Constructor
00681     OsiLinkBranchingObject ();
00682 
00683     // Useful constructor
00684     OsiLinkBranchingObject (OsiSolverInterface * solver,  const OsiLink * originalObject,
00685                             int way,
00686                             double separator);
00687 
00688     // Copy constructor
00689     OsiLinkBranchingObject ( const OsiLinkBranchingObject &);
00690 
00691     // Assignment operator
00692     OsiLinkBranchingObject & operator=( const OsiLinkBranchingObject& rhs);
00693 
00695     virtual OsiBranchingObject * clone() const;
00696 
00697     // Destructor
00698     virtual ~OsiLinkBranchingObject ();
00699 
00700     using OsiBranchingObject::branch ;
00702     virtual double branch(OsiSolverInterface * solver);
00703 
00704     using OsiBranchingObject::print ;
00707     virtual void print(const OsiSolverInterface * solver = NULL);
00708 private:
00710 };
00718 class OsiBiLinear : public OsiObject2 {
00719 
00720 public:
00721 
00722     // Default Constructor
00723     OsiBiLinear ();
00724 
00730     OsiBiLinear (OsiSolverInterface * solver, int xColumn,
00731                  int yColumn, int xyRow, double coefficient,
00732                  double xMesh, double yMesh,
00733                  int numberExistingObjects = 0, const OsiObject ** objects = NULL );
00734 
00740     OsiBiLinear (CoinModel * coinModel, int xColumn,
00741                  int yColumn, int xyRow, double coefficient,
00742                  double xMesh, double yMesh,
00743                  int numberExistingObjects = 0, const OsiObject ** objects = NULL );
00744 
00745     // Copy constructor
00746     OsiBiLinear ( const OsiBiLinear &);
00747 
00749     virtual OsiObject * clone() const;
00750 
00751     // Assignment operator
00752     OsiBiLinear & operator=( const OsiBiLinear& rhs);
00753 
00754     // Destructor
00755     virtual ~OsiBiLinear ();
00756 
00757     using OsiObject::infeasibility ;
00759     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
00760 
00761     using OsiObject::feasibleRegion ;
00767     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
00768 
00773     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
00774 
00776     virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
00777 
00778     // This does NOT set mutable stuff
00779     virtual double checkInfeasibility(const OsiBranchingInformation * info) const;
00780 
00783     virtual bool canDoHeuristics() const {
00784         return false;
00785     }
00788     virtual bool boundBranch() const {
00789         return (branchingStrategy_&4) != 0;
00790     }
00792     inline int xColumn() const {
00793         return xColumn_;
00794     }
00796     inline int yColumn() const {
00797         return yColumn_;
00798     }
00800     inline int xRow() const {
00801         return xRow_;
00802     }
00804     inline int yRow() const {
00805         return yRow_;
00806     }
00808     inline int xyRow() const {
00809         return xyRow_;
00810     }
00812     inline double coefficient() const {
00813         return coefficient_;
00814     }
00816     inline void setCoefficient(double value) {
00817         coefficient_ = value;
00818     }
00820     inline int firstLambda() const {
00821         return firstLambda_;
00822     }
00824     inline double xSatisfied() const {
00825         return xSatisfied_;
00826     }
00827     inline void setXSatisfied(double value) {
00828         xSatisfied_ = value;
00829     }
00831     inline double ySatisfied() const {
00832         return ySatisfied_;
00833     }
00834     inline void setYSatisfied(double value) {
00835         ySatisfied_ = value;
00836     }
00838     inline double xOtherSatisfied() const {
00839         return xOtherSatisfied_;
00840     }
00841     inline void setXOtherSatisfied(double value) {
00842         xOtherSatisfied_ = value;
00843     }
00845     inline double yOtherSatisfied() const {
00846         return yOtherSatisfied_;
00847     }
00848     inline void setYOtherSatisfied(double value) {
00849         yOtherSatisfied_ = value;
00850     }
00852     inline double xMeshSize() const {
00853         return xMeshSize_;
00854     }
00855     inline void setXMeshSize(double value) {
00856         xMeshSize_ = value;
00857     }
00859     inline double yMeshSize() const {
00860         return yMeshSize_;
00861     }
00862     inline void setYMeshSize(double value) {
00863         yMeshSize_ = value;
00864     }
00866     inline double xySatisfied() const {
00867         return xySatisfied_;
00868     }
00869     inline void setXYSatisfied(double value) {
00870         xySatisfied_ = value;
00871     }
00873     void setMeshSizes(const OsiSolverInterface * solver, double x, double y);
00884     inline int branchingStrategy() const {
00885         return branchingStrategy_;
00886     }
00887     inline void setBranchingStrategy(int value) {
00888         branchingStrategy_ = value;
00889     }
00897     inline int boundType() const {
00898         return boundType_;
00899     }
00900     inline void setBoundType(int value) {
00901         boundType_ = value;
00902     }
00904     void newBounds(OsiSolverInterface * solver, int way, short xOrY, double separator) const;
00906     int updateCoefficients(const double * lower, const double * upper, double * objective,
00907                            CoinPackedMatrix * matrix, CoinWarmStartBasis * basis) const;
00909     double xyCoefficient(const double * solution) const;
00911     void getCoefficients(const OsiSolverInterface * solver, double xB[2], double yB[2], double xybar[4]) const;
00913     double computeLambdas(const double xB[3], const double yB[3], const double xybar[4], double lambda[4]) const;
00915     void addExtraRow(int row, double multiplier);
00917     void getPseudoShadow(const OsiBranchingInformation * info);
00919     double getMovement(const OsiBranchingInformation * info);
00920 
00921 protected:
00923     void computeLambdas(const OsiSolverInterface * solver, double lambda[4]) const;
00925 
00927     double coefficient_;
00929     double xMeshSize_;
00931     double yMeshSize_;
00933     double xSatisfied_;
00935     double ySatisfied_;
00937     double xOtherSatisfied_;
00939     double yOtherSatisfied_;
00941     double xySatisfied_;
00943     mutable double xyBranchValue_;
00945     int xColumn_;
00947     int yColumn_;
00949     int firstLambda_;
00960     int branchingStrategy_;
00968     int boundType_;
00970     int xRow_;
00972     int yRow_;
00974     int xyRow_;
00976     int convexity_;
00978     int numberExtraRows_;
00980     double * multiplier_;
00982     int * extraRow_;
00984     mutable short chosen_;
00985 };
00989 class OsiBiLinearBranchingObject : public OsiTwoWayBranchingObject {
00990 
00991 public:
00992 
00993     // Default Constructor
00994     OsiBiLinearBranchingObject ();
00995 
00996     // Useful constructor
00997     OsiBiLinearBranchingObject (OsiSolverInterface * solver,  const OsiBiLinear * originalObject,
00998                                 int way,
00999                                 double separator, int chosen);
01000 
01001     // Copy constructor
01002     OsiBiLinearBranchingObject ( const OsiBiLinearBranchingObject &);
01003 
01004     // Assignment operator
01005     OsiBiLinearBranchingObject & operator=( const OsiBiLinearBranchingObject& rhs);
01006 
01008     virtual OsiBranchingObject * clone() const;
01009 
01010     // Destructor
01011     virtual ~OsiBiLinearBranchingObject ();
01012 
01013     using OsiBranchingObject::branch ;
01015     virtual double branch(OsiSolverInterface * solver);
01016 
01017     using OsiBranchingObject::print ;
01020     virtual void print(const OsiSolverInterface * solver = NULL);
01023     virtual bool boundBranch() const;
01024 private:
01027     short chosen_;
01028 };
01036 class OsiBiLinearEquality : public OsiBiLinear {
01037 
01038 public:
01039 
01040     // Default Constructor
01041     OsiBiLinearEquality ();
01042 
01048     OsiBiLinearEquality (OsiSolverInterface * solver, int xColumn,
01049                          int yColumn, int xyRow, double rhs,
01050                          double xMesh);
01051 
01052     // Copy constructor
01053     OsiBiLinearEquality ( const OsiBiLinearEquality &);
01054 
01056     virtual OsiObject * clone() const;
01057 
01058     // Assignment operator
01059     OsiBiLinearEquality & operator=( const OsiBiLinearEquality& rhs);
01060 
01061     // Destructor
01062     virtual ~OsiBiLinearEquality ();
01063 
01065     virtual double improvement(const OsiSolverInterface * solver) const;
01071     double newGrid(OsiSolverInterface * solver, int type) const;
01073     inline int numberPoints() const {
01074         return numberPoints_;
01075     }
01076     inline void setNumberPoints(int value) {
01077         numberPoints_ = value;
01078     }
01079 
01080 private:
01082     int numberPoints_;
01083 };
01085 
01086 
01087 class OsiSimpleFixedInteger : public OsiSimpleInteger {
01088 
01089 public:
01090 
01092     OsiSimpleFixedInteger ();
01093 
01095     OsiSimpleFixedInteger (const OsiSolverInterface * solver, int iColumn);
01096 
01098     OsiSimpleFixedInteger (int iColumn, double lower, double upper);
01099 
01101     OsiSimpleFixedInteger (const OsiSimpleInteger &);
01102 
01104     OsiSimpleFixedInteger ( const OsiSimpleFixedInteger &);
01105 
01107     virtual OsiObject * clone() const;
01108 
01110     OsiSimpleFixedInteger & operator=( const OsiSimpleFixedInteger& rhs);
01111 
01113     virtual ~OsiSimpleFixedInteger ();
01114 
01115     using OsiObject::infeasibility ;
01117     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
01118 
01123     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
01124 protected:
01126 
01127 };
01137 class OsiUsesBiLinear : public OsiSimpleInteger {
01138 
01139 public:
01140 
01142     OsiUsesBiLinear ();
01143 
01145     OsiUsesBiLinear (const OsiSolverInterface * solver, int iColumn, int type);
01146 
01148     OsiUsesBiLinear (int iColumn, double lower, double upper, int type);
01149 
01151     OsiUsesBiLinear (const OsiSimpleInteger & rhs, int type);
01152 
01154     OsiUsesBiLinear ( const OsiUsesBiLinear & rhs);
01155 
01157     virtual OsiObject * clone() const;
01158 
01160     OsiUsesBiLinear & operator=( const OsiUsesBiLinear& rhs);
01161 
01163     virtual ~OsiUsesBiLinear ();
01164 
01165     using OsiObject::infeasibility ;
01167     virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
01168 
01173     virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
01174 
01175     using OsiObject::feasibleRegion ;
01181     virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
01182 
01184     void addBiLinearObjects(OsiSolverLink * solver);
01185 protected:
01188     int numberBiLinear_;
01190     int type_;
01192     OsiObject ** objects_;
01193 };
01201 class OsiChooseStrongSubset  : public OsiChooseStrong {
01202 
01203 public:
01204 
01206     OsiChooseStrongSubset ();
01207 
01209     OsiChooseStrongSubset (const OsiSolverInterface * solver);
01210 
01212     OsiChooseStrongSubset (const OsiChooseStrongSubset &);
01213 
01215     OsiChooseStrongSubset & operator= (const OsiChooseStrongSubset& rhs);
01216 
01218     virtual OsiChooseVariable * clone() const;
01219 
01221     virtual ~OsiChooseStrongSubset ();
01222 
01227     virtual int setupList ( OsiBranchingInformation *info, bool initialize);
01241     virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
01242 
01244     inline int numberObjectsToUse() const {
01245         return numberObjectsToUse_;
01246     }
01248     inline void setNumberObjectsToUse(int value) {
01249         numberObjectsToUse_ = value;
01250     }
01251 
01252 protected:
01253     // Data
01255     int numberObjectsToUse_;
01256 };
01257 
01258 #include <string>
01259 
01260 #include "CglStored.hpp"
01261 
01262 class CoinWarmStartBasis;
01264 class CglTemporary : public CglStored {
01265 
01266 public:
01267 
01268 
01279     virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
01280                                const CglTreeInfo info = CglTreeInfo()) const;
01282 
01285 
01286     CglTemporary ();
01287 
01289     CglTemporary (const CglTemporary & rhs);
01290 
01292     virtual CglCutGenerator * clone() const;
01293 
01295     CglTemporary &
01296     operator=(const CglTemporary& rhs);
01297 
01299     virtual
01300     ~CglTemporary ();
01302 
01303 private:
01304 
01305 // Private member methods
01306 
01307     // Private member data
01308 };
01309 //#############################################################################
01310 
01316 class OsiSolverLinearizedQuadratic : public OsiClpSolverInterface {
01317 
01318 public:
01319     //---------------------------------------------------------------------------
01322 
01323     virtual void initialSolve();
01325 
01326 
01329 
01330     OsiSolverLinearizedQuadratic ();
01332     OsiSolverLinearizedQuadratic(  ClpSimplex * quadraticModel);
01334     virtual OsiSolverInterface * clone(bool copyData = true) const;
01335 
01337     OsiSolverLinearizedQuadratic (const OsiSolverLinearizedQuadratic &);
01338 
01340     OsiSolverLinearizedQuadratic & operator=(const OsiSolverLinearizedQuadratic& rhs);
01341 
01343     virtual ~OsiSolverLinearizedQuadratic ();
01344 
01346 
01347 
01350 
01351     inline double bestObjectiveValue() const {
01352         return bestObjectiveValue_;
01353     }
01355     const double * bestSolution() const {
01356         return bestSolution_;
01357     }
01359     inline void setSpecialOptions3(int value) {
01360         specialOptions3_ = value;
01361     }
01363     inline int specialOptions3() const {
01364         return specialOptions3_;
01365     }
01367     ClpSimplex * quadraticModel() const {
01368         return quadraticModel_;
01369     }
01371 
01372     //---------------------------------------------------------------------------
01373 
01374 protected:
01375 
01376 
01379 
01382 
01383     double bestObjectiveValue_;
01385     ClpSimplex * quadraticModel_;
01387     double * bestSolution_;
01392     int specialOptions3_;
01394 };
01395 class ClpSimplex;
01400 ClpSimplex * approximateSolution(CoinModel & coinModel,
01401                                  int numberPasses, double deltaTolerance,
01402                                  int mode = 0);
01403 #endif
01404 

Generated on Tue Sep 7 2010 20:23:52 by  doxygen 1.7.1