1 /* $Id: CoinWarmStartDual.hpp 1372 2011-01-03 23:31:00Z lou $ */
2 // Copyright (C) 2000, International Business Machines
3 // Corporation and others.  All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef CoinWarmStartDual_H
7 #define CoinWarmStartDual_H
8 
9 #include "CoinHelperFunctions.hpp"
10 #include "CoinWarmStart.hpp"
11 #include "CoinWarmStartVector.hpp"
12 
13 
14 //#############################################################################
15 
16 /** WarmStart information that is only a dual vector */
17 
18 class CoinWarmStartDual : public virtual CoinWarmStart {
19 public:
20    /// return the size of the dual vector
size() const21    inline int size() const { return dual_.size(); }
22    /// return a pointer to the array of duals
dual() const23    inline const double * dual() const { return dual_.values(); }
24 
25    /** Assign the dual vector to be the warmstart information. In this method
26        the object assumes ownership of the pointer and upon return "dual" will
27        be a NULL pointer. If copying is desirable use the constructor. */
assignDual(int size,double * & dual)28    inline void assignDual(int size, double *& dual)
29     { dual_.assignVector(size, dual); }
30 
CoinWarmStartDual()31    CoinWarmStartDual() {}
32 
CoinWarmStartDual(int size,const double * dual)33    CoinWarmStartDual(int size, const double * dual) : dual_(size, dual) {}
34 
CoinWarmStartDual(const CoinWarmStartDual & rhs)35    CoinWarmStartDual(const CoinWarmStartDual& rhs) : dual_(rhs.dual_) {}
36 
operator =(const CoinWarmStartDual & rhs)37    CoinWarmStartDual& operator=(const CoinWarmStartDual& rhs) {
38      if (this != &rhs) {
39        dual_ = rhs.dual_;
40      }
41      return *this;
42    }
43 
44    /** `Virtual constructor' */
clone() const45    virtual CoinWarmStart *clone() const override {
46       return new CoinWarmStartDual(*this);
47    }
48 
~CoinWarmStartDual()49    virtual ~CoinWarmStartDual() {}
50 
51 /*! \name Dual warm start `diff' methods */
52 //@{
53 
54   /*! \brief Generate a `diff' that can convert the warm start passed as a
55 	     parameter to the warm start specified by \c this.
56 
57     The capabilities are limited: the basis passed as a parameter can be no
58     larger than the basis pointed to by \c this.
59   */
60 
61   virtual CoinWarmStartDiff*
62   generateDiff (const CoinWarmStart *const oldCWS) const override ;
63 
64   /*! \brief Apply \p diff to this warm start.
65 
66     Update this warm start by applying \p diff. It's assumed that the
67     allocated capacity of the warm start is sufficiently large.
68   */
69 
70   virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) override ;
71 
72 #if 0
73 protected:
74   inline const CoinWarmStartVector<double>& warmStartVector() const { return dual_; }
75 #endif
76 
77 //@}
78 
79 private:
80    ///@name Private data members
81   CoinWarmStartVector<double> dual_;
82 };
83 
84 //#############################################################################
85 
86 /*! \class CoinWarmStartDualDiff
87     \brief A `diff' between two CoinWarmStartDual objects
88 
89   This class exists in order to hide from the world the details of
90   calculating and representing a `diff' between two CoinWarmStartDual
91   objects. For convenience, assignment, cloning, and deletion are visible to
92   the world, and default and copy constructors are made available to derived
93   classes.  Knowledge of the rest of this structure, and of generating and
94   applying diffs, is restricted to the friend functions
95   CoinWarmStartDual::generateDiff() and CoinWarmStartDual::applyDiff().
96 
97   The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_.
98 
99 */
100 
101 class CoinWarmStartDualDiff : public virtual CoinWarmStartDiff
102 { public:
103 
104   /*! \brief `Virtual constructor' */
clone() const105   virtual CoinWarmStartDiff *clone() const override
106   {
107       return new CoinWarmStartDualDiff(*this) ;
108   }
109 
110   /*! \brief Assignment */
operator =(const CoinWarmStartDualDiff & rhs)111   virtual CoinWarmStartDualDiff &operator= (const CoinWarmStartDualDiff &rhs)
112   {
113       if (this != &rhs) {
114 	  diff_ = rhs.diff_;
115       }
116       return *this;
117   }
118 
119   /*! \brief Destructor */
~CoinWarmStartDualDiff()120   virtual ~CoinWarmStartDualDiff() {}
121 
122   protected:
123 
124   /*! \brief Default constructor
125 
126     This is protected (rather than private) so that derived classes can
127     see it when they make <i>their</i> default constructor protected or
128     private.
129   */
CoinWarmStartDualDiff()130   CoinWarmStartDualDiff () : diff_() {}
131 
132   /*! \brief Copy constructor
133 
134     For convenience when copying objects containing CoinWarmStartDualDiff
135     objects. But consider whether you should be using #clone() to retain
136     polymorphism.
137 
138     This is protected (rather than private) so that derived classes can
139     see it when the make <i>their</i> copy constructor protected or
140     private.
141   */
CoinWarmStartDualDiff(const CoinWarmStartDualDiff & rhs)142   CoinWarmStartDualDiff (const CoinWarmStartDualDiff &rhs) :
143       diff_(rhs.diff_) {}
144 
145   private:
146 
147   friend CoinWarmStartDiff*
148     CoinWarmStartDual::generateDiff(const CoinWarmStart *const oldCWS) const ;
149   friend void
150     CoinWarmStartDual::applyDiff(const CoinWarmStartDiff *const diff) ;
151 
152   /*! \brief Standard constructor */
CoinWarmStartDualDiff(int sze,const unsigned int * const diffNdxs,const double * const diffVals)153   CoinWarmStartDualDiff (int sze, const unsigned int *const diffNdxs,
154 			 const double *const diffVals) :
155       diff_(sze, diffNdxs, diffVals) {}
156 
157   /*!
158       \brief The difference in the dual vector is simply the difference in a
159       vector.
160   */
161   CoinWarmStartVectorDiff<double> diff_;
162 };
163 
164 
165 #endif
166