CoinWarmStartPrimalDual.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 CoinWarmStartPrimalDual_H
#define CoinWarmStartPrimalDual_H
 
#include "CoinHelperFunctions.hpp"
#include "CoinWarmStart.hpp"
#include "CoinWarmStartVector.hpp"
 
//#############################################################################
 
class CoinWarmStartPrimalDual : public virtual CoinWarmStart {
public:
  inline int dualSize() const { return dual_.size(); }
  inline const double *dual() const { return dual_.values(); }
 
  inline int primalSize() const { return primal_.size(); }
  inline const double *primal() const { return primal_.values(); }
 
  void assign(int primalSize, int dualSize, double *&primal, double *&dual)
  {
    primal_.assignVector(primalSize, primal);
    dual_.assignVector(dualSize, dual);
  }
 
  CoinWarmStartPrimalDual()
    : primal_()
    , dual_()
  {
  }
 
  CoinWarmStartPrimalDual(int primalSize, int dualSize,
    const double *primal, const double *dual)
    : primal_(primalSize, primal)
    , dual_(dualSize, dual)
  {
  }
 
  CoinWarmStartPrimalDual(const CoinWarmStartPrimalDual &rhs)
    : primal_(rhs.primal_)
    , dual_(rhs.dual_)
  {
  }
 
  CoinWarmStartPrimalDual &operator=(const CoinWarmStartPrimalDual &rhs)
  {
    if (this != &rhs) {
      primal_ = rhs.primal_;
      dual_ = rhs.dual_;
    }
    return *this;
  }
 
  inline void clear()
  {
    primal_.clear();
    dual_.clear();
  }
 
  inline void swap(CoinWarmStartPrimalDual &rhs)
  {
    if (this != &rhs) {
      primal_.swap(rhs.primal_);
      dual_.swap(rhs.dual_);
    }
  }
 
  virtual CoinWarmStart *clone() const
  {
    return new CoinWarmStartPrimalDual(*this);
  }
 
  virtual ~CoinWarmStartPrimalDual() {}
 
 
  virtual CoinWarmStartDiff *
  generateDiff(const CoinWarmStart *const oldCWS) const;
 
  virtual void applyDiff(const CoinWarmStartDiff *const cwsdDiff);
 
 
#if 0
protected:
  inline const CoinWarmStartVector<double>& primalWarmStartVector() const
  { return primal_; }
  inline const CoinWarmStartVector<double>& dualWarmStartVector() const
  { return dual_; }
#endif
 
private:
 
  CoinWarmStartVector< double > primal_;
  CoinWarmStartVector< double > dual_;
};
 
//#############################################################################
 
class CoinWarmStartPrimalDualDiff : public virtual CoinWarmStartDiff {
  friend CoinWarmStartDiff *
  CoinWarmStartPrimalDual::generateDiff(const CoinWarmStart *const oldCWS) const;
  friend void
  CoinWarmStartPrimalDual::applyDiff(const CoinWarmStartDiff *const diff);
 
public:
  virtual CoinWarmStartDiff *clone() const
  {
    return new CoinWarmStartPrimalDualDiff(*this);
  }
 
  virtual ~CoinWarmStartPrimalDualDiff() {}
 
protected:
  CoinWarmStartPrimalDualDiff()
    : primalDiff_()
    , dualDiff_()
  {
  }
 
  CoinWarmStartPrimalDualDiff(const CoinWarmStartPrimalDualDiff &rhs)
    : primalDiff_(rhs.primalDiff_)
    , dualDiff_(rhs.dualDiff_)
  {
  }
 
  inline void clear()
  {
    primalDiff_.clear();
    dualDiff_.clear();
  }
 
  inline void swap(CoinWarmStartPrimalDualDiff &rhs)
  {
    if (this != &rhs) {
      primalDiff_.swap(rhs.primalDiff_);
      dualDiff_.swap(rhs.dualDiff_);
    }
  }
 
private:
  CoinWarmStartVectorDiff< double > primalDiff_;
  CoinWarmStartVectorDiff< double > dualDiff_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/