CoinWarmStartDual.hpp

Go to the documentation of this file.

/* $Id$ */
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/