00001
00002
00003
00004 #ifndef CglLinked_H
00005 #define CglLinked_H
00006
00007
00008
00009
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
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
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;
00343 int affected;
00344
00345
00346
00347
00348
00349 unsigned char affect;
00350 unsigned char ubUsed;
00351
00352
00353
00354
00355
00356 unsigned char type;
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
00381 CbcHeuristicDynamic3 ();
00382
00383
00384
00385 CbcHeuristicDynamic3 (CbcModel & model);
00386
00387
00388 CbcHeuristicDynamic3 ( const CbcHeuristicDynamic3 &);
00389
00390
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
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
00459 OsiOldLink ( const OsiOldLink &);
00460
00462 virtual OsiObject * clone() const;
00463
00464
00465 OsiOldLink & operator=( const OsiOldLink& rhs);
00466
00467
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
00521 OsiOldLinkBranchingObject ();
00522
00523
00524 OsiOldLinkBranchingObject (OsiSolverInterface * solver, const OsiOldLink * originalObject,
00525 int way,
00526 double separator);
00527
00528
00529 OsiOldLinkBranchingObject ( const OsiOldLinkBranchingObject &);
00530
00531
00532 OsiOldLinkBranchingObject & operator=( const OsiOldLinkBranchingObject& rhs);
00533
00535 virtual OsiBranchingObject * clone() const;
00536
00537
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
00561 OsiOneLink ();
00562
00566 OsiOneLink (const OsiSolverInterface * solver, int xRow, int xColumn, int xyRow,
00567 const char * functionString);
00568
00569
00570 OsiOneLink ( const OsiOneLink &);
00571
00572
00573 OsiOneLink & operator=( const OsiOneLink& rhs);
00574
00575
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
00603 OsiLink ();
00604
00608 OsiLink (const OsiSolverInterface * solver, int yRow,
00609 int yColumn, double meshSize);
00610
00611
00612 OsiLink ( const OsiLink &);
00613
00615 virtual OsiObject * clone() const;
00616
00617
00618 OsiLink & operator=( const OsiLink& rhs);
00619
00620
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
00681 OsiLinkBranchingObject ();
00682
00683
00684 OsiLinkBranchingObject (OsiSolverInterface * solver, const OsiLink * originalObject,
00685 int way,
00686 double separator);
00687
00688
00689 OsiLinkBranchingObject ( const OsiLinkBranchingObject &);
00690
00691
00692 OsiLinkBranchingObject & operator=( const OsiLinkBranchingObject& rhs);
00693
00695 virtual OsiBranchingObject * clone() const;
00696
00697
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
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
00746 OsiBiLinear ( const OsiBiLinear &);
00747
00749 virtual OsiObject * clone() const;
00750
00751
00752 OsiBiLinear & operator=( const OsiBiLinear& rhs);
00753
00754
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
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
00994 OsiBiLinearBranchingObject ();
00995
00996
00997 OsiBiLinearBranchingObject (OsiSolverInterface * solver, const OsiBiLinear * originalObject,
00998 int way,
00999 double separator, int chosen);
01000
01001
01002 OsiBiLinearBranchingObject ( const OsiBiLinearBranchingObject &);
01003
01004
01005 OsiBiLinearBranchingObject & operator=( const OsiBiLinearBranchingObject& rhs);
01006
01008 virtual OsiBranchingObject * clone() const;
01009
01010
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
01041 OsiBiLinearEquality ();
01042
01048 OsiBiLinearEquality (OsiSolverInterface * solver, int xColumn,
01049 int yColumn, int xyRow, double rhs,
01050 double xMesh);
01051
01052
01053 OsiBiLinearEquality ( const OsiBiLinearEquality &);
01054
01056 virtual OsiObject * clone() const;
01057
01058
01059 OsiBiLinearEquality & operator=( const OsiBiLinearEquality& rhs);
01060
01061
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
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
01306
01307
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