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

Go to the documentation of this file.

// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinDenseVector_H
#define CoinDenseVector_H

#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif

#include <cassert>
#include <cstdlib>
#include <cmath>
#include "CoinHelperFunctions.hpp"

//#############################################################################
    template <typename T> void
    CoinDenseVectorUnitTest(T dummy);

//#############################################################################
template <typename T> class CoinDenseVector {
private:

   int nElements_;
   T * elements_;
  
public:

   inline int getNumElements() const { return nElements_; }
   inline int size() const { return nElements_; }
   inline const T * getElements() const { return elements_; }
   inline T * getElements() { return elements_; }
 
   //-------------------------------------------------------------------
   // Set indices and elements
   //------------------------------------------------------------------- 

   void clear();
   CoinDenseVector & operator=(const CoinDenseVector &);
   T & operator[](int index) const;

   void setVector(int size, const T * elems);

  
   void setConstant(int size, T elems);
  

   void setElement(int index, T element);
   void resize(int newSize, T fill=T()); 

   void append(const CoinDenseVector &);


   inline T oneNorm() const {
     T norm = 0;
     for (int i=0; i<nElements_; i++)
       norm += CoinAbs(elements_[i]);
     return norm;
   }
   inline double twoNorm() const {
     double norm = 0.;
     for (int i=0; i<nElements_; i++)
       norm += elements_[i] * elements_[i];
     // std namespace removed because it was causing a compile
     // problem with Microsoft Visual C++
     return /*std::*/sqrt(norm);
   }
   inline T infNorm() const {
     T norm = 0;
     for (int i=0; i<nElements_; i++)
       norm = CoinMax(norm, CoinAbs(elements_[i]));
     return norm;
   }
   inline T sum() const {
     T sume = 0;
     for (int i=0; i<nElements_; i++)
       sume += elements_[i];
     return sume;
   }
   inline void scale(T factor) {
     for (int i=0; i<nElements_; i++)
       elements_[i] *= factor;
     return;
   }


   void operator+=(T value);
   void operator-=(T value);
   void operator*=(T value);
   void operator/=(T value);

   CoinDenseVector();
   CoinDenseVector(int size, const T * elems);
   CoinDenseVector(int size, T element=T());
   CoinDenseVector(const CoinDenseVector &);

   ~CoinDenseVector ();
    
private:

   void gutsOfSetVector(int size, const T * elems);
   void gutsOfSetConstant(int size, T value);
};

//#############################################################################


template <typename T> inline
CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1,
                             const CoinDenseVector<T>& op2){
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] + elements2[i];
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1,
                             const CoinDenseVector<T>& op2){
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] - elements2[i];
  return op3;
}


template <typename T> inline
CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1,
                          const CoinDenseVector<T>& op2){
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] * elements2[i];
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1,
                          const CoinDenseVector<T>& op2){
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] / elements2[i];
  return op3;
}


template <typename T> inline
CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1, T value){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] + dvalue;
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1, T value){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] - dvalue;
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1, T value){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] * dvalue;
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1, T value){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] / dvalue;
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator+(T value, const CoinDenseVector<T>& op1){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] + dvalue;
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator-(T value, const CoinDenseVector<T>& op1){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = dvalue - elements1[i];
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator*(T value, const CoinDenseVector<T>& op1){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = elements1[i] * dvalue;
  return op3;
}

template <typename T> inline
CoinDenseVector<T> operator/(T value, const CoinDenseVector<T>& op1){
  int size = op1.size();
  CoinDenseVector<T> op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for(int i=0; i<size; i++)
    elements3[i] = dvalue / elements1[i];
  return op3;
}

#endif

---