CoinWarmStartDual.hpp

Go to the documentation of this file.

/* $Id: CoinWarmStartDual.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// 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
*/