CoinWarmStartDual.hpp

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.

#ifndef CoinWarmStartDual_H
#define CoinWarmStartDual_H

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


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

class CoinWarmStartDual : public CoinWarmStart {
protected:
   inline void gutsOfDestructor() {
      delete[] dualVector_;
   }
   inline void gutsOfCopy(const CoinWarmStartDual& rhs) {
      dualSize_  = rhs.dualSize_;
      dualVector_ = new double[dualSize_];
      CoinDisjointCopyN(rhs.dualVector_, dualSize_, dualVector_);
   }

public:
   int size() const { return dualSize_; }
   const double * dual() const { return dualVector_; }

   void assignDual(int size, double *& dual) {
      dualSize_ = size;
      delete[] dualVector_;
      dualVector_ = dual;
      dual = NULL;
   }

   CoinWarmStartDual() : dualSize_(0), dualVector_(NULL) {}

   CoinWarmStartDual(int size, const double * dual) :
      dualSize_(size), dualVector_(new double[size]) {
      CoinDisjointCopyN(dual, size, dualVector_);
   }

   CoinWarmStartDual(const CoinWarmStartDual& rhs) {
      gutsOfCopy(rhs);
   }

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

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


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

  virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;


private:


   int dualSize_;
   double * dualVector_;
};

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

class CoinWarmStartDualDiff : public CoinWarmStartDiff
{ public:

  virtual CoinWarmStartDiff *clone() const
  { CoinWarmStartDualDiff *cwsdd =  new CoinWarmStartDualDiff(*this) ;
    return (dynamic_cast<CoinWarmStartDiff *>(cwsdd)) ; }

  virtual CoinWarmStartDualDiff &operator= (const CoinWarmStartDualDiff &rhs) ;

  virtual ~CoinWarmStartDualDiff()
  { delete[] diffNdxs_ ;
    delete[] diffVals_ ; }

  protected:

  CoinWarmStartDualDiff () : sze_(0), diffNdxs_(0), diffVals_(NULL) {} ;

  CoinWarmStartDualDiff (const CoinWarmStartDualDiff &rhs) ;

  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) ;
  
  int sze_ ;

  unsigned int *diffNdxs_ ;

  double *diffVals_ ;
} ;


#endif

---