ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/install/include/coin/CoinWarmStartDual.hpp

@@ -1,166 +0,0 @@
-/* $Id: CoinWarmStartDual.hpp 1372 2011-01-03 23:31:00Z lou $ */
-// 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"
-
-
-//#############################################################################
-
-/** WarmStart information that is only a dual vector */
-
-class CoinWarmStartDual : public virtual CoinWarmStart {
-public:
-   /// return the size of the dual vector
-   inline int size() const { return dual_.size(); }
-   /// return a pointer to the array of duals
-   inline const double * dual() const { return dual_.values(); }
-
-   /** Assign the dual vector to be the warmstart information. In this method
-       the object assumes ownership of the pointer and upon return "dual" will
-       be a NULL pointer. If copying is desirable use the constructor. */
-   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 constructor' */
-   virtual CoinWarmStart *clone() const {
-      return new CoinWarmStartDual(*this);
-   }
-
-   virtual ~CoinWarmStartDual() {}
-
-/*! \name Dual warm start `diff' methods */
-//@{
-
-  /*! \brief Generate a `diff' that can convert the warm start passed as a
-	     parameter to the warm start specified by \c this.
-
-    The capabilities are limited: the basis passed as a parameter can be no
-    larger than the basis pointed to by \c this.
-  */
-
-  virtual CoinWarmStartDiff*
-  generateDiff (const CoinWarmStart *const oldCWS) const ;
-
-  /*! \brief Apply \p diff to this warm start.
-
-    Update this warm start by applying \p diff. It's assumed that the
-    allocated capacity of the warm start is sufficiently large.
-  */
-
-  virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;
-
-#if 0
-protected:
-  inline const CoinWarmStartVector<double>& warmStartVector() const { return dual_; }
-#endif
-
-//@}
-
-private:
-   ///@name Private data members
-  CoinWarmStartVector<double> dual_;
-};
-
-//#############################################################################
-
-/*! \class CoinWarmStartDualDiff
-    \brief A `diff' between two CoinWarmStartDual objects
-
-  This class exists in order to hide from the world the details of
-  calculating and representing a `diff' between two CoinWarmStartDual
-  objects. For convenience, assignment, cloning, and deletion are visible to
-  the world, and default and copy constructors are made available to derived
-  classes.  Knowledge of the rest of this structure, and of generating and
-  applying diffs, is restricted to the friend functions
-  CoinWarmStartDual::generateDiff() and CoinWarmStartDual::applyDiff().
-
-  The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_.
-    
-*/
-
-class CoinWarmStartDualDiff : public virtual CoinWarmStartDiff
-{ public:
-
-  /*! \brief `Virtual constructor' */
-  virtual CoinWarmStartDiff *clone() const
-  {
-      return new CoinWarmStartDualDiff(*this) ;
-  }
-
-  /*! \brief Assignment */
-  virtual CoinWarmStartDualDiff &operator= (const CoinWarmStartDualDiff &rhs)
-  {
-      if (this != &rhs) {
-	  diff_ = rhs.diff_;
-      }
-      return *this;
-  }
-
-  /*! \brief Destructor */
-  virtual ~CoinWarmStartDualDiff() {}
-
-  protected:
-
-  /*! \brief Default constructor
-  
-    This is protected (rather than private) so that derived classes can
-    see it when they make <i>their</i> default constructor protected or
-    private.
-  */
-  CoinWarmStartDualDiff () : diff_() {}
-
-  /*! \brief Copy constructor
-  
-    For convenience when copying objects containing CoinWarmStartDualDiff
-    objects. But consider whether you should be using #clone() to retain
-    polymorphism.
-
-    This is protected (rather than private) so that derived classes can
-    see it when the make <i>their</i> copy constructor protected or
-    private.
-  */
-  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) ;
-
-  /*! \brief Standard constructor */
-  CoinWarmStartDualDiff (int sze, const unsigned int *const diffNdxs,
-			 const double *const diffVals) :
-      diff_(sze, diffNdxs, diffVals) {}
-
-  /*!
-      \brief The difference in the dual vector is simply the difference in a
-      vector.
-  */
-  CoinWarmStartVectorDiff<double> diff_;
-};
-
-
-#endif
-

data/ext/ruby-cbc/install/include/coin/CoinWarmStartPrimalDual.hpp

@@ -1,211 +0,0 @@
-/* $Id: CoinWarmStartPrimalDual.hpp 1372 2011-01-03 23:31:00Z lou $ */
-// 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"
-
-
-//#############################################################################
-
-/** WarmStart information that is only a dual vector */
-
-class CoinWarmStartPrimalDual : public virtual CoinWarmStart {
-public:
-  /// return the size of the dual vector
-  inline int dualSize() const { return dual_.size(); }
-  /// return a pointer to the array of duals
-  inline const double * dual() const { return dual_.values(); }
-
-  /// return the size of the primal vector
-  inline int primalSize() const { return primal_.size(); }
-  /// return a pointer to the array of primals
-  inline const double * primal() const { return primal_.values(); }
-
-  /** Assign the primal/dual vectors to be the warmstart information. In this
-      method the object assumes ownership of the pointers and upon return \c
-      primal and \c dual will be a NULL pointers. If copying is desirable use
-      the constructor.
-
-      NOTE: \c primal and \c dual must have been allocated by new double[],
-      because they will be freed by delete[] upon the desructtion of this
-      object...
-  */
-  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;
-  }
-
-  /*! \brief Clear the data
-
-  Make it appear as if the warmstart was just created using the default
-  constructor.
-  */
-  inline void clear() {
-    primal_.clear();
-    dual_.clear();
-  }
-
-  inline void swap(CoinWarmStartPrimalDual& rhs) {
-    if (this != &rhs) {
-      primal_.swap(rhs.primal_);
-      dual_.swap(rhs.dual_);
-    }
-  }
-
-  /** `Virtual constructor' */
-  virtual CoinWarmStart *clone() const {
-    return new CoinWarmStartPrimalDual(*this);
-  }
-
-  virtual ~CoinWarmStartPrimalDual() {}
-
-  /*! \name PrimalDual warm start `diff' methods */
-  //@{
-
-  /*! \brief Generate a `diff' that can convert the warm start passed as a
-    parameter to the warm start specified by \c this.
-
-    The capabilities are limited: the basis passed as a parameter can be no
-    larger than the basis pointed to by \c this.
-  */
-
-  virtual CoinWarmStartDiff*
-  generateDiff (const CoinWarmStart *const oldCWS) const ;
-
-  /*! \brief Apply \p diff to this warm start.
-
-  Update this warm start by applying \p diff. It's assumed that the
-  allocated capacity of the warm start is sufficiently large.
-  */
-
-  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:
-  ///@name Private data members
-  //@{
-  CoinWarmStartVector<double> primal_;
-  CoinWarmStartVector<double> dual_;
-  //@}
-};
-
-//#############################################################################
-
-/*! \class CoinWarmStartPrimalDualDiff
-  \brief A `diff' between two CoinWarmStartPrimalDual objects
-
-  This class exists in order to hide from the world the details of calculating
-  and representing a `diff' between two CoinWarmStartPrimalDual objects. For
-  convenience, assignment, cloning, and deletion are visible to the world, and
-  default and copy constructors are made available to derived classes.
-  Knowledge of the rest of this structure, and of generating and applying
-  diffs, is restricted to the friend functions
-  CoinWarmStartPrimalDual::generateDiff() and
-  CoinWarmStartPrimalDual::applyDiff().
-
-  The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_.
-    
-*/
-
-class CoinWarmStartPrimalDualDiff : public virtual CoinWarmStartDiff
-{
-  friend CoinWarmStartDiff*
-  CoinWarmStartPrimalDual::generateDiff(const CoinWarmStart *const oldCWS) const;
-  friend void
-  CoinWarmStartPrimalDual::applyDiff(const CoinWarmStartDiff *const diff) ;
-
-public:
-
-  /*! \brief `Virtual constructor'. To be used when retaining polymorphism is
-    important */
-  virtual CoinWarmStartDiff *clone() const
-  {
-    return new CoinWarmStartPrimalDualDiff(*this);
-  }
-
-  /*! \brief Destructor */
-  virtual ~CoinWarmStartPrimalDualDiff() {}
-
-protected:
-
-  /*! \brief Default constructor
-  
-  This is protected (rather than private) so that derived classes can
-  see it when they make <i>their</i> default constructor protected or
-  private.
-  */
-  CoinWarmStartPrimalDualDiff () : primalDiff_(), dualDiff_() {}
-
-  /*! \brief Copy constructor
-  
-  For convenience when copying objects containing
-  CoinWarmStartPrimalDualDiff objects. But consider whether you should be
-  using #clone() to retain polymorphism.
-
-  This is protected (rather than private) so that derived classes can
-  see it when the make <i>their</i> copy constructor protected or
-  private.
-  */
-  CoinWarmStartPrimalDualDiff (const CoinWarmStartPrimalDualDiff &rhs) :
-    primalDiff_(rhs.primalDiff_), dualDiff_(rhs.dualDiff_) {}
-
-  /*! \brief Clear the data
-
-  Make it appear as if the diff was just created using the default
-  constructor.
-  */
-  inline void clear() {
-    primalDiff_.clear();
-    dualDiff_.clear();
-  }
-
-  inline void swap(CoinWarmStartPrimalDualDiff& rhs) {
-    if (this != &rhs) {
-      primalDiff_.swap(rhs.primalDiff_);
-      dualDiff_.swap(rhs.dualDiff_);
-    }
-  }
-
-private:
-
-  /*!
-    \brief These two differences describe the differences in the primal and
-    in the dual vector.
-  */
-  CoinWarmStartVectorDiff<double> primalDiff_;
-  CoinWarmStartVectorDiff<double> dualDiff_;
-} ;
-
-#endif

data/ext/ruby-cbc/install/include/coin/CoinWarmStartVector.hpp

@@ -1,488 +0,0 @@
-/* $Id: CoinWarmStartVector.hpp 1498 2011-11-02 15:25:35Z mjs $ */
-// 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 CoinWarmStartVector_H
-#define CoinWarmStartVector_H
-
-#if defined(_MSC_VER)
-// Turn off compiler warning about long names
-#  pragma warning(disable:4786)
-#endif
-
-#include <cassert>
-#include <cmath>
-
-#include "CoinHelperFunctions.hpp"
-#include "CoinWarmStart.hpp"
-
-
-//#############################################################################
-
-/** WarmStart information that is only a vector */
-
-template <typename T>
-class CoinWarmStartVector : public virtual CoinWarmStart
-{
-protected:
-  inline void gutsOfDestructor() {
-    delete[] values_;
-  }
-  inline void gutsOfCopy(const CoinWarmStartVector<T>& rhs) {
-    size_  = rhs.size_;
-    values_ = new T[size_];
-    CoinDisjointCopyN(rhs.values_, size_, values_);
-  }
-
-public:
-  /// return the size of the vector
-  int size() const { return size_; }
-  /// return a pointer to the array of vectors
-  const T* values() const { return values_; }
-
-  /** Assign the vector to be the warmstart information. In this method
-      the object assumes ownership of the pointer and upon return #vector will
-      be a NULL pointer. If copying is desirable use the constructor. */
-  void assignVector(int size, T*& vec) {
-    size_ = size;
-    delete[] values_;
-    values_ = vec;
-    vec = NULL;
-  }
-
-  CoinWarmStartVector() : size_(0), values_(NULL) {}
-
-  CoinWarmStartVector(int size, const T* vec) :
-    size_(size), values_(new T[size]) {
-    CoinDisjointCopyN(vec, size, values_);
-  }
-
-  CoinWarmStartVector(const CoinWarmStartVector& rhs) {
-    gutsOfCopy(rhs);
-  }
-
-  CoinWarmStartVector& operator=(const CoinWarmStartVector& rhs) {
-    if (this != &rhs) {
-      gutsOfDestructor();
-      gutsOfCopy(rhs);
-    }
-    return *this;
-  }
-
-  inline void swap(CoinWarmStartVector& rhs) {
-    if (this != &rhs) {
-      std::swap(size_, rhs.size_);
-      std::swap(values_, rhs.values_);
-    }
-  }
-
-  /** `Virtual constructor' */
-  virtual CoinWarmStart *clone() const {
-    return new CoinWarmStartVector(*this);
-  }
-     
-  virtual ~CoinWarmStartVector() {
-    gutsOfDestructor();
-  }
-
-  /*! \brief Clear the data
-
-  Make it appear as if the warmstart was just created using the default
-  constructor.
-  */
-  inline void clear() {
-    size_ = 0;
-    delete[] values_;
-    values_ = NULL;
-  }
-
-  /*! \name Vector warm start `diff' methods */
-  //@{
-
-  /*! \brief Generate a `diff' that can convert the warm start passed as a
-    parameter to the warm start specified by \c this.
-
-    The capabilities are limited: the basis passed as a parameter can be no
-    larger than the basis pointed to by \c this.
-  */
-
-  virtual CoinWarmStartDiff*
-  generateDiff (const CoinWarmStart *const oldCWS) const ;
-
-  /*! \brief Apply \p diff to this warm start.
-
-  Update this warm start by applying \p diff. It's assumed that the
-  allocated capacity of the warm start is sufficiently large.
-  */
-
-  virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;
-
-  //@}
-
-private:
-  ///@name Private data members
-  //@{
-  /// the size of the vector
-  int size_;
-  /// the vector itself
-  T* values_;
-  //@}
-};
-
-//=============================================================================
-
-/*! \class CoinWarmStartVectorDiff
-  \brief A `diff' between two CoinWarmStartVector objects
-
-  This class exists in order to hide from the world the details of calculating
-  and representing a `diff' between two CoinWarmStartVector objects. For
-  convenience, assignment, cloning, and deletion are visible to the world, and
-  default and copy constructors are made available to derived classes.
-  Knowledge of the rest of this structure, and of generating and applying
-  diffs, is restricted to the friend functions
-  CoinWarmStartVector::generateDiff() and CoinWarmStartVector::applyDiff().
-
-  The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_.
-    
-*/
-
-template <typename T>
-class CoinWarmStartVectorDiff : public virtual CoinWarmStartDiff
-{
-  friend CoinWarmStartDiff*
-  CoinWarmStartVector<T>::generateDiff(const CoinWarmStart *const oldCWS) const;
-  friend void
-  CoinWarmStartVector<T>::applyDiff(const CoinWarmStartDiff *const diff) ;
-
-public:
-
-  /*! \brief `Virtual constructor' */
-  virtual CoinWarmStartDiff * clone() const {
-    return new CoinWarmStartVectorDiff(*this) ;
-  }
-
-  /*! \brief Assignment */
-  virtual CoinWarmStartVectorDiff &
-  operator= (const CoinWarmStartVectorDiff<T>& rhs) ;
-
-  /*! \brief Destructor */
-  virtual ~CoinWarmStartVectorDiff() {
-    delete[] diffNdxs_ ;
-    delete[] diffVals_ ;
-  }
-
-  inline void swap(CoinWarmStartVectorDiff& rhs) {
-    if (this != &rhs) {
-      std::swap(sze_, rhs.sze_);
-      std::swap(diffNdxs_, rhs.diffNdxs_);
-      std::swap(diffVals_, rhs.diffVals_);
-    }
-  }
-
-  /*! \brief Default constructor
-   */
-  CoinWarmStartVectorDiff () : sze_(0), diffNdxs_(0), diffVals_(NULL) {} 
-
-  /*! \brief Copy constructor
-  
-  For convenience when copying objects containing CoinWarmStartVectorDiff
-  objects. But consider whether you should be using #clone() to retain
-  polymorphism.
-  */
-  CoinWarmStartVectorDiff(const CoinWarmStartVectorDiff<T>& rhs) ;
-
-  /*! \brief Standard constructor */
-  CoinWarmStartVectorDiff(int sze, const unsigned int* const diffNdxs,
-			  const T* const diffVals) ;
-  
-  /*! \brief Clear the data
-
-  Make it appear as if the diff was just created using the default
-  constructor.
-  */
-  inline void clear() {
-    sze_ = 0;
-    delete[] diffNdxs_;  diffNdxs_ = NULL;
-    delete[] diffVals_;  diffVals_ = NULL;
-  }
-
-private:
-
-  /*!
-    \brief Number of entries (and allocated capacity), in units of \c T.
-  */
-  int sze_ ;
-
-  /*! \brief Array of diff indices */
-
-  unsigned int* diffNdxs_ ;
-
-  /*! \brief Array of diff values */
-
-  T* diffVals_ ;
-};
-
-//##############################################################################
-
-template <typename T, typename U>
-class CoinWarmStartVectorPair : public virtual CoinWarmStart 
-{
-private:
-  CoinWarmStartVector<T> t_;
-  CoinWarmStartVector<U> u_;
-
-public:
-  inline int size0() const { return t_.size(); }
-  inline int size1() const { return u_.size(); }
-  inline const T* values0() const { return t_.values(); }
-  inline const U* values1() const { return u_.values(); }
-
-  inline void assignVector0(int size, T*& vec) { t_.assignVector(size, vec); }
-  inline void assignVector1(int size, U*& vec) { u_.assignVector(size, vec); }
-
-  CoinWarmStartVectorPair() {}
-  CoinWarmStartVectorPair(int s0, const T* v0, int s1, const U* v1) :
-    t_(s0, v0), u_(s1, v1) {}
-
-  CoinWarmStartVectorPair(const CoinWarmStartVectorPair<T,U>& rhs) :
-    t_(rhs.t_), u_(rhs.u_) {}
-  CoinWarmStartVectorPair& operator=(const CoinWarmStartVectorPair<T,U>& rhs) {
-    if (this != &rhs) {
-      t_ = rhs.t_;
-      u_ = rhs.u_;
-    }	
-    return *this;
-  }
-
-  inline void swap(CoinWarmStartVectorPair<T,U>& rhs) {
-    t_.swap(rhs.t_);
-    u_.swap(rhs.u_);
-  }
-
-  virtual CoinWarmStart *clone() const {
-    return new CoinWarmStartVectorPair(*this);
-  }
-
-  virtual ~CoinWarmStartVectorPair() {}
-
-  inline void clear() {
-    t_.clear();
-    u_.clear();
-  }
-
-  virtual CoinWarmStartDiff*
-  generateDiff (const CoinWarmStart *const oldCWS) const ;
-
-  virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;
-};
-
-//=============================================================================
-
-template <typename T, typename U>
-class CoinWarmStartVectorPairDiff : public virtual CoinWarmStartDiff
-{
-  friend CoinWarmStartDiff*
-  CoinWarmStartVectorPair<T,U>::generateDiff(const CoinWarmStart *const oldCWS) const;
-  friend void
-  CoinWarmStartVectorPair<T,U>::applyDiff(const CoinWarmStartDiff *const diff) ;
-
-private:
-  CoinWarmStartVectorDiff<T> tdiff_;
-  CoinWarmStartVectorDiff<U> udiff_;
-
-public:
-  CoinWarmStartVectorPairDiff() {}
-  CoinWarmStartVectorPairDiff(const CoinWarmStartVectorPairDiff<T,U>& rhs) :
-    tdiff_(rhs.tdiff_), udiff_(rhs.udiff_) {}
-  virtual ~CoinWarmStartVectorPairDiff() {}
-
-  virtual CoinWarmStartVectorPairDiff&
-  operator=(const CoinWarmStartVectorPairDiff<T,U>& rhs) {
-	  if (this != &rhs) {
-		  tdiff_ = rhs.tdiff_;
-		  udiff_ = rhs.udiff_;
-	  }
-    return *this;
-  }
-
-  virtual CoinWarmStartDiff * clone() const {
-    return new CoinWarmStartVectorPairDiff(*this) ;
-  }
-
-  inline void swap(CoinWarmStartVectorPairDiff<T,U>& rhs) {
-    tdiff_.swap(rhs.tdiff_);
-    udiff_.swap(rhs.udiff_);
-  }
-
-  inline void clear() {
-    tdiff_.clear();
-    udiff_.clear();
-  }
-};
-
-//##############################################################################
-//#############################################################################
-
-/*
-  Generate a `diff' that can convert the warm start passed as a parameter to
-  the warm start specified by this.
-
-  The capabilities are limited: the basis passed as a parameter can be no
-  larger than the basis pointed to by this.
-*/
-
-template <typename T> CoinWarmStartDiff*
-CoinWarmStartVector<T>::generateDiff(const CoinWarmStart *const oldCWS) const
-{ 
-/*
-  Make sure the parameter is CoinWarmStartVector or derived class.
-*/
-  const CoinWarmStartVector<T>* oldVector =
-    dynamic_cast<const CoinWarmStartVector<T>*>(oldCWS);
-  if (!oldVector)
-    { throw CoinError("Old warm start not derived from CoinWarmStartVector.",
-		      "generateDiff","CoinWarmStartVector") ; }
-  const CoinWarmStartVector<T>* newVector = this ;
-  /*
-    Make sure newVector is equal or bigger than oldVector. Calculate the worst
-    case number of diffs and allocate vectors to hold them.
-  */
-  const int oldCnt = oldVector->size() ;
-  const int newCnt = newVector->size() ;
-
-  assert(newCnt >= oldCnt) ;
-
-  unsigned int *diffNdx = new unsigned int [newCnt]; 
-  T* diffVal = new T[newCnt]; 
-  /*
-    Scan the vector vectors.  For the portion of the vectors which overlap,
-    create diffs. Then add any additional entries from newVector.
-  */
-  const T*oldVal = oldVector->values() ;
-  const T*newVal = newVector->values() ;
-  int numberChanged = 0 ;
-  int i ;
-  for (i = 0 ; i < oldCnt ; i++) {
-    if (oldVal[i] != newVal[i]) {
-      diffNdx[numberChanged] = i ;
-      diffVal[numberChanged++] = newVal[i] ;
-    }
-  }
-  for ( ; i < newCnt ; i++) {
-    diffNdx[numberChanged] = i ;
-    diffVal[numberChanged++] = newVal[i] ;
-  }
-  /*
-    Create the object of our desire.
-  */
-  CoinWarmStartVectorDiff<T> *diff =
-    new CoinWarmStartVectorDiff<T>(numberChanged,diffNdx,diffVal) ;
-  /*
-    Clean up and return.
-  */
-  delete[] diffNdx ;
-  delete[] diffVal ;
-
-  return diff;
-  //  return (dynamic_cast<CoinWarmStartDiff<T>*>(diff)) ;
-}
-
-
-/*
-  Apply diff to this warm start.
-  
-  Update this warm start by applying diff. It's assumed that the
-  allocated capacity of the warm start is sufficiently large.
-*/
-
-template <typename T> void
-CoinWarmStartVector<T>::applyDiff (const CoinWarmStartDiff *const cwsdDiff)
-{
-  /*
-    Make sure we have a CoinWarmStartVectorDiff
-  */
-  const CoinWarmStartVectorDiff<T>* diff =
-    dynamic_cast<const CoinWarmStartVectorDiff<T>*>(cwsdDiff) ;
-  if (!diff) {
-    throw CoinError("Diff not derived from CoinWarmStartVectorDiff.",
-		    "applyDiff","CoinWarmStartVector") ;
-  }
-  /*
-    Application is by straighforward replacement of words in the vector vector.
-  */
-  const int numberChanges = diff->sze_ ;
-  const unsigned int *diffNdxs = diff->diffNdxs_ ;
-  const T* diffVals = diff->diffVals_ ;
-  T* vals = this->values_ ;
-
-  for (int i = 0 ; i < numberChanges ; i++) {
-    unsigned int diffNdx = diffNdxs[i] ;
-    T diffVal = diffVals[i] ;
-    vals[diffNdx] = diffVal ;
-  }
-}
-
-//#############################################################################
-
-
-// Assignment
-
-template <typename T> CoinWarmStartVectorDiff<T>&
-CoinWarmStartVectorDiff<T>::operator=(const CoinWarmStartVectorDiff<T> &rhs)
-{
-  if (this != &rhs) {
-    if (sze_ > 0) {
-      delete[] diffNdxs_ ;
-      delete[] diffVals_ ;
-    }
-    sze_ = rhs.sze_ ;
-    if (sze_ > 0) {
-      diffNdxs_ = new unsigned int[sze_] ;
-      memcpy(diffNdxs_,rhs.diffNdxs_,sze_*sizeof(unsigned int)) ;
-      diffVals_ = new T[sze_] ;
-      memcpy(diffVals_,rhs.diffVals_,sze_*sizeof(T)) ;
-    } else {
-      diffNdxs_ = 0 ;
-      diffVals_ = 0 ;
-    }
-  }
-
-  return (*this) ;
-}
-
-
-// Copy constructor
-
-template <typename T>
-CoinWarmStartVectorDiff<T>::CoinWarmStartVectorDiff(const CoinWarmStartVectorDiff<T> &rhs)
-  : sze_(rhs.sze_),
-    diffNdxs_(0),
-    diffVals_(0)
-{
-  if (sze_ > 0) {
-    diffNdxs_ = new unsigned int[sze_] ;
-    memcpy(diffNdxs_,rhs.diffNdxs_,sze_*sizeof(unsigned int)) ;
-    diffVals_ = new T[sze_] ;
-    memcpy(diffVals_,rhs.diffVals_,sze_*sizeof(T)) ;
-  }
-}
-
-/// Standard constructor
-
-template <typename T>
-CoinWarmStartVectorDiff<T>::CoinWarmStartVectorDiff
-(int sze, const unsigned int *const diffNdxs, const T *const diffVals)
-  : sze_(sze),
-    diffNdxs_(0),
-    diffVals_(0)
-{
-  if (sze > 0) {
-    diffNdxs_ = new unsigned int[sze] ;
-    memcpy(diffNdxs_,diffNdxs,sze*sizeof(unsigned int)) ;
-    diffVals_ = new T[sze] ;
-    memcpy(diffVals_,diffVals,sze*sizeof(T)) ;
-  }
-}
-
-#endif