CoinWarmStartDual.hpp

Go to the documentation of this file.

/* $Id: CoinWarmStartDual.hpp 1372 2011-01-03 23:31:00Z lou $ */
// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CoinWarmStartDual_H
#define CoinWarmStartDual_H

#include "CoinHelperFunctions.hpp"
#include "CoinWarmStart.hpp"
#include "CoinWarmStartVector.hpp"


//#############################################################################

class CoinWarmStartDual : public virtual CoinWarmStart {
public:
   inline int size() const { return dual_.size(); }
   inline const double * dual() const { return dual_.values(); }

   inline void assignDual(int size, double *& dual)
    { dual_.assignVector(size, dual); }

   CoinWarmStartDual() {}

   CoinWarmStartDual(int size, const double * dual) : dual_(size, dual) {}

   CoinWarmStartDual(const CoinWarmStartDual& rhs) : dual_(rhs.dual_) {}

   CoinWarmStartDual& operator=(const CoinWarmStartDual& rhs) {
     if (this != &rhs) {
       dual_ = rhs.dual_;
     }
     return *this;
   }

   virtual CoinWarmStart *clone() const {
      return new CoinWarmStartDual(*this);
   }

   virtual ~CoinWarmStartDual() {}


  virtual CoinWarmStartDiff*
  generateDiff (const CoinWarmStart *const oldCWS) const ;

  virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;

#if 0
protected:
  inline const CoinWarmStartVector<double>& warmStartVector() const { return dual_; }
#endif


private:
  CoinWarmStartVector<double> dual_;
};

//#############################################################################

class CoinWarmStartDualDiff : public virtual CoinWarmStartDiff
{ public:

  virtual CoinWarmStartDiff *clone() const
  {
      return new CoinWarmStartDualDiff(*this) ;
  }

  virtual CoinWarmStartDualDiff &operator= (const CoinWarmStartDualDiff &rhs)
  {
      if (this != &rhs) {
          diff_ = rhs.diff_;
      }
      return *this;
  }

  virtual ~CoinWarmStartDualDiff() {}

  protected:

  CoinWarmStartDualDiff () : diff_() {}

  CoinWarmStartDualDiff (const CoinWarmStartDualDiff &rhs) :
      diff_(rhs.diff_) {}

  private:

  friend CoinWarmStartDiff*
    CoinWarmStartDual::generateDiff(const CoinWarmStart *const oldCWS) const ;
  friend void
    CoinWarmStartDual::applyDiff(const CoinWarmStartDiff *const diff) ;

  CoinWarmStartDualDiff (int sze, const unsigned int *const diffNdxs,
                         const double *const diffVals) :
      diff_(sze, diffNdxs, diffVals) {}

  CoinWarmStartVectorDiff<double> diff_;
};


#endif