00001
00002
00003 #ifndef CoinDenseVector_H
00004 #define CoinDenseVector_H
00005
00006 #if defined(_MSC_VER)
00007
00008 # pragma warning(disable:4786)
00009 #endif
00010
00011 #include <cassert>
00012 #include <cmath>
00013 #include "CoinHelperFunctions.hpp"
00014
00015
00021 template <typename T> void
00022 CoinDenseVectorUnitTest(T dummy);
00023
00024
00063 template <typename T> class CoinDenseVector {
00064 private:
00067
00068 int nElements_;
00070 T * elements_;
00072
00073 public:
00076
00077 inline int getNumElements() const { return nElements_; }
00078 inline int size() const { return nElements_; }
00080 inline const T * getElements() const { return elements_; }
00082 inline T * getElements() { return elements_; }
00084
00085
00086
00087
00090
00091 void clear();
00093 CoinDenseVector & operator=(const CoinDenseVector &);
00095 T & operator[](int index) const;
00096
00101 void setVector(int size, const T * elems);
00102
00103
00105 void setConstant(int size, T elems);
00106
00107
00111 void setElement(int index, T element);
00115 void resize(int newSize, T fill=T());
00116
00118 void append(const CoinDenseVector &);
00120
00123
00124 inline T oneNorm() const {
00125 T norm = 0;
00126 for (int i=0; i<nElements_; i++)
00127 norm += CoinAbs(elements_[i]);
00128 return norm;
00129 }
00131 inline double twoNorm() const {
00132 double norm = 0.;
00133 for (int i=0; i<nElements_; i++)
00134 norm += elements_[i] * elements_[i];
00135 return sqrt(norm);
00136 }
00138 inline T infNorm() const {
00139 T norm = 0;
00140 for (int i=0; i<nElements_; i++)
00141 norm = CoinMax(norm, CoinAbs(elements_[i]));
00142 return norm;
00143 }
00145 inline T sum() const {
00146 T sume = 0;
00147 for (int i=0; i<nElements_; i++)
00148 sume += elements_[i];
00149 return sume;
00150 }
00152 inline void scale(T factor) {
00153 for (int i=0; i<nElements_; i++)
00154 elements_[i] *= factor;
00155 return;
00156 }
00158
00161
00162 void operator+=(T value);
00164 void operator-=(T value);
00166 void operator*=(T value);
00168 void operator/=(T value);
00170
00174 CoinDenseVector();
00176 CoinDenseVector(int size, const T * elems);
00178 CoinDenseVector(int size, T element=T());
00180 CoinDenseVector(const CoinDenseVector &);
00181
00183 ~CoinDenseVector ();
00185
00186 private:
00189
00190 void gutsOfSetVector(int size, const T * elems);
00192 void gutsOfSetConstant(int size, T value);
00194 };
00195
00196
00197
00205
00206 template <typename T> inline
00207 CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1,
00208 const CoinDenseVector<T>& op2){
00209 assert(op1.size() == op2.size());
00210 int size = op1.size();
00211 CoinDenseVector<T> op3(size);
00212 const T *elements1 = op1.getElements();
00213 const T *elements2 = op2.getElements();
00214 T *elements3 = op3.getElements();
00215 for(int i=0; i<size; i++)
00216 elements3[i] = elements1[i] + elements2[i];
00217 return op3;
00218 }
00219
00221 template <typename T> inline
00222 CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1,
00223 const CoinDenseVector<T>& op2){
00224 assert(op1.size() == op2.size());
00225 int size = op1.size();
00226 CoinDenseVector<T> op3(size);
00227 const T *elements1 = op1.getElements();
00228 const T *elements2 = op2.getElements();
00229 T *elements3 = op3.getElements();
00230 for(int i=0; i<size; i++)
00231 elements3[i] = elements1[i] - elements2[i];
00232 return op3;
00233 }
00234
00235
00237 template <typename T> inline
00238 CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1,
00239 const CoinDenseVector<T>& op2){
00240 assert(op1.size() == op2.size());
00241 int size = op1.size();
00242 CoinDenseVector<T> op3(size);
00243 const T *elements1 = op1.getElements();
00244 const T *elements2 = op2.getElements();
00245 T *elements3 = op3.getElements();
00246 for(int i=0; i<size; i++)
00247 elements3[i] = elements1[i] * elements2[i];
00248 return op3;
00249 }
00250
00252 template <typename T> inline
00253 CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1,
00254 const CoinDenseVector<T>& op2){
00255 assert(op1.size() == op2.size());
00256 int size = op1.size();
00257 CoinDenseVector<T> op3(size);
00258 const T *elements1 = op1.getElements();
00259 const T *elements2 = op2.getElements();
00260 T *elements3 = op3.getElements();
00261 for(int i=0; i<size; i++)
00262 elements3[i] = elements1[i] / elements2[i];
00263 return op3;
00264 }
00266
00272
00273 template <typename T> inline
00274 CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1, T value){
00275 int size = op1.size();
00276 CoinDenseVector<T> op3(size);
00277 const T *elements1 = op1.getElements();
00278 T *elements3 = op3.getElements();
00279 double dvalue = value;
00280 for(int i=0; i<size; i++)
00281 elements3[i] = elements1[i] + dvalue;
00282 return op3;
00283 }
00284
00286 template <typename T> inline
00287 CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1, T value){
00288 int size = op1.size();
00289 CoinDenseVector<T> op3(size);
00290 const T *elements1 = op1.getElements();
00291 T *elements3 = op3.getElements();
00292 double dvalue = value;
00293 for(int i=0; i<size; i++)
00294 elements3[i] = elements1[i] - dvalue;
00295 return op3;
00296 }
00297
00299 template <typename T> inline
00300 CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1, T value){
00301 int size = op1.size();
00302 CoinDenseVector<T> op3(size);
00303 const T *elements1 = op1.getElements();
00304 T *elements3 = op3.getElements();
00305 double dvalue = value;
00306 for(int i=0; i<size; i++)
00307 elements3[i] = elements1[i] * dvalue;
00308 return op3;
00309 }
00310
00312 template <typename T> inline
00313 CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1, T value){
00314 int size = op1.size();
00315 CoinDenseVector<T> op3(size);
00316 const T *elements1 = op1.getElements();
00317 T *elements3 = op3.getElements();
00318 double dvalue = value;
00319 for(int i=0; i<size; i++)
00320 elements3[i] = elements1[i] / dvalue;
00321 return op3;
00322 }
00323
00325 template <typename T> inline
00326 CoinDenseVector<T> operator+(T value, const CoinDenseVector<T>& op1){
00327 int size = op1.size();
00328 CoinDenseVector<T> op3(size);
00329 const T *elements1 = op1.getElements();
00330 T *elements3 = op3.getElements();
00331 double dvalue = value;
00332 for(int i=0; i<size; i++)
00333 elements3[i] = elements1[i] + dvalue;
00334 return op3;
00335 }
00336
00338 template <typename T> inline
00339 CoinDenseVector<T> operator-(T value, const CoinDenseVector<T>& op1){
00340 int size = op1.size();
00341 CoinDenseVector<T> op3(size);
00342 const T *elements1 = op1.getElements();
00343 T *elements3 = op3.getElements();
00344 double dvalue = value;
00345 for(int i=0; i<size; i++)
00346 elements3[i] = dvalue - elements1[i];
00347 return op3;
00348 }
00349
00351 template <typename T> inline
00352 CoinDenseVector<T> operator*(T value, const CoinDenseVector<T>& op1){
00353 int size = op1.size();
00354 CoinDenseVector<T> op3(size);
00355 const T *elements1 = op1.getElements();
00356 T *elements3 = op3.getElements();
00357 double dvalue = value;
00358 for(int i=0; i<size; i++)
00359 elements3[i] = elements1[i] * dvalue;
00360 return op3;
00361 }
00362
00364 template <typename T> inline
00365 CoinDenseVector<T> operator/(T value, const CoinDenseVector<T>& op1){
00366 int size = op1.size();
00367 CoinDenseVector<T> op3(size);
00368 const T *elements1 = op1.getElements();
00369 T *elements3 = op3.getElements();
00370 double dvalue = value;
00371 for(int i=0; i<size; i++)
00372 elements3[i] = dvalue / elements1[i];
00373 return op3;
00374 }
00376
00377 #endif