00001
00002
00003
00004
00005
00006 #ifndef CglLinked_H
00007 #define CglLinked_H
00008
00009
00010
00011
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
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
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;
00345 int affected;
00346
00347
00348
00349
00350
00351 unsigned char affect;
00352 unsigned char ubUsed;
00353
00354
00355
00356
00357
00358 unsigned char type;
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
00383 CbcHeuristicDynamic3 ();
00384
00385
00386
00387 CbcHeuristicDynamic3 (CbcModel & model);
00388
00389
00390 CbcHeuristicDynamic3 ( const CbcHeuristicDynamic3 &);
00391
00392
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
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
00461 OsiOldLink ( const OsiOldLink &);
00462
00464 virtual OsiObject * clone() const;
00465
00466
00467 OsiOldLink & operator=( const OsiOldLink& rhs);
00468
00469
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
00523 OsiOldLinkBranchingObject ();
00524
00525
00526 OsiOldLinkBranchingObject (OsiSolverInterface * solver, const OsiOldLink * originalObject,
00527 int way,
00528 double separator);
00529
00530
00531 OsiOldLinkBranchingObject ( const OsiOldLinkBranchingObject &);
00532
00533
00534 OsiOldLinkBranchingObject & operator=( const OsiOldLinkBranchingObject& rhs);
00535
00537 virtual OsiBranchingObject * clone() const;
00538
00539
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
00563 OsiOneLink ();
00564
00568 OsiOneLink (const OsiSolverInterface * solver, int xRow, int xColumn, int xyRow,
00569 const char * functionString);
00570
00571
00572 OsiOneLink ( const OsiOneLink &);
00573
00574
00575 OsiOneLink & operator=( const OsiOneLink& rhs);
00576
00577
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
00605 OsiLink ();
00606
00610 OsiLink (const OsiSolverInterface * solver, int yRow,
00611 int yColumn, double meshSize);
00612
00613
00614 OsiLink ( const OsiLink &);
00615
00617 virtual OsiObject * clone() const;
00618
00619
00620 OsiLink & operator=( const OsiLink& rhs);
00621
00622
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
00683 OsiLinkBranchingObject ();
00684
00685
00686 OsiLinkBranchingObject (OsiSolverInterface * solver, const OsiLink * originalObject,
00687 int way,
00688 double separator);
00689
00690
00691 OsiLinkBranchingObject ( const OsiLinkBranchingObject &);
00692
00693
00694 OsiLinkBranchingObject & operator=( const OsiLinkBranchingObject& rhs);
00695
00697 virtual OsiBranchingObject * clone() const;
00698
00699
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
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
00748 OsiBiLinear ( const OsiBiLinear &);
00749
00751 virtual OsiObject * clone() const;
00752
00753
00754 OsiBiLinear & operator=( const OsiBiLinear& rhs);
00755
00756
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
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
00996 OsiBiLinearBranchingObject ();
00997
00998
00999 OsiBiLinearBranchingObject (OsiSolverInterface * solver, const OsiBiLinear * originalObject,
01000 int way,
01001 double separator, int chosen);
01002
01003
01004 OsiBiLinearBranchingObject ( const OsiBiLinearBranchingObject &);
01005
01006
01007 OsiBiLinearBranchingObject & operator=( const OsiBiLinearBranchingObject& rhs);
01008
01010 virtual OsiBranchingObject * clone() const;
01011
01012
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
01043 OsiBiLinearEquality ();
01044
01050 OsiBiLinearEquality (OsiSolverInterface * solver, int xColumn,
01051 int yColumn, int xyRow, double rhs,
01052 double xMesh);
01053
01054
01055 OsiBiLinearEquality ( const OsiBiLinearEquality &);
01056
01058 virtual OsiObject * clone() const;
01059
01060
01061 OsiBiLinearEquality & operator=( const OsiBiLinearEquality& rhs);
01062
01063
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
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()) const;
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
01308
01309
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