• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

/build/buildd/coinutils-2.6.4/CoinUtils/src/CoinDenseVector.hpp

Go to the documentation of this file.
00001 /* $Id: CoinDenseVector.hpp 1215 2009-11-05 11:03:04Z forrest $ */
00002 // Copyright (C) 2003, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 #ifndef CoinDenseVector_H
00005 #define CoinDenseVector_H
00006 
00007 #if defined(_MSC_VER)
00008 // Turn off compiler warning about long names
00009 #  pragma warning(disable:4786)
00010 #endif
00011 
00012 #include <cassert>
00013 #include <cstdlib>
00014 #include <cmath>
00015 #include "CoinHelperFunctions.hpp"
00016 
00017 //#############################################################################
00023     template <typename T> void
00024     CoinDenseVectorUnitTest(T dummy);
00025 
00026 //#############################################################################
00065 template <typename T> class CoinDenseVector {
00066 private:
00069 
00070    int nElements_;
00072    T * elements_;
00074   
00075 public:
00078 
00079    inline int getNumElements() const { return nElements_; }
00080    inline int size() const { return nElements_; }
00082    inline const T * getElements() const { return elements_; }
00084    inline T * getElements() { return elements_; }
00086  
00087    //-------------------------------------------------------------------
00088    // Set indices and elements
00089    //------------------------------------------------------------------- 
00092 
00093    void clear();
00095    CoinDenseVector & operator=(const CoinDenseVector &);
00097    T & operator[](int index) const;
00098 
00103    void setVector(int size, const T * elems);
00104 
00105   
00107    void setConstant(int size, T elems);
00108   
00109 
00113    void setElement(int index, T element);
00117    void resize(int newSize, T fill=T()); 
00118 
00120    void append(const CoinDenseVector &);
00122 
00125 
00126    inline T oneNorm() const {
00127      T norm = 0;
00128      for (int i=0; i<nElements_; i++)
00129        norm += CoinAbs(elements_[i]);
00130      return norm;
00131    }
00133    inline double twoNorm() const {
00134      double norm = 0.;
00135      for (int i=0; i<nElements_; i++)
00136        norm += elements_[i] * elements_[i];
00137      // std namespace removed because it was causing a compile
00138      // problem with Microsoft Visual C++
00139      return /*std::*/sqrt(norm);
00140    }
00142    inline T infNorm() const {
00143      T norm = 0;
00144      for (int i=0; i<nElements_; i++)
00145        norm = CoinMax(norm, CoinAbs(elements_[i]));
00146      return norm;
00147    }
00149    inline T sum() const {
00150      T sume = 0;
00151      for (int i=0; i<nElements_; i++)
00152        sume += elements_[i];
00153      return sume;
00154    }
00156    inline void scale(T factor) {
00157      for (int i=0; i<nElements_; i++)
00158        elements_[i] *= factor;
00159      return;
00160    }
00162 
00165 
00166    void operator+=(T value);
00168    void operator-=(T value);
00170    void operator*=(T value);
00172    void operator/=(T value);
00174 
00178    CoinDenseVector();
00180    CoinDenseVector(int size, const T * elems);
00182    CoinDenseVector(int size, T element=T());
00184    CoinDenseVector(const CoinDenseVector &);
00185 
00187    ~CoinDenseVector ();
00189     
00190 private:
00193 
00194    void gutsOfSetVector(int size, const T * elems);
00196    void gutsOfSetConstant(int size, T value);
00198 };
00199 
00200 //#############################################################################
00201 
00209 
00210 template <typename T> inline
00211 CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1,
00212                              const CoinDenseVector<T>& op2){
00213   assert(op1.size() == op2.size());
00214   int size = op1.size();
00215   CoinDenseVector<T> op3(size);
00216   const T *elements1 = op1.getElements();
00217   const T *elements2 = op2.getElements();
00218   T *elements3 = op3.getElements();
00219   for(int i=0; i<size; i++)
00220     elements3[i] = elements1[i] + elements2[i];
00221   return op3;
00222 }
00223 
00225 template <typename T> inline
00226 CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1,
00227                              const CoinDenseVector<T>& op2){
00228   assert(op1.size() == op2.size());
00229   int size = op1.size();
00230   CoinDenseVector<T> op3(size);
00231   const T *elements1 = op1.getElements();
00232   const T *elements2 = op2.getElements();
00233   T *elements3 = op3.getElements();
00234   for(int i=0; i<size; i++)
00235     elements3[i] = elements1[i] - elements2[i];
00236   return op3;
00237 }
00238 
00239 
00241 template <typename T> inline
00242 CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1,
00243                           const CoinDenseVector<T>& op2){
00244   assert(op1.size() == op2.size());
00245   int size = op1.size();
00246   CoinDenseVector<T> op3(size);
00247   const T *elements1 = op1.getElements();
00248   const T *elements2 = op2.getElements();
00249   T *elements3 = op3.getElements();
00250   for(int i=0; i<size; i++)
00251     elements3[i] = elements1[i] * elements2[i];
00252   return op3;
00253 }
00254 
00256 template <typename T> inline
00257 CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1,
00258                           const CoinDenseVector<T>& op2){
00259   assert(op1.size() == op2.size());
00260   int size = op1.size();
00261   CoinDenseVector<T> op3(size);
00262   const T *elements1 = op1.getElements();
00263   const T *elements2 = op2.getElements();
00264   T *elements3 = op3.getElements();
00265   for(int i=0; i<size; i++)
00266     elements3[i] = elements1[i] / elements2[i];
00267   return op3;
00268 }
00270 
00276 
00277 template <typename T> inline
00278 CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1, T value){
00279   int size = op1.size();
00280   CoinDenseVector<T> op3(size);
00281   const T *elements1 = op1.getElements();
00282   T *elements3 = op3.getElements();
00283   double dvalue = value;
00284   for(int i=0; i<size; i++)
00285     elements3[i] = elements1[i] + dvalue;
00286   return op3;
00287 }
00288 
00290 template <typename T> inline
00291 CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1, T value){
00292   int size = op1.size();
00293   CoinDenseVector<T> op3(size);
00294   const T *elements1 = op1.getElements();
00295   T *elements3 = op3.getElements();
00296   double dvalue = value;
00297   for(int i=0; i<size; i++)
00298     elements3[i] = elements1[i] - dvalue;
00299   return op3;
00300 }
00301 
00303 template <typename T> inline
00304 CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1, T value){
00305   int size = op1.size();
00306   CoinDenseVector<T> op3(size);
00307   const T *elements1 = op1.getElements();
00308   T *elements3 = op3.getElements();
00309   double dvalue = value;
00310   for(int i=0; i<size; i++)
00311     elements3[i] = elements1[i] * dvalue;
00312   return op3;
00313 }
00314 
00316 template <typename T> inline
00317 CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1, T value){
00318   int size = op1.size();
00319   CoinDenseVector<T> op3(size);
00320   const T *elements1 = op1.getElements();
00321   T *elements3 = op3.getElements();
00322   double dvalue = value;
00323   for(int i=0; i<size; i++)
00324     elements3[i] = elements1[i] / dvalue;
00325   return op3;
00326 }
00327 
00329 template <typename T> inline
00330 CoinDenseVector<T> operator+(T value, const CoinDenseVector<T>& op1){
00331   int size = op1.size();
00332   CoinDenseVector<T> op3(size);
00333   const T *elements1 = op1.getElements();
00334   T *elements3 = op3.getElements();
00335   double dvalue = value;
00336   for(int i=0; i<size; i++)
00337     elements3[i] = elements1[i] + dvalue;
00338   return op3;
00339 }
00340 
00342 template <typename T> inline
00343 CoinDenseVector<T> operator-(T value, const CoinDenseVector<T>& op1){
00344   int size = op1.size();
00345   CoinDenseVector<T> op3(size);
00346   const T *elements1 = op1.getElements();
00347   T *elements3 = op3.getElements();
00348   double dvalue = value;
00349   for(int i=0; i<size; i++)
00350     elements3[i] = dvalue - elements1[i];
00351   return op3;
00352 }
00353 
00355 template <typename T> inline
00356 CoinDenseVector<T> operator*(T value, const CoinDenseVector<T>& op1){
00357   int size = op1.size();
00358   CoinDenseVector<T> op3(size);
00359   const T *elements1 = op1.getElements();
00360   T *elements3 = op3.getElements();
00361   double dvalue = value;
00362   for(int i=0; i<size; i++)
00363     elements3[i] = elements1[i] * dvalue;
00364   return op3;
00365 }
00366 
00368 template <typename T> inline
00369 CoinDenseVector<T> operator/(T value, const CoinDenseVector<T>& op1){
00370   int size = op1.size();
00371   CoinDenseVector<T> op3(size);
00372   const T *elements1 = op1.getElements();
00373   T *elements3 = op3.getElements();
00374   double dvalue = value;
00375   for(int i=0; i<size; i++)
00376     elements3[i] = dvalue / elements1[i];
00377   return op3;
00378 }
00380 
00381 #endif

Generated on Fri Oct 15 2010 18:21:02 by  doxygen 1.7.1