6 #ifndef CoinWarmStartVector_H
7 #define CoinWarmStartVector_H
11 # pragma warning(disable:4786)
150 template <
typename T>
197 const T*
const diffVals) ;
228 template <
typename T,
typename U>
236 inline int size0()
const {
return t_.size(); }
246 t_(s0, v0),
u_(s1, v1) {}
282 template <
typename T,
typename U>
344 {
throw CoinError(
"Old warm start not derived from CoinWarmStartVector.",
345 "generateDiff",
"CoinWarmStartVector") ; }
351 const int oldCnt = oldVector->
size() ;
352 const int newCnt = newVector->
size() ;
354 assert(newCnt >= oldCnt) ;
356 unsigned int *diffNdx =
new unsigned int [newCnt];
357 T* diffVal =
new T[newCnt];
362 const T*oldVal = oldVector->
values() ;
363 const T*newVal = newVector->
values() ;
364 int numberChanged = 0 ;
366 for (i = 0 ; i < oldCnt ; i++) {
367 if (oldVal[i] != newVal[i]) {
368 diffNdx[numberChanged] = i ;
369 diffVal[numberChanged++] = newVal[i] ;
372 for ( ; i < newCnt ; i++) {
373 diffNdx[numberChanged] = i ;
374 diffVal[numberChanged++] = newVal[i] ;
399 template <
typename T>
void
408 throw CoinError(
"Diff not derived from CoinWarmStartVectorDiff.",
409 "applyDiff",
"CoinWarmStartVector") ;
414 const int numberChanges = diff->
sze_ ;
415 const unsigned int *diffNdxs = diff->
diffNdxs_ ;
417 T* vals = this->values_ ;
419 for (
int i = 0 ; i < numberChanges ; i++) {
420 unsigned int diffNdx = diffNdxs[i] ;
421 T diffVal = diffVals[i] ;
422 vals[diffNdx] = diffVal ;
441 diffNdxs_ =
new unsigned int[sze_] ;
442 memcpy(diffNdxs_,rhs.
diffNdxs_,sze_*
sizeof(
unsigned int)) ;
443 diffVals_ =
new T[sze_] ;
444 memcpy(diffVals_,rhs.
diffVals_,sze_*
sizeof(T)) ;
457 template <
typename T>
473 template <
typename T>
475 (
int sze,
const unsigned int *
const diffNdxs,
const T *
const diffVals)
481 diffNdxs_ =
new unsigned int[sze] ;
482 memcpy(diffNdxs_,diffNdxs,sze*
sizeof(
unsigned int)) ;
483 diffVals_ =
new T[sze] ;
484 memcpy(diffVals_,diffVals,sze*
sizeof(T)) ;
CoinWarmStartVector & operator=(const CoinWarmStartVector &rhs)
void clear()
Clear the data.
T * diffVals_
Array of diff values.
CoinWarmStartVector(const CoinWarmStartVector &rhs)
virtual ~CoinWarmStartVectorPairDiff()
void gutsOfCopy(const CoinWarmStartVector< T > &rhs)
int size() const
return the size of the vector
virtual ~CoinWarmStartVector()
virtual CoinWarmStartDiff * generateDiff(const CoinWarmStart *const oldCWS) const
void CoinDisjointCopyN(register const T *from, const int size, register T *to)
This helper function copies an array to another location.
const T * values() const
return a pointer to the array of vectors
Abstract base class for warm start `diff' objects.
CoinWarmStartVectorPair(const CoinWarmStartVectorPair< T, U > &rhs)
int sze_
Number of entries (and allocated capacity), in units of T.
const T * values0() const
virtual CoinWarmStart * clone() const
`Virtual constructor'
const U * values1() const
virtual ~CoinWarmStartVectorDiff()
Destructor.
T * values_
the vector itself
int size_
the size of the vector
virtual void applyDiff(const CoinWarmStartDiff *const cwsdDiff)
void swap(CoinWarmStartVector &rhs)
void assignVector0(int size, T *&vec)
virtual CoinWarmStartVectorPairDiff & operator=(const CoinWarmStartVectorPairDiff< T, U > &rhs)
CoinWarmStartVector< U > u_
CoinWarmStartVectorPairDiff(const CoinWarmStartVectorPairDiff< T, U > &rhs)
WarmStart information that is only a vector.
Declaration of the generic simplex (basis-oriented) warm start class. Also contains a basis diff clas...
CoinWarmStartVector(int size, const T *vec)
void swap(CoinWarmStartVectorDiff &rhs)
CoinWarmStartVectorDiff()
Default constructor.
CoinWarmStartVectorPair(int s0, const T *v0, int s1, const U *v1)
virtual CoinWarmStart * clone() const
`Virtual constructor'
void assignVector(int size, T *&vec)
Assign the vector to be the warmstart information.
virtual CoinWarmStartVectorDiff & operator=(const CoinWarmStartVectorDiff< T > &rhs)
Assignment.
void swap(CoinWarmStartVectorPairDiff< T, U > &rhs)
void assignVector1(int size, U *&vec)
virtual CoinWarmStartDiff * clone() const
`Virtual constructor'
virtual void applyDiff(const CoinWarmStartDiff *const cwsdDiff)
Apply diff to this warm start.
virtual CoinWarmStartDiff * generateDiff(const CoinWarmStart *const oldCWS) const
Generate a `diff' that can convert the warm start passed as a parameter to the warm start specified b...
virtual CoinWarmStartDiff * clone() const
`Virtual constructor'
virtual ~CoinWarmStartVectorPair()
Abstract base class for warm start information.
CoinWarmStartVectorPairDiff()
Error Class thrown by an exception.
CoinWarmStartVectorPair()
CoinWarmStartVectorDiff< U > udiff_
CoinWarmStartVector< T > t_
A `diff' between two CoinWarmStartVector objects.
CoinWarmStartVectorDiff< T > tdiff_
CoinWarmStartVectorPair & operator=(const CoinWarmStartVectorPair< T, U > &rhs)
unsigned int * diffNdxs_
Array of diff indices.
void clear()
Clear the data.
void swap(CoinWarmStartVectorPair< T, U > &rhs)