CoinUtils 2.11.4
Loading...
Searching...
No Matches
CoinDenseVector.hpp
Go to the documentation of this file.
1/* $Id$ */
2// Copyright (C) 2003, International Business Machines
3// Corporation and others. All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef CoinDenseVector_H
7#define CoinDenseVector_H
8
9#if defined(_MSC_VER)
10// Turn off compiler warning about long names
11#pragma warning(disable : 4786)
12#endif
13
14#include <cassert>
15#include <cstdlib>
16#include <cmath>
18
19//#############################################################################
25template < typename T >
27
28//#############################################################################
67template < typename T >
69private:
77
78public:
82 inline int getNumElements() const { return nElements_; }
83 inline int size() const { return nElements_; }
85 inline const T *getElements() const { return elements_; }
87 inline T *getElements() { return elements_; }
89
90 //-------------------------------------------------------------------
91 // Set indices and elements
92 //-------------------------------------------------------------------
95
96 void clear();
100 T &operator[](int index) const;
101
106 void setVector(int size, const T *elems);
107
109 void setConstant(int size, T elems);
110
114 void setElement(int index, T element);
118 void resize(int newSize, T fill = T());
119
121 void append(const CoinDenseVector &);
123
127 inline T oneNorm() const
128 {
129 T norm = 0;
130 for (int i = 0; i < nElements_; i++)
131 norm += CoinAbs(elements_[i]);
132 return norm;
133 }
135 inline double twoNorm() const
136 {
137 double norm = 0.;
138 for (int i = 0; i < nElements_; i++)
139 norm += elements_[i] * elements_[i];
140 // std namespace removed because it was causing a compile
141 // problem with Microsoft Visual C++
142 return /*std::*/ sqrt(norm);
143 }
145 inline T infNorm() const
146 {
147 T norm = 0;
148 for (int i = 0; i < nElements_; i++)
149 norm = CoinMax(norm, CoinAbs(elements_[i]));
150 return norm;
151 }
153 inline T sum() const
154 {
155 T sume = 0;
156 for (int i = 0; i < nElements_; i++)
157 sume += elements_[i];
158 return sume;
159 }
161 inline void scale(T factor)
162 {
163 for (int i = 0; i < nElements_; i++)
164 elements_[i] *= factor;
165 return;
166 }
168
172 void operator+=(T value);
174 void operator-=(T value);
176 void operator*=(T value);
178 void operator/=(T value);
180
186 CoinDenseVector(int size, const T *elems);
188 CoinDenseVector(int size, T element = T());
191
195
196private:
200 void gutsOfSetVector(int size, const T *elems);
202 void gutsOfSetConstant(int size, T value);
204};
205
206//#############################################################################
207
216template < typename T >
218 const CoinDenseVector< T > &op2)
219{
220 assert(op1.size() == op2.size());
221 int size = op1.size();
222 CoinDenseVector< T > op3(size);
223 const T *elements1 = op1.getElements();
224 const T *elements2 = op2.getElements();
225 T *elements3 = op3.getElements();
226 for (int i = 0; i < size; i++)
227 elements3[i] = elements1[i] + elements2[i];
228 return op3;
229}
230
232template < typename T >
234 const CoinDenseVector< T > &op2)
235{
236 assert(op1.size() == op2.size());
237 int size = op1.size();
238 CoinDenseVector< T > op3(size);
239 const T *elements1 = op1.getElements();
240 const T *elements2 = op2.getElements();
241 T *elements3 = op3.getElements();
242 for (int i = 0; i < size; i++)
243 elements3[i] = elements1[i] - elements2[i];
244 return op3;
245}
246
248template < typename T >
250 const CoinDenseVector< T > &op2)
251{
252 assert(op1.size() == op2.size());
253 int size = op1.size();
254 CoinDenseVector< T > op3(size);
255 const T *elements1 = op1.getElements();
256 const T *elements2 = op2.getElements();
257 T *elements3 = op3.getElements();
258 for (int i = 0; i < size; i++)
259 elements3[i] = elements1[i] * elements2[i];
260 return op3;
261}
262
264template < typename T >
266 const CoinDenseVector< T > &op2)
267{
268 assert(op1.size() == op2.size());
269 int size = op1.size();
270 CoinDenseVector< T > op3(size);
271 const T *elements1 = op1.getElements();
272 const T *elements2 = op2.getElements();
273 T *elements3 = op3.getElements();
274 for (int i = 0; i < size; i++)
275 elements3[i] = elements1[i] / elements2[i];
276 return op3;
277}
279
286template < typename T >
288{
289 int size = op1.size();
290 CoinDenseVector< T > op3(size);
291 const T *elements1 = op1.getElements();
292 T *elements3 = op3.getElements();
293 double dvalue = value;
294 for (int i = 0; i < size; i++)
295 elements3[i] = elements1[i] + dvalue;
296 return op3;
297}
298
300template < typename T >
302{
303 int size = op1.size();
304 CoinDenseVector< T > op3(size);
305 const T *elements1 = op1.getElements();
306 T *elements3 = op3.getElements();
307 double dvalue = value;
308 for (int i = 0; i < size; i++)
309 elements3[i] = elements1[i] - dvalue;
310 return op3;
311}
312
314template < typename T >
316{
317 int size = op1.size();
318 CoinDenseVector< T > op3(size);
319 const T *elements1 = op1.getElements();
320 T *elements3 = op3.getElements();
321 double dvalue = value;
322 for (int i = 0; i < size; i++)
323 elements3[i] = elements1[i] * dvalue;
324 return op3;
325}
326
328template < typename T >
330{
331 int size = op1.size();
332 CoinDenseVector< T > op3(size);
333 const T *elements1 = op1.getElements();
334 T *elements3 = op3.getElements();
335 double dvalue = value;
336 for (int i = 0; i < size; i++)
337 elements3[i] = elements1[i] / dvalue;
338 return op3;
339}
340
342template < typename T >
344{
345 int size = op1.size();
346 CoinDenseVector< T > op3(size);
347 const T *elements1 = op1.getElements();
348 T *elements3 = op3.getElements();
349 double dvalue = value;
350 for (int i = 0; i < size; i++)
351 elements3[i] = elements1[i] + dvalue;
352 return op3;
353}
354
356template < typename T >
358{
359 int size = op1.size();
360 CoinDenseVector< T > op3(size);
361 const T *elements1 = op1.getElements();
362 T *elements3 = op3.getElements();
363 double dvalue = value;
364 for (int i = 0; i < size; i++)
365 elements3[i] = dvalue - elements1[i];
366 return op3;
367}
368
370template < typename T >
372{
373 int size = op1.size();
374 CoinDenseVector< T > op3(size);
375 const T *elements1 = op1.getElements();
376 T *elements3 = op3.getElements();
377 double dvalue = value;
378 for (int i = 0; i < size; i++)
379 elements3[i] = elements1[i] * dvalue;
380 return op3;
381}
382
384template < typename T >
386{
387 int size = op1.size();
388 CoinDenseVector< T > op3(size);
389 const T *elements1 = op1.getElements();
390 T *elements3 = op3.getElements();
391 double dvalue = value;
392 for (int i = 0; i < size; i++)
393 elements3[i] = dvalue / elements1[i];
394 return op3;
395}
397
398#endif
399
400/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
401*/
void CoinDenseVectorUnitTest(T dummy)
A function that tests the methods in the CoinDenseVector class.
CoinDenseVector< T > operator+(const CoinDenseVector< T > &op1, const CoinDenseVector< T > &op2)
Return the sum of two dense vectors.
CoinDenseVector< T > operator/(const CoinDenseVector< T > &op1, const CoinDenseVector< T > &op2)
Return the element-wise ratio of two dense vectors.
CoinDenseVector< T > operator-(const CoinDenseVector< T > &op1, const CoinDenseVector< T > &op2)
Return the difference of two dense vectors.
CoinDenseVector< T > operator*(const CoinDenseVector< T > &op1, const CoinDenseVector< T > &op2)
Return the element-wise product of two dense vectors.
T CoinMax(const T x1, const T x2)
Return the larger (according to operator<() of the arguments.
T CoinAbs(const T value)
Return the absolute value of the argument.
Dense Vector.
CoinDenseVector(const CoinDenseVector &)
Copy constructors.
void gutsOfSetConstant(int size, T value)
Set all elements to a given value.
void operator/=(T value)
divide every entry by value
T * getElements()
Get element values.
void operator-=(T value)
subtract value from every entry
int getNumElements() const
Get the size.
void operator*=(T value)
multiply every entry by value
T infNorm() const
infinity-norm of vector
void operator+=(T value)
add value to every entry
CoinDenseVector(int size, T element=T())
Alternate Constructors - set elements to same scalar value.
CoinDenseVector()
Default constructor.
void resize(int newSize, T fill=T())
Resize the dense vector to be the first newSize elements.
T oneNorm() const
1-norm of vector
T * elements_
Vector elements.
int nElements_
Size of element vector.
void append(const CoinDenseVector &)
Append a dense vector to this dense vector.
const T * getElements() const
Get element values.
void setElement(int index, T element)
Set an existing element in the dense vector The first argument is the "index" into the elements() arr...
T sum() const
sum of vector elements
CoinDenseVector(int size, const T *elems)
Alternate Constructors - set elements to vector of Ts.
void clear()
Reset the vector (i.e. set all elemenets to zero)
CoinDenseVector & operator=(const CoinDenseVector &)
Assignment operator.
~CoinDenseVector()
Destructor.
void setConstant(int size, T elems)
Elements set to have the same scalar value.
void gutsOfSetVector(int size, const T *elems)
Copy internal data.
double twoNorm() const
2-norm of vector
void setVector(int size, const T *elems)
Set vector size, and elements.
T & operator[](int index) const
Member of array operator.
void scale(T factor)
scale vector elements