/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinWarmStartPrimalDual.hpp

Go to the documentation of this file.

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

#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

---