Nektar++
Main Page
Related Pages
Namespaces
Classes
Files
File List
File Members
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Pages
library
LibUtilities
LinearAlgebra
NekVectorConstantSized.hpp
Go to the documentation of this file.
1
/////////////////////////////////////////////////////////////////////////////////
2
////
3
//// File: NekConstantSizedVector.hpp
4
////
5
//// For more information, please see: http://www.nektar.info
6
////
7
//// The MIT License
8
////
9
//// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10
//// Department of Aeronautics, Imperial College London (UK), and Scientific
11
//// Computing and Imaging Institute, University of Utah (USA).
12
////
13
//// License for the specific language governing rights and limitations under
14
//// Permission is hereby granted, free of charge, to any person obtaining a
15
//// copy of this software and associated documentation files (the "Software"),
16
//// to deal in the Software without restriction, including without limitation
17
//// the rights to use, copy, modify, merge, publish, distribute, sublicense,
18
//// and/or sell copies of the Software, and to permit persons to whom the
19
//// Software is furnished to do so, subject to the following conditions:
20
////
21
//// The above copyright notice and this permission notice shall be included
22
//// in all copies or substantial portions of the Software.
23
////
24
//// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25
//// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26
//// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27
//// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28
//// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29
//// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30
//// DEALINGS IN THE SOFTWARE.
31
////
32
//// Description: Generic N-Dimensional Vector.
33
////
34
/////////////////////////////////////////////////////////////////////////////////
35
//
36
//#ifndef NEKTAR_LIB_UTILITIES_LINEAR_ALGEBRA_NEK_CONSTANT_SIZED_VECTOR_HPP
37
//#define NEKTAR_LIB_UTILITIES_LINEAR_ALGEBRA_NEK_CONSTANT_SIZED_VECTOR_HPP
38
//
39
//#include <LibUtilities/LinearAlgebra/NekVectorFwd.hpp>
40
//#include <LibUtilities/LinearAlgebra/NekVectorTypeTraits.hpp>
41
//#include <LibUtilities/LinearAlgebra/NekVectorCommon.hpp>
42
//#include <LibUtilities/LinearAlgebra/PointerWrapper.h>
43
//
44
//#include <ExpressionTemplates/ExpressionTemplates.hpp>
45
//#include <LibUtilities/BasicUtils/ErrorUtil.hpp>
46
//
47
//
48
//#include <algorithm>
49
//#include <boost/static_assert.hpp>
50
//
51
//
52
//namespace Nektar
53
//{
54
//
55
//
56
// template<typename dataType, typename dim, typename space>
57
// class NekVector<dataType, dim, space>
58
// {
59
// public:
60
// typedef dataType DataType;
61
//
62
// NekVector() :
63
// m_impl()
64
// {
65
// std::fill_n(m_impl, dim::Value, DataType());
66
// }
67
//
68
// explicit NekVector(typename boost::call_traits<DataType>::const_reference a) :
69
// m_impl()
70
// {
71
// std::fill_n(m_impl, dim::Value, a);
72
// }
73
//
74
// /// \brief Constructs a vector with initial value a.
75
// ///
76
// /// \param size The size of the vector. Since the size of the vector is specified in the template, this parameter is ignored.
77
// /// \param a The value with which to initialize the vector.
78
// ///
79
// /// This constructor is provided for generic methods which don't know if the vector they
80
// /// are creating is constant sized or variable sized.
81
// NekVector(unsigned int size, typename boost::call_traits<DataType>::const_reference a) :
82
// m_impl()
83
// {
84
// ASSERTL1(size == dim::Value, std::string("Attempting to construct a constant sized vector of size ") +
85
// boost::lexical_cast<std::string>(dim::Value) +
86
// std::string(" with a size ") +
87
// boost::lexical_cast<std::string>(size));
88
// std::fill_n(m_impl, dim::Value, a);
89
// }
90
//
91
// explicit NekVector(const std::string& vectorValues) :
92
// m_impl()
93
// {
94
// std::vector<DataType> values = FromString<DataType>(vectorValues);
95
//
96
// ASSERTL0(values.size() == dim::Value, "Error converting string values to vector");
97
//
98
// std::copy(values.begin(), values.end(), &m_impl[0]);
99
// }
100
//
101
// NekVector(typename boost::call_traits<DataType>::const_reference x,
102
// typename boost::call_traits<DataType>::const_reference y,
103
// typename boost::call_traits<DataType>::const_reference z) :
104
// m_impl()
105
// {
106
// BOOST_STATIC_ASSERT(dim::Value == 3);
107
// m_impl[0] = x;
108
// m_impl[1] = y;
109
// m_impl[2] = z;
110
// }
111
//
112
// NekVector(typename boost::call_traits<DataType>::const_reference x,
113
// typename boost::call_traits<DataType>::const_reference y,
114
// typename boost::call_traits<DataType>::const_reference z,
115
// typename boost::call_traits<DataType>::const_reference w) :
116
// m_impl()
117
// {
118
// BOOST_STATIC_ASSERT(dim::Value == 4);
119
// m_impl[0] = x;
120
// m_impl[1] = y;
121
// m_impl[2] = z;
122
// m_impl[3] = w;
123
// }
124
//
125
// NekVector(const NekVector<DataType, dim, space>& rhs) :
126
// m_impl()
127
// {
128
// std::copy(rhs.m_impl, rhs.m_impl+dim::Value, m_impl);
129
// }
130
//
131
// explicit NekVector(const DataType* const ptr) :
132
// m_impl()
133
// {
134
// std::copy(ptr, ptr+dim::Value, &m_impl[0]);
135
// }
136
//
137
// ~NekVector()
138
// {
139
//#ifdef _DEBUG
140
// std::fill_n(m_impl, dim::Value, DataType());
141
//#endif //_DEBUG
142
// }
143
//
144
//#ifdef NEKTAR_USE_EXPRESSION_TEMPLATES
145
// template<typename L, typename Op, typename R>
146
// NekVector(const expt::Node<L, Op, R>& rhs) :
147
// m_impl()
148
// {
149
// #ifdef _DEBUG
150
// boost::tuple<unsigned int, unsigned int, unsigned int> sizes =
151
// MatrixSize<Node<L, Op, R>, typename Node<L, Op, R>::Indices, 0>::GetRequiredSize(rhs.GetData());
152
// ASSERTL0(sizes.get<0>() == dim::Value, "Data sizes are not equal.");
153
// #endif
154
//
155
// /// TODO Make sure this works correctly with eWrapper
156
// //BOOST_MPL_ASSERT(( boost::is_same<typename Expression<ExpressionPolicyType>::ResultType, NekVector<DataType, VariableSizedVector, space> > ));
157
// expt::ExpressionEvaluator::Evaluate(rhs, *this);
158
// }
159
//#endif
160
//
161
//#ifdef NEKTAR_USE_EXPRESSION_TEMPLATES
162
// template<typename L, typename Op, typename R>
163
// NekVector<DataType, dim, space>& operator=(const expt::Node<L, Op, R>& rhs)
164
// {
165
// rhs.Evaluate(*this);
166
// return *this;
167
// }
168
//#endif
169
//
170
// /// \brief Returns the number of dimensions for the point.
171
// unsigned int GetDimension() const
172
// {
173
// return dim::Value;
174
// }
175
//
176
// /// \brief Treating the vector as a column vector, how many rows it has.
177
// unsigned int GetRows() const
178
// {
179
// return dim::Value;
180
// }
181
//
182
// const DataType* GetRawPtr() const
183
// {
184
// return &m_impl[0];
185
// }
186
//
187
// typedef const DataType* const_iterator;
188
// const_iterator begin() const { return GetRawPtr(); }
189
// const_iterator end() const { return GetRawPtr() + GetDimension(); }
190
//
191
// typename boost::call_traits<DataType>::const_reference operator()(unsigned int i) const
192
// {
193
// ASSERTL1(( i >= 0) && (i < GetDimension()), "Invalid access to m_data via parenthesis operator");
194
// return m_impl[i];
195
// }
196
//
197
// typename boost::call_traits<DataType>::const_reference operator[](unsigned int i) const
198
// {
199
// return m_impl[i];
200
// }
201
//
202
// typename boost::call_traits<DataType>::const_reference x() const
203
// {
204
// BOOST_STATIC_ASSERT(dim::Value >= 1);
205
// return m_impl[0];
206
// }
207
//
208
// typename boost::call_traits<DataType>::const_reference y() const
209
// {
210
// BOOST_STATIC_ASSERT(dim::Value >= 2);
211
// return m_impl[1];
212
// }
213
//
214
// typename boost::call_traits<DataType>::const_reference z() const
215
// {
216
// BOOST_STATIC_ASSERT(dim::Value >= 3);
217
// return m_impl[2];
218
// }
219
//
220
// typename boost::call_traits<DataType>::const_reference w() const
221
// {
222
// BOOST_STATIC_ASSERT(dim::Value >= 4);
223
// return m_impl[3];
224
// }
225
//
226
//
227
//// typename boost::call_traits<DataType>::reference x()
228
//// {
229
//// BOOST_STATIC_ASSERT(dim::Value >= 1);
230
//// return m_impl[0];
231
//// }
232
////
233
//// typename boost::call_traits<DataType>::reference y()
234
//// {
235
//// BOOST_STATIC_ASSERT(dim::Value >= 2);
236
//// return m_impl[1];
237
//// }
238
////
239
//// typename boost::call_traits<DataType>::reference z()
240
//// {
241
//// BOOST_STATIC_ASSERT(dim::Value >= 3);
242
//// return m_impl[2];
243
//// }
244
////
245
////
246
//// typename boost::call_traits<DataType>::reference w()
247
//// {
248
//// BOOST_STATIC_ASSERT(dim::Value >= 4);
249
//// return m_impl[3];
250
//// }
251
//
252
// // Unitary operators
253
// NekVector<DataType, dim, space> operator-() const { return Negate(*this); }
254
//
255
// DataType Magnitude() const { return Nektar::Magnitude(*this); }
256
//
257
// DataType Dot(const NekVector<DataType, dim, space>& rhs) const { return Nektar::Dot(*this, rhs); }
258
//
259
// NekVector<DataType, dim, space> Cross(const NekVector<DataType, dim, space>& rhs) const
260
// {
261
// return Nektar::Cross(*this, rhs);
262
// }
263
//
264
// std::string AsString() const { return Nektar::AsString(*this); }
265
//
266
// // Norms
267
// DataType L1Norm() const { return Nektar::L1Norm(*this); }
268
// DataType L2Norm() const { return Nektar::L2Norm(*this); }
269
// DataType InfinityNorm() const { return Nektar::InfinityNorm(*this); }
270
//
271
// PointerWrapper GetWrapperType() const { return eCopy; }
272
//
273
// protected:
274
// DataType* GetImpl() { return &m_impl[0]; }
275
//
276
// NekVector<DataType, dim, space>& operator=(const NekVector<DataType, dim, space>& rhs)
277
// {
278
// std::copy(rhs.m_impl, rhs.m_impl+dim::Value, m_impl);
279
// return *this;
280
// }
281
//
282
// NekVector<DataType, dim, space>& operator=(const NekVector<DataType, VariableSizedVector, space>& rhs)
283
// {
284
// ASSERTL0(GetDimension() == rhs.GetDimension(), "Assignment to a constant sized vector must have the same number of elements.");
285
// std::copy(rhs.GetRawPtr(), rhs.GetRawPtr()+dim::Value, m_impl);
286
// return *this;
287
// }
288
//
289
// private:
290
// DataType m_impl[dim::Value];
291
//
292
// };
293
//
294
// // \param DataType The type of data held by each element of the vector.
295
// // \param dim The number of elements in the vector. If set to 0, the vector
296
// // will have a variable number of elements.
297
// // \param space The space of the vector.
298
// template<typename DataType, typename dim, typename space>
299
// class NekVector : public NekVector<DataType, dim, space>
300
// {
301
// public:
302
// typedef NekVector<DataType, dim, space> BaseType;
303
//
304
// /// \brief Creates a constant sized vector with each element initialized to
305
// /// the default value for DataType.
306
// NekVector() : BaseType() {}
307
//
308
// /// \brief Creates a constant sized vector with each element set to a.
309
// /// \param a The value to assign to each element of the vector.
310
// explicit NekVector(typename boost::call_traits<DataType>::const_reference a) :
311
// BaseType(a) {}
312
//
313
// NekVector(unsigned int size, typename boost::call_traits<DataType>::const_reference a) :
314
// BaseType(size, a) {}
315
//
316
// /// \brief Creates a vector from the elements in a delimited string.
317
// /// \param vectorValues A string the the vector values.
318
// ///
319
// ///
320
// explicit NekVector(const std::string& vectorValues) : BaseType(vectorValues) {}
321
//
322
// NekVector(typename boost::call_traits<DataType>::const_reference x,
323
// typename boost::call_traits<DataType>::const_reference y,
324
// typename boost::call_traits<DataType>::const_reference z) :
325
// BaseType(x, y, z) {}
326
//
327
// NekVector(typename boost::call_traits<DataType>::const_reference x,
328
// typename boost::call_traits<DataType>::const_reference y,
329
// typename boost::call_traits<DataType>::const_reference z,
330
// typename boost::call_traits<DataType>::const_reference w) :
331
// BaseType(x,y,z,w) {}
332
//
333
// NekVector(const NekVector<DataType, dim, space>& rhs) :
334
// BaseType(rhs) {}
335
//
336
// explicit NekVector(const DataType* const ptr) :
337
// BaseType(ptr) {}
338
//
339
//
340
//#ifdef NEKTAR_USE_EXPRESSION_TEMPLATES
341
// template<typename L, typename Op, typename R>
342
// NekVector(const expt::Node<L, Op, R>& rhs) :
343
// BaseType()
344
// {
345
// #ifdef _DEBUG
346
// boost::tuple<unsigned int, unsigned int, unsigned int> sizes =
347
// MatrixSize<expt::Node<L, Op, R>, typename expt::Node<L, Op, R>::Indices, 0>::GetRequiredSize(rhs.GetData());
348
// ASSERTL0(sizes.get<0>() == dim::Value, "Data sizes are not equal.");
349
// #endif
350
//
351
// /// TODO Make sure this works correctly with eWrapper
352
// //BOOST_MPL_ASSERT(( boost::is_same<typename Expression<ExpressionPolicyType>::ResultType, NekVector<DataType, VariableSizedVector, space> > ));
353
// expt::ExpressionEvaluator::Evaluate(rhs, *this);
354
// }
355
//#endif
356
//
357
//#ifdef NEKTAR_USE_EXPRESSION_TEMPLATES
358
// template<typename L, typename Op, typename R>
359
// NekVector<DataType, dim, space>& operator=(const expt::Node<L, Op, R>& rhs)
360
// {
361
// rhs.Evaluate(*this);
362
// return *this;
363
// }
364
//#endif
365
//
366
//
367
//
368
// NekVector<DataType, dim, space>& operator=(const NekVector<DataType, dim, space>& rhs)
369
// {
370
// BaseType::operator=(rhs);
371
// return *this;
372
// }
373
//
374
// NekVector<DataType, dim, space>& operator=(const NekVector<DataType, VariableSizedVector, space>& rhs)
375
// {
376
// BaseType::operator=(rhs);
377
// return *this;
378
// }
379
//
380
// using BaseType::GetRawPtr;
381
// DataType* GetRawPtr()
382
// {
383
// return this->GetImpl();
384
// }
385
//
386
//
387
// typedef DataType* iterator;
388
//
389
//
390
// iterator begin() { return GetRawPtr(); }
391
// iterator end() { return GetRawPtr() + this->GetDimension(); }
392
//
393
//
394
// /// \brief Returns i^{th} element.
395
// /// \param i The element to return.
396
// /// \pre i < dim
397
// /// \return A reference to the i^{th} element.
398
// ///
399
// /// Retrieves the i^{th} element. Since it returns a reference you may
400
// /// assign a new value (i.e., p(2) = 3.2;)
401
// ///
402
// /// This operator performs range checking.
403
// typename boost::call_traits<DataType>::reference operator()(unsigned int i)
404
// {
405
// ASSERTL1((i >= 0) && (i < this->GetDimension()), "Invalid access to m_data via parenthesis operator");
406
// return this->GetImpl()[i];
407
// }
408
//
409
// typename boost::call_traits<DataType>::reference operator[](unsigned int i)
410
// {
411
// return this->GetImpl()[i];
412
// }
413
//
414
// using BaseType::operator();
415
// using BaseType::operator[];
416
//
417
// using BaseType::x;
418
// typename boost::call_traits<DataType>::reference x()
419
// {
420
// BOOST_STATIC_ASSERT(dim::Value >= 1);
421
// return this->GetImpl()[0];
422
// }
423
//
424
// using BaseType::y;
425
// typename boost::call_traits<DataType>::reference y()
426
// {
427
// BOOST_STATIC_ASSERT(dim::Value >= 2);
428
// return this->GetImpl()[1];
429
// }
430
//
431
// using BaseType::z;
432
// typename boost::call_traits<DataType>::reference z()
433
// {
434
// BOOST_STATIC_ASSERT(dim::Value >= 3);
435
// return this->GetImpl()[2];
436
// }
437
//
438
// using BaseType::w;
439
// typename boost::call_traits<DataType>::reference w()
440
// {
441
// BOOST_STATIC_ASSERT(dim::Value >= 4);
442
// return this->GetImpl()[3];
443
// }
444
//
445
// void SetX(typename boost::call_traits<DataType>::const_reference val)
446
// {
447
// BOOST_STATIC_ASSERT(dim::Value >= 1);
448
// this->GetImpl()[0] = val;
449
// }
450
//
451
// void SetY(typename boost::call_traits<DataType>::const_reference val)
452
// {
453
// BOOST_STATIC_ASSERT(dim::Value >= 2);
454
// this->GetImpl()[1] = val;
455
// }
456
//
457
// void SetZ(typename boost::call_traits<DataType>::const_reference val)
458
// {
459
// BOOST_STATIC_ASSERT(dim::Value >= 3);
460
// this->GetImpl()[2] = val;
461
// }
462
//
463
// void SetW(typename boost::call_traits<DataType>::const_reference val)
464
// {
465
// BOOST_STATIC_ASSERT(dim::Value >= 4);
466
// this->GetImpl()[3] = val;
467
// }
468
//
469
// /// Arithmetic Routines
470
//
471
// NekVector<DataType, dim, space>& operator+=(const NekVector<DataType, dim, space>& rhs)
472
// {
473
// AddEqual(*this, rhs);
474
// return *this;
475
// }
476
//
477
// NekVector<DataType, dim, space>& operator-=(const NekVector<DataType, dim, space>& rhs)
478
// {
479
// SubtractEqual(*this, rhs);
480
// return *this;
481
// }
482
//
483
// NekVector<DataType, dim, space>& operator*=(typename boost::call_traits<DataType>::const_reference rhs)
484
// {
485
// MultiplyEqual(*this, rhs);
486
// return *this;
487
// }
488
//
489
// NekVector<DataType, dim, space>& operator/=(typename boost::call_traits<DataType>::const_reference rhs)
490
// {
491
// DivideEqual(*this, rhs);
492
// return *this;
493
// }
494
//
495
//
496
//
497
// void Normalize() { return Nektar::Normalize(*this); }
498
//
499
//
500
//
501
// };
502
//
503
//
504
//
505
//}
506
//
507
//#endif // NEKTAR_LIB_UTILITIES_LINEAR_ALGEBRA_NEK_CONSTANT_SIZED_VECTOR_HPP
Generated on Wed May 4 2016 17:54:15 for Nektar++ by
1.8.8