Nektar++
NekVector.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: NekVector.cpp
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// Permission is hereby granted, free of charge, to any person obtaining a
14// copy of this software and associated documentation files (the "Software"),
15// to deal in the Software without restriction, including without limitation
16// the rights to use, copy, modify, merge, publish, distribute, sublicense,
17// and/or sell copies of the Software, and to permit persons to whom the
18// Software is furnished to do so, subject to the following conditions:
19//
20// The above copyright notice and this permission notice shall be included
21// in all copies or substantial portions of the Software.
22//
23// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29// DEALINGS IN THE SOFTWARE.
30//
31// Description:
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#include <LibUtilities/LinearAlgebra/NekVector.hpp>
36
37namespace Nektar
38{
39
40template <typename DataType>
41NekVector<DataType>::NekVector() : m_size(0), m_data(), m_wrapperType(eCopy)
42{
43}
44
45template <typename DataType>
46NekVector<DataType>::NekVector(unsigned int size)
47 : m_size(size), m_data(size), m_wrapperType(eCopy)
48{
49}
50
51template <typename DataType>
52NekVector<DataType>::NekVector(
53 unsigned int size, typename boost::call_traits<DataType>::const_reference a)
54 : m_size(size), m_data(size), m_wrapperType(eCopy)
55{
56 std::fill_n(m_data.get(), m_size, a);
57}
58
59template <typename DataType>
60NekVector<DataType>::NekVector(const std::string &vectorValues)
61 : m_size(0), m_data(), m_wrapperType(eCopy)
62{
63 try
64 {
65 std::vector<DataType> values = FromString<DataType>(vectorValues);
66 m_size = values.size();
67 m_data = Array<OneD, DataType>(m_size);
68 std::copy(values.begin(), values.end(), m_data.begin());
69
70 ASSERTL0(m_size > 0, "Error converting string values to vector");
71 }
72 catch (std::runtime_error &e)
73 {
74 NEKERROR(ErrorUtil::efatal, e.what());
75 }
76}
77
78template <typename DataType>
79NekVector<DataType>::NekVector(
80 typename boost::call_traits<DataType>::const_reference x,
81 typename boost::call_traits<DataType>::const_reference y,
82 typename boost::call_traits<DataType>::const_reference z)
83 : m_size(3), m_data(m_size), m_wrapperType(eCopy)
84{
85 m_data[0] = x;
86 m_data[1] = y;
87 m_data[2] = z;
88}
89
90template <typename DataType>
91NekVector<DataType>::NekVector(const NekVector<DataType> &rhs)
92 : m_size(rhs.GetDimension()), m_data(rhs.m_data),
93 m_wrapperType(rhs.m_wrapperType)
94{
95 if (m_wrapperType == eCopy)
96 {
97 m_data = Array<OneD, DataType>(m_size);
98 std::copy(rhs.begin(), rhs.end(), m_data.get());
99 }
100}
101
102template <typename DataType>
103NekVector<DataType>::NekVector(unsigned int size, const DataType *const ptr)
104 : m_size(size), m_data(size, ptr), m_wrapperType(eCopy)
105{
106}
107
108template <typename DataType>
109NekVector<DataType>::NekVector(const Array<OneD, DataType> &ptr,
110 PointerWrapper h)
111 : m_size(ptr.size()), m_data(ptr), m_wrapperType(h)
112{
113 if (h == eCopy)
114 {
115 m_data = Array<OneD, DataType>(m_size);
116 CopyArray(ptr, m_data);
117 }
118}
119
120template <typename DataType>
121NekVector<DataType>::NekVector(unsigned int size, Array<OneD, DataType> &ptr,
122 PointerWrapper h)
123 : m_size(size), m_data(ptr), m_wrapperType(h)
124{
125 if (h == eCopy)
126 {
127 ASSERTL0(size <= ptr.size(),
128 "Attempting to populate a vector of size " +
129 std::to_string(size) +
130 " but the incoming array only has " +
131 std::to_string(ptr.size()) + " elements.");
132
133 m_data = Array<OneD, DataType>(size);
134 std::copy(ptr.begin(), ptr.begin() + size, m_data.begin());
135 }
136}
137
138template <typename DataType>
139NekVector<DataType>::NekVector(const Array<OneD, const DataType> &ptr,
140 PointerWrapper h)
141 : m_size(ptr.size()), m_data(ptr, eVECTOR_WRAPPER), m_wrapperType(h)
142{
143 if (h == eCopy)
144 {
145 m_data = Array<OneD, DataType>(m_size);
146 CopyArray(ptr, m_data);
147 }
148}
149
150template <typename DataType>
151NekVector<DataType>::NekVector(unsigned int size,
152 const Array<OneD, const DataType> &ptr,
153 PointerWrapper h)
154 : m_size(size), m_data(ptr, eVECTOR_WRAPPER), m_wrapperType(h)
155{
156 if (h == eCopy)
157 {
158 ASSERTL0(size <= ptr.size(),
159 "Attempting to populate a vector of size " +
160 std::to_string(size) +
161 " but the incoming array only has " +
162 std::to_string(ptr.size()) + " elements.");
163
164 m_data = Array<OneD, DataType>(size);
165 std::copy(ptr.begin(), ptr.begin() + size, m_data.begin());
166 }
167}
168
169template <typename DataType> NekVector<DataType>::~NekVector()
170{
171}
172
173template <typename DataType>
174NekVector<DataType> &NekVector<DataType>::operator=(
175 const NekVector<DataType> &rhs)
176{
177 if (m_wrapperType == eCopy)
178 {
179 // If the current vector is a copy, then regardless of the rhs type
180 // we just copy over the values, resizing if needed.
181 if (GetDimension() != rhs.GetDimension())
182 {
183 m_size = rhs.GetDimension();
184 m_data = Array<OneD, DataType>(m_size);
185 }
186 }
187 else if (m_wrapperType == eWrapper)
188 {
189 // If the current vector is wrapped, then just copy over the top,
190 // but the sizes of the two vectors must be the same.
191 ASSERTL0(
192 GetDimension() == rhs.GetDimension(),
193 "Wrapped NekVectors must have the same dimension in operator=");
194 }
195
196 std::copy(rhs.begin(), rhs.end(), m_data.get());
197 return *this;
198}
199
200template <typename DataType>
201unsigned int NekVector<DataType>::GetDimension() const
202{
203 return m_size;
204}
205
206template <typename DataType> unsigned int NekVector<DataType>::GetRows() const
207{
208 return m_size;
209}
210
211template <typename DataType> DataType *NekVector<DataType>::GetRawPtr()
212{
213 return this->GetData().get();
214}
215
216template <typename DataType>
217Array<OneD, DataType> &NekVector<DataType>::GetPtr()
218{
219 return this->GetData();
220}
221
222template <typename DataType>
223const DataType *NekVector<DataType>::GetRawPtr() const
224{
225 return m_data.get();
226}
227
228template <typename DataType>
229const Array<OneD, const DataType> &NekVector<DataType>::GetPtr() const
230{
231 return m_data;
232}
233
234template <typename DataType>
235typename NekVector<DataType>::iterator NekVector<DataType>::begin()
236{
237 return GetRawPtr();
238}
239
240template <typename DataType>
241typename NekVector<DataType>::iterator NekVector<DataType>::end()
242{
243 return GetRawPtr() + this->GetDimension();
244}
245
246template <typename DataType>
247typename NekVector<DataType>::const_iterator NekVector<DataType>::begin() const
248{
249 return GetRawPtr();
250}
251
252template <typename DataType>
253typename NekVector<DataType>::const_iterator NekVector<DataType>::end() const
254{
255 return GetRawPtr() + GetDimension();
256}
257
258template <typename DataType>
259typename boost::call_traits<DataType>::reference NekVector<
260 DataType>::operator()(unsigned int i)
261{
262 ASSERTL1(i < this->GetDimension(),
263 "Invalid access to m_data via parenthesis operator");
264 return this->GetData()[i];
265}
266
267template <typename DataType>
268typename boost::call_traits<DataType>::reference NekVector<
269 DataType>::operator[](unsigned int i)
270{
271 return this->GetData()[i];
272}
273
274template <typename DataType>
275typename boost::call_traits<DataType>::reference NekVector<DataType>::x()
276{
277 ASSERTL1(this->GetDimension() >= 1, "Invalid use of NekVector::x");
278 return (*this)(0);
279}
280
281template <typename DataType>
282typename boost::call_traits<DataType>::reference NekVector<DataType>::y()
283{
284 ASSERTL1(this->GetDimension() >= 2, "Invalid use of NekVector::y");
285 return (*this)(1);
286}
287
288template <typename DataType>
289typename boost::call_traits<DataType>::reference NekVector<DataType>::z()
290{
291 ASSERTL1(this->GetDimension() >= 3, "Invalid use of NekVector::z");
292 return (*this)(2);
293}
294
295template <typename DataType>
296void NekVector<DataType>::SetX(
297 typename boost::call_traits<DataType>::const_reference val)
298{
299 ASSERTL1(this->GetDimension() >= 1, "Invalid use of NekVector::SetX");
300 this->GetData()[0] = val;
301}
302
303template <typename DataType>
304void NekVector<DataType>::SetY(
305 typename boost::call_traits<DataType>::const_reference val)
306{
307 ASSERTL1(this->GetDimension() >= 2, "Invalid use of NekVector::SetX");
308 this->GetData()[1] = val;
309}
310
311template <typename DataType>
312void NekVector<DataType>::SetZ(
313 typename boost::call_traits<DataType>::const_reference val)
314{
315 ASSERTL1(this->GetDimension() >= 3, "Invalid use of NekVector::SetX");
316 this->GetData()[2] = val;
317}
318
319template <typename DataType>
320NekVector<DataType> &NekVector<DataType>::operator+=(
321 const NekVector<DataType> &rhs)
322{
323 AddEqual(*this, rhs);
324 return *this;
325}
326
327template <typename DataType>
328NekVector<DataType> &NekVector<DataType>::operator-=(
329 const NekVector<DataType> &rhs)
330{
331 SubtractEqual(*this, rhs);
332 return *this;
333}
334
335template <typename DataType>
336NekVector<DataType> &NekVector<DataType>::operator*=(
337 typename boost::call_traits<DataType>::const_reference rhs)
338{
339 MultiplyEqual(*this, rhs);
340 return *this;
341}
342
343template <typename DataType>
344NekVector<DataType> &NekVector<DataType>::operator/=(
345 typename boost::call_traits<DataType>::const_reference rhs)
346{
347 DivideEqual(*this, rhs);
348 return *this;
349}
350
351template <typename DataType> void NekVector<DataType>::Normalize()
352{
353 return Nektar::Normalize(*this);
354}
355
356template <typename DataType>
357typename boost::call_traits<DataType>::const_reference NekVector<
358 DataType>::operator()(unsigned int i) const
359{
360 ASSERTL1(i < GetDimension(),
361 "Invalid access to m_data via parenthesis operator");
362 return m_data[i];
363}
364
365template <typename DataType>
366typename boost::call_traits<DataType>::const_reference NekVector<
367 DataType>::operator[](unsigned int i) const
368{
369 return m_data[i];
370}
371
372template <typename DataType>
373typename boost::call_traits<DataType>::const_reference NekVector<DataType>::x()
374 const
375{
376 ASSERTL1(GetDimension() >= 1, "Invalid use of NekVector::x");
377 return (*this)(0);
378}
379
380template <typename DataType>
381typename boost::call_traits<DataType>::const_reference NekVector<DataType>::y()
382 const
383{
384 ASSERTL1(GetDimension() >= 2, "Invalid use of NekVector::y");
385 return (*this)(1);
386}
387
388template <typename DataType>
389typename boost::call_traits<DataType>::const_reference NekVector<DataType>::z()
390 const
391{
392 ASSERTL1(GetDimension() >= 3, "Invalid use of NekVector::z");
393 return (*this)(2);
394}
395
396template <typename DataType>
397NekVector<DataType> NekVector<DataType>::operator-() const
398{
399 return Negate(*this);
400}
401
402template <typename DataType> DataType NekVector<DataType>::Magnitude() const
403{
404 return Nektar::Magnitude(*this);
405}
406
407template <typename DataType>
408DataType NekVector<DataType>::Dot(const NekVector<DataType> &rhs) const
409{
410 return Nektar::Dot(*this, rhs);
411}
412
413template <typename DataType>
414NekVector<DataType> NekVector<DataType>::Cross(
415 const NekVector<DataType> &rhs) const
416{
417 return Nektar::Cross(*this, rhs);
418}
419
420template <typename DataType> std::string NekVector<DataType>::AsString() const
421{
422 return Nektar::AsString(*this);
423}
424
425// Norms
426template <typename DataType> DataType NekVector<DataType>::L1Norm() const
427{
428 return Nektar::L1Norm(*this);
429}
430
431template <typename DataType> DataType NekVector<DataType>::L2Norm() const
432{
433 return Nektar::L2Norm(*this);
434}
435
436template <typename DataType> DataType NekVector<DataType>::InfinityNorm() const
437{
438 return Nektar::InfinityNorm(*this);
439}
440
441template <typename DataType>
442PointerWrapper NekVector<DataType>::GetWrapperType() const
443{
444 return m_wrapperType;
445}
446
447template <typename DataType>
448Array<OneD, DataType> &NekVector<DataType>::GetData()
449{
450 return m_data;
451}
452
453template <typename DataType> void NekVector<DataType>::SetSize(unsigned int s)
454{
455 m_size = s;
456}
457
458template <typename DataType>
459void NekVector<DataType>::SetWrapperType(PointerWrapper p)
460{
461 m_wrapperType = p;
462}
463
464template <typename DataType>
465void NekVector<DataType>::SetData(const Array<OneD, DataType> &newData)
466{
467 m_data = newData;
468}
469
470template <typename DataType>
471void NekVector<DataType>::Resize(unsigned int newSize)
472{
473 if (m_data.size() < newSize)
474 {
475 m_data = Array<OneD, DataType>(newSize);
476 }
477 m_size = newSize;
478}
479
480template LIB_UTILITIES_EXPORT class NekVector<NekDouble>;
481template LIB_UTILITIES_EXPORT class NekVector<NekSingle>;
482
483template <typename DataType>
484void Add(NekVector<DataType> &result, const NekVector<DataType> &lhs,
485 const NekVector<DataType> &rhs)
486{
487 DataType *r_buf = result.GetRawPtr();
488 const DataType *lhs_buf = lhs.GetRawPtr();
489 const DataType *rhs_buf = rhs.GetRawPtr();
490 const unsigned int ldim = lhs.GetDimension();
491 for (int i = 0; i < ldim; ++i)
492 {
493 r_buf[i] = lhs_buf[i] + rhs_buf[i];
494 }
495}
496
497template <typename DataType>
498void AddNegatedLhs(NekVector<DataType> &result, const NekVector<DataType> &lhs,
499 const NekVector<DataType> &rhs)
500{
501 DataType *r_buf = result.GetRawPtr();
502 const DataType *lhs_buf = lhs.GetRawPtr();
503 const DataType *rhs_buf = rhs.GetRawPtr();
504 const unsigned int ldim = lhs.GetDimension();
505 for (int i = 0; i < ldim; ++i)
506 {
507 r_buf[i] = -lhs_buf[i] + rhs_buf[i];
508 }
509}
510
511template LIB_UTILITIES_EXPORT void Add(NekVector<NekDouble> &result,
512 const NekVector<NekDouble> &lhs,
513 const NekVector<NekDouble> &rhs);
514template LIB_UTILITIES_EXPORT void AddNegatedLhs(
515 NekVector<NekDouble> &result, const NekVector<NekDouble> &lhs,
516 const NekVector<NekDouble> &rhs);
517
518template LIB_UTILITIES_EXPORT void Add(NekVector<NekSingle> &result,
519 const NekVector<NekSingle> &lhs,
520 const NekVector<NekSingle> &rhs);
521template LIB_UTILITIES_EXPORT void AddNegatedLhs(
522 NekVector<NekSingle> &result, const NekVector<NekSingle> &lhs,
523 const NekVector<NekSingle> &rhs);
524
525template <typename DataType>
526void AddEqual(NekVector<DataType> &result, const NekVector<DataType> &rhs)
527{
528 DataType *r_buf = result.GetRawPtr();
529 const DataType *rhs_buf = rhs.GetRawPtr();
530 const unsigned int rdim = rhs.GetDimension();
531 for (int i = 0; i < rdim; ++i)
532 {
533 r_buf[i] += rhs_buf[i];
534 }
535}
536
537template <typename DataType>
538void AddEqualNegatedLhs(NekVector<DataType> &result,
539 const NekVector<DataType> &rhs)
540{
541 DataType *r_buf = result.GetRawPtr();
542 const DataType *rhs_buf = rhs.GetRawPtr();
543 const unsigned int rdim = rhs.GetDimension();
544 for (int i = 0; i < rdim; ++i)
545 {
546 r_buf[i] = -r_buf[i] + rhs_buf[i];
547 }
548}
549
550template LIB_UTILITIES_EXPORT void AddEqual(NekVector<NekDouble> &result,
551 const NekVector<NekDouble> &rhs);
552template LIB_UTILITIES_EXPORT void AddEqualNegatedLhs(
553 NekVector<NekDouble> &result, const NekVector<NekDouble> &rhs);
554
555template LIB_UTILITIES_EXPORT void AddEqual(NekVector<NekSingle> &result,
556 const NekVector<NekSingle> &rhs);
557template LIB_UTILITIES_EXPORT void AddEqualNegatedLhs(
558 NekVector<NekSingle> &result, const NekVector<NekSingle> &rhs);
559
560template <typename LhsDataType, typename RhsDataType>
561NekVector<LhsDataType> Add(const NekVector<LhsDataType> &lhs,
562 const NekVector<RhsDataType> &rhs)
563{
564 NekVector<LhsDataType> result(lhs.GetDimension());
565 Add(result, lhs, rhs);
566 return result;
567}
568
569template LIB_UTILITIES_EXPORT NekVector<NekDouble> Add(
570 const NekVector<NekDouble> &lhs, const NekVector<NekDouble> &rhs);
571
572template LIB_UTILITIES_EXPORT NekVector<NekSingle> Add(
573 const NekVector<NekSingle> &lhs, const NekVector<NekSingle> &rhs);
574
575template <typename ResultDataType, typename InputDataType>
576void Subtract(NekVector<ResultDataType> &result,
577 const NekVector<InputDataType> &lhs,
578 const NekVector<InputDataType> &rhs)
579{
580 ResultDataType *r_buf = result.GetRawPtr();
581 typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
582 typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
583 const unsigned int ldim = lhs.GetDimension();
584 for (int i = 0; i < ldim; ++i)
585 {
586 r_buf[i] = lhs_buf[i] - rhs_buf[i];
587 }
588}
589
590template <typename ResultDataType, typename InputDataType>
591void SubtractNegatedLhs(NekVector<ResultDataType> &result,
592 const NekVector<InputDataType> &lhs,
593 const NekVector<InputDataType> &rhs)
594{
595 ResultDataType *r_buf = result.GetRawPtr();
596 typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
597 typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
598 const unsigned int ldim = lhs.GetDimension();
599 for (int i = 0; i < ldim; ++i)
600 {
601 r_buf[i] = -lhs_buf[i] - rhs_buf[i];
602 }
603}
604
605template LIB_UTILITIES_EXPORT void Subtract(NekVector<NekDouble> &result,
606 const NekVector<NekDouble> &lhs,
607 const NekVector<NekDouble> &rhs);
608
609template LIB_UTILITIES_EXPORT void SubtractNegatedLhs(
610 NekVector<NekDouble> &result, const NekVector<NekDouble> &lhs,
611 const NekVector<NekDouble> &rhs);
612
613template LIB_UTILITIES_EXPORT void Subtract(NekVector<NekSingle> &result,
614 const NekVector<NekSingle> &lhs,
615 const NekVector<NekSingle> &rhs);
616
617template LIB_UTILITIES_EXPORT void SubtractNegatedLhs(
618 NekVector<NekSingle> &result, const NekVector<NekSingle> &lhs,
619 const NekVector<NekSingle> &rhs);
620
621template <typename ResultDataType, typename InputDataType>
622void SubtractEqual(NekVector<ResultDataType> &result,
623 const NekVector<InputDataType> &rhs)
624{
625 ResultDataType *r_buf = result.GetRawPtr();
626 typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
627 const unsigned int rdim = rhs.GetDimension();
628 for (int i = 0; i < rdim; ++i)
629 {
630 r_buf[i] -= rhs_buf[i];
631 }
632}
633
634template <typename ResultDataType, typename InputDataType>
635void SubtractEqualNegatedLhs(NekVector<ResultDataType> &result,
636 const NekVector<InputDataType> &rhs)
637{
638 ResultDataType *r_buf = result.GetRawPtr();
639 typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
640 const unsigned int rdim = rhs.GetDimension();
641 for (int i = 0; i < rdim; ++i)
642 {
643 r_buf[i] = -r_buf[i] - rhs_buf[i];
644 }
645}
646
647template LIB_UTILITIES_EXPORT void SubtractEqual(
648 NekVector<NekDouble> &result, const NekVector<NekDouble> &rhs);
649
650template LIB_UTILITIES_EXPORT void SubtractEqualNegatedLhs(
651 NekVector<NekDouble> &result, const NekVector<NekDouble> &rhs);
652
653template LIB_UTILITIES_EXPORT void SubtractEqual(
654 NekVector<NekSingle> &result, const NekVector<NekSingle> &rhs);
655
656template LIB_UTILITIES_EXPORT void SubtractEqualNegatedLhs(
657 NekVector<NekSingle> &result, const NekVector<NekSingle> &rhs);
658
659template <typename DataType>
660NekVector<DataType> Subtract(const NekVector<DataType> &lhs,
661 const NekVector<DataType> &rhs)
662{
663 NekVector<DataType> result(lhs.GetDimension());
664 Subtract(result, lhs, rhs);
665 return result;
666}
667
668template LIB_UTILITIES_EXPORT NekVector<NekDouble> Subtract(
669 const NekVector<NekDouble> &lhs, const NekVector<NekDouble> &rhs);
670
671template LIB_UTILITIES_EXPORT NekVector<NekSingle> Subtract(
672 const NekVector<NekSingle> &lhs, const NekVector<NekSingle> &rhs);
673
674template <typename ResultDataType, typename InputDataType>
675void Divide(NekVector<ResultDataType> &result,
676 const NekVector<InputDataType> &lhs, const NekDouble &rhs)
677{
678 ResultDataType *r_buf = result.GetRawPtr();
679 typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
680
681 const unsigned int ldim = lhs.GetDimension();
682 for (int i = 0; i < ldim; ++i)
683 {
684 r_buf[i] = lhs_buf[i] / rhs;
685 }
686}
687
688template <typename ResultDataType, typename InputDataType>
689void Divide(NekVector<ResultDataType> &result,
690 const NekVector<InputDataType> &lhs, const NekSingle &rhs)
691{
692 ResultDataType *r_buf = result.GetRawPtr();
693 typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
694
695 const unsigned int ldim = lhs.GetDimension();
696 for (int i = 0; i < ldim; ++i)
697 {
698 r_buf[i] = lhs_buf[i] / rhs;
699 }
700}
701
702template LIB_UTILITIES_EXPORT void Divide(NekVector<NekDouble> &result,
703 const NekVector<NekDouble> &lhs,
704 const NekDouble &rhs);
705
706template LIB_UTILITIES_EXPORT void Divide(NekVector<NekSingle> &result,
707 const NekVector<NekSingle> &lhs,
708 const NekSingle &rhs);
709
710template <typename ResultDataType>
711void DivideEqual(NekVector<ResultDataType> &result, const NekDouble &rhs)
712{
713 ResultDataType *r_buf = result.GetRawPtr();
714
715 const unsigned int resdim = result.GetDimension();
716 for (int i = 0; i < resdim; ++i)
717 {
718 r_buf[i] /= rhs;
719 }
720}
721
722template <typename ResultDataType>
723void DivideEqual(NekVector<ResultDataType> &result, const NekSingle &rhs)
724{
725 ResultDataType *r_buf = result.GetRawPtr();
726
727 const unsigned int resdim = result.GetDimension();
728 for (int i = 0; i < resdim; ++i)
729 {
730 r_buf[i] /= rhs;
731 }
732}
733
734template LIB_UTILITIES_EXPORT void DivideEqual(NekVector<NekDouble> &result,
735 const NekDouble &rhs);
736
737template LIB_UTILITIES_EXPORT void DivideEqual(NekVector<NekSingle> &result,
738 const NekSingle &rhs);
739
740template <typename DataType>
741NekVector<DataType> Divide(const NekVector<DataType> &lhs, const NekDouble &rhs)
742{
743 NekVector<DataType> result(lhs.GetDimension());
744 Divide(result, lhs, rhs);
745 return result;
746}
747
748template <typename DataType>
749NekVector<DataType> Divide(const NekVector<DataType> &lhs, const NekSingle &rhs)
750{
751 NekVector<DataType> result(lhs.GetDimension());
752 Divide(result, lhs, rhs);
753 return result;
754}
755
756template LIB_UTILITIES_EXPORT NekVector<NekDouble> Divide(
757 const NekVector<NekDouble> &lhs, const NekDouble &rhs);
758
759template LIB_UTILITIES_EXPORT NekVector<NekSingle> Divide(
760 const NekVector<NekSingle> &lhs, const NekSingle &rhs);
761
762template <typename ResultDataType, typename InputDataType>
763void Multiply(NekVector<ResultDataType> &result,
764 const NekVector<InputDataType> &lhs,
765 const NekVector<InputDataType> &rhs)
766{
767 ResultDataType *result_buf = result.GetRawPtr();
768 const InputDataType *rhs_buf = rhs.GetRawPtr();
769 const InputDataType *lhs_buf = lhs.GetRawPtr();
770 const unsigned int resdim = result.GetDimension();
771 for (int i = 0; i < resdim; ++i)
772 {
773 result_buf[i] = lhs_buf[i] * rhs_buf[i];
774 }
775}
776
777template LIB_UTILITIES_EXPORT void Multiply(NekVector<NekDouble> &result,
778 const NekVector<NekDouble> &lhs,
779 const NekVector<NekDouble> &rhs);
780
781template LIB_UTILITIES_EXPORT void Multiply(NekVector<NekSingle> &result,
782 const NekVector<NekSingle> &lhs,
783 const NekVector<NekSingle> &rhs);
784
785template <typename ResultDataType, typename InputDataType>
786void MultiplyEqual(NekVector<ResultDataType> &result,
787 const NekVector<InputDataType> &rhs)
788{
789 ResultDataType *result_buf = result.GetRawPtr();
790 const InputDataType *rhs_buf = rhs.GetRawPtr();
791 const unsigned int resdim = result.GetDimension();
792 for (int i = 0; i < resdim; ++i)
793 {
794 result_buf[i] *= rhs_buf[i];
795 }
796}
797
798template LIB_UTILITIES_EXPORT void MultiplyEqual(
799 NekVector<NekDouble> &result, const NekVector<NekDouble> &rhs);
800
801template LIB_UTILITIES_EXPORT void MultiplyEqual(
802 NekVector<NekSingle> &result, const NekVector<NekSingle> &rhs);
803
804template <typename DataType, typename InputDataType>
805NekVector<DataType> Multiply(const NekVector<DataType> &lhs,
806 const NekVector<InputDataType> &rhs)
807{
808 NekVector<DataType> result(lhs.GetDimension());
809 Multiply(result, lhs, rhs);
810 return result;
811}
812
813template LIB_UTILITIES_EXPORT NekVector<NekDouble> Multiply(
814 const NekVector<NekDouble> &lhs, const NekVector<NekDouble> &rhs);
815
816template LIB_UTILITIES_EXPORT NekVector<NekSingle> Multiply(
817 const NekVector<NekSingle> &lhs, const NekVector<NekSingle> &rhs);
818
819template <typename ResultDataType, typename InputDataType>
820void Multiply(NekVector<ResultDataType> &result,
821 const NekVector<InputDataType> &lhs, const NekDouble &rhs)
822{
823 ResultDataType *r_buf = result.GetRawPtr();
824 const InputDataType *lhs_buf = lhs.GetRawPtr();
825
826 const unsigned int ldim = lhs.GetDimension();
827 for (int i = 0; i < ldim; ++i)
828 {
829 r_buf[i] = lhs_buf[i] * rhs;
830 }
831}
832
833template <typename ResultDataType, typename InputDataType>
834void Multiply(NekVector<ResultDataType> &result,
835 const NekVector<InputDataType> &lhs, const NekSingle &rhs)
836{
837 ResultDataType *r_buf = result.GetRawPtr();
838 const InputDataType *lhs_buf = lhs.GetRawPtr();
839
840 const unsigned int ldim = lhs.GetDimension();
841 for (int i = 0; i < ldim; ++i)
842 {
843 r_buf[i] = lhs_buf[i] * rhs;
844 }
845}
846
847template LIB_UTILITIES_EXPORT void Multiply(NekVector<NekDouble> &result,
848 const NekVector<NekDouble> &lhs,
849 const NekDouble &rhs);
850
851template LIB_UTILITIES_EXPORT void Multiply(NekVector<NekSingle> &result,
852 const NekVector<NekSingle> &lhs,
853 const NekSingle &rhs);
854
855template <typename ResultDataType>
856void MultiplyEqual(NekVector<ResultDataType> &result, const NekDouble &rhs)
857{
858 ResultDataType *r_buf = result.GetRawPtr();
859 const unsigned int rdim = result.GetDimension();
860 for (unsigned int i = 0; i < rdim; ++i)
861 {
862 r_buf[i] *= rhs;
863 }
864}
865
866template <typename ResultDataType>
867void MultiplyEqual(NekVector<ResultDataType> &result, const NekSingle &rhs)
868{
869 ResultDataType *r_buf = result.GetRawPtr();
870 const unsigned int rdim = result.GetDimension();
871 for (unsigned int i = 0; i < rdim; ++i)
872 {
873 r_buf[i] *= rhs;
874 }
875}
876template LIB_UTILITIES_EXPORT void MultiplyEqual(NekVector<NekDouble> &result,
877 const NekDouble &rhs);
878
879template LIB_UTILITIES_EXPORT void MultiplyEqual(NekVector<NekSingle> &result,
880 const NekSingle &rhs);
881
882template <typename DataType>
883NekVector<DataType> Multiply(const NekVector<DataType> &lhs,
884 const NekDouble &rhs)
885{
886 NekVector<DataType> result(lhs.GetDimension());
887 Multiply(result, lhs, rhs);
888 return result;
889}
890
891template <typename DataType>
892NekVector<DataType> Multiply(const NekVector<DataType> &lhs,
893 const NekSingle &rhs)
894{
895 NekVector<DataType> result(lhs.GetDimension());
896 Multiply(result, lhs, rhs);
897 return result;
898}
899
900template LIB_UTILITIES_EXPORT NekVector<NekDouble> Multiply(
901 const NekVector<NekDouble> &lhs, const NekDouble &rhs);
902
903template LIB_UTILITIES_EXPORT NekVector<NekSingle> Multiply(
904 const NekVector<NekSingle> &lhs, const NekSingle &rhs);
905
906template <typename ResultDataType, typename InputDataType>
907void Multiply(NekVector<ResultDataType> &result, const NekDouble &lhs,
908 const NekVector<InputDataType> &rhs)
909{
910 Multiply(result, rhs, lhs);
911}
912
913template <typename ResultDataType, typename InputDataType>
914void MultiplyInvertedLhs(NekVector<ResultDataType> &result,
915 const NekDouble &lhs,
916 const NekVector<InputDataType> &rhs)
917{
918 ResultDataType *r_buf = result.GetRawPtr();
919 const InputDataType *rhs_buf = rhs.GetRawPtr();
920 NekDouble inverse = 1.0 / lhs;
921
922 const unsigned int rdim = rhs.GetDimension();
923 for (int i = 0; i < rdim; ++i)
924 {
925 r_buf[i] = inverse * rhs_buf[i];
926 }
927}
928
929template <typename ResultDataType, typename InputDataType>
930void Multiply(NekVector<ResultDataType> &result, const NekSingle &lhs,
931 const NekVector<InputDataType> &rhs)
932{
933 Multiply(result, rhs, lhs);
934}
935
936template <typename ResultDataType, typename InputDataType>
937void MultiplyInvertedLhs(NekVector<ResultDataType> &result,
938 const NekSingle &lhs,
939 const NekVector<InputDataType> &rhs)
940{
941 ResultDataType *r_buf = result.GetRawPtr();
942 const InputDataType *rhs_buf = rhs.GetRawPtr();
943 NekSingle inverse = 1.0 / lhs;
944
945 const unsigned int rdim = rhs.GetDimension();
946 for (int i = 0; i < rdim; ++i)
947 {
948 r_buf[i] = inverse * rhs_buf[i];
949 }
950}
951
952template LIB_UTILITIES_EXPORT void MultiplyInvertedLhs(
953 NekVector<NekDouble> &result, const NekDouble &lhs,
954 const NekVector<NekDouble> &rhs);
955
956template LIB_UTILITIES_EXPORT void Multiply(NekVector<NekDouble> &result,
957 const NekDouble &lhs,
958 const NekVector<NekDouble> &rhs);
959
960template LIB_UTILITIES_EXPORT void MultiplyInvertedLhs(
961 NekVector<NekSingle> &result, const NekSingle &lhs,
962 const NekVector<NekSingle> &rhs);
963
964template LIB_UTILITIES_EXPORT void Multiply(NekVector<NekSingle> &result,
965 const NekSingle &lhs,
966 const NekVector<NekSingle> &rhs);
967
968template <typename DataType>
969NekVector<DataType> Multiply(const DataType &lhs,
970 const NekVector<DataType> &rhs)
971{
972 return Multiply(rhs, lhs);
973}
974
975template LIB_UTILITIES_EXPORT NekVector<NekDouble> Multiply(
976 const NekDouble &lhs, const NekVector<NekDouble> &rhs);
977
978template LIB_UTILITIES_EXPORT NekVector<NekSingle> Multiply(
979 const NekSingle &lhs, const NekVector<NekSingle> &rhs);
980
981template <typename DataType>
982std::ostream &operator<<(std::ostream &os, const NekVector<DataType> &rhs)
983{
984 os << rhs.AsString();
985 return os;
986}
987
988template LIB_UTILITIES_EXPORT std::ostream &operator<<(
989 std::ostream &os, const NekVector<NekDouble> &rhs);
990
991template LIB_UTILITIES_EXPORT std::ostream &operator<<(
992 std::ostream &os, const NekVector<NekSingle> &rhs);
993
994template <typename DataType>
995NekVector<DataType> createVectorFromPoints(const NekPoint<DataType> &source,
996 const NekPoint<DataType> &dest)
997{
998 NekVector<DataType> result(3, 0.0);
999 for (unsigned int i = 0; i < 3; ++i)
1000 {
1001 result[i] = dest[i] - source[i];
1002 }
1003 return result;
1004}
1005
1006template LIB_UTILITIES_EXPORT NekVector<NekDouble> createVectorFromPoints(
1007 const NekPoint<NekDouble> &source, const NekPoint<NekDouble> &dest);
1008
1009template LIB_UTILITIES_EXPORT NekVector<NekSingle> createVectorFromPoints(
1010 const NekPoint<NekSingle> &source, const NekPoint<NekSingle> &dest);
1011
1012template <typename DataType>
1013NekPoint<DataType> findPointAlongVector(const NekVector<DataType> &lhs,
1014 const DataType &t)
1015{
1016 NekPoint<DataType> result;
1017 for (unsigned int i = 0; i < 3; ++i)
1018 {
1019 result[i] = lhs[i] * t;
1020 }
1021
1022 return result;
1023}
1024
1025template LIB_UTILITIES_EXPORT NekPoint<NekDouble> findPointAlongVector(
1026 const NekVector<NekDouble> &lhs, const NekDouble &t);
1027
1028template LIB_UTILITIES_EXPORT NekPoint<NekSingle> findPointAlongVector(
1029 const NekVector<NekSingle> &lhs, const NekSingle &t);
1030
1031template <typename DataType>
1032bool operator==(const NekVector<DataType> &lhs, const NekVector<DataType> &rhs)
1033{
1034 if (lhs.GetDimension() != rhs.GetDimension())
1035 {
1036 return false;
1037 }
1038
1039 return std::equal(lhs.begin(), lhs.end(), rhs.begin());
1040}
1041
1042template LIB_UTILITIES_EXPORT bool operator==(const NekVector<NekDouble> &lhs,
1043 const NekVector<NekDouble> &rhs);
1044
1045template LIB_UTILITIES_EXPORT bool operator==(const NekVector<NekSingle> &lhs,
1046 const NekVector<NekSingle> &rhs);
1047
1048template <typename DataType>
1049bool operator!=(const NekVector<DataType> &lhs, const NekVector<DataType> &rhs)
1050{
1051 return !(lhs == rhs);
1052}
1053
1054template LIB_UTILITIES_EXPORT bool operator!=(const NekVector<NekDouble> &lhs,
1055 const NekVector<NekDouble> &rhs);
1056
1057template LIB_UTILITIES_EXPORT bool operator!=(const NekVector<NekSingle> &lhs,
1058 const NekVector<NekSingle> &rhs);
1059
1060template <typename DataType>
1061std::vector<DataType> FromString(const std::string &str)
1062{
1063 std::vector<DataType> result;
1064
1065 try
1066 {
1067 typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
1068 boost::char_separator<char> sep("(<,>) ");
1069 tokenizer tokens(str, sep);
1070 for (tokenizer::iterator strIter = tokens.begin();
1071 strIter != tokens.end(); ++strIter)
1072 {
1073 result.push_back(boost::lexical_cast<DataType>(*strIter));
1074 }
1075 }
1076 catch (boost::bad_lexical_cast &)
1077 {
1078 }
1079
1080 return result;
1081}
1082
1083template LIB_UTILITIES_EXPORT std::vector<NekDouble> FromString(
1084 const std::string &str);
1085
1086template LIB_UTILITIES_EXPORT std::vector<NekSingle> FromString(
1087 const std::string &str);
1088
1089template <typename DataType> DataType L1Norm(const NekVector<DataType> &v)
1090{
1091 typedef NekVector<DataType> VectorType;
1092
1093 DataType result(0);
1094 for (typename VectorType::const_iterator iter = v.begin(); iter != v.end();
1095 ++iter)
1096 {
1097 result += fabs(*iter);
1098 }
1099
1100 return result;
1101}
1102
1103template LIB_UTILITIES_EXPORT NekDouble L1Norm(const NekVector<NekDouble> &v);
1104
1105template LIB_UTILITIES_EXPORT NekSingle L1Norm(const NekVector<NekSingle> &v);
1106
1107template <typename DataType> DataType L2Norm(const NekVector<DataType> &v)
1108{
1109 typedef NekVector<DataType> VectorType;
1110
1111 DataType result(0);
1112 for (typename VectorType::const_iterator iter = v.begin(); iter != v.end();
1113 ++iter)
1114 {
1115 DataType v = fabs(*iter);
1116 result += v * v;
1117 }
1118 return sqrt(result);
1119}
1120
1121template LIB_UTILITIES_EXPORT NekDouble L2Norm(const NekVector<NekDouble> &v);
1122
1123template LIB_UTILITIES_EXPORT NekSingle L2Norm(const NekVector<NekSingle> &v);
1124
1125template <typename DataType> DataType InfinityNorm(const NekVector<DataType> &v)
1126{
1127 DataType result = fabs(v[0]);
1128 const unsigned int vdim = v.GetDimension();
1129 for (unsigned int i = 0; i < vdim; ++i)
1130 {
1131 result = std::max(DataType(fabs(v[i])), result);
1132 }
1133 return result;
1134}
1135
1136template LIB_UTILITIES_EXPORT NekDouble
1137InfinityNorm(const NekVector<NekDouble> &v);
1138
1139template LIB_UTILITIES_EXPORT NekSingle
1140InfinityNorm(const NekVector<NekSingle> &v);
1141
1142template <typename DataType>
1143NekVector<DataType> Negate(const NekVector<DataType> &v)
1144{
1145 NekVector<DataType> temp(v);
1146 const unsigned int tdim = temp.GetDimension();
1147 for (unsigned int i = 0; i < tdim; ++i)
1148 {
1149 temp(i) = -temp(i);
1150 }
1151 return temp;
1152}
1153
1154template LIB_UTILITIES_EXPORT NekVector<NekDouble> Negate(
1155 const NekVector<NekDouble> &v);
1156
1157template LIB_UTILITIES_EXPORT NekVector<NekSingle> Negate(
1158 const NekVector<NekSingle> &v);
1159
1160template <typename DataType> void NegateInPlace(NekVector<DataType> &v)
1161{
1162 DataType *data = v.GetRawPtr();
1163 const unsigned int vdim = v.GetDimension();
1164 for (unsigned int i = 0; i < vdim; ++i)
1165 {
1166 data[i] = -data[i];
1167 }
1168}
1169
1170template LIB_UTILITIES_EXPORT void NegateInPlace(NekVector<NekDouble> &v);
1171
1172template LIB_UTILITIES_EXPORT void NegateInPlace(NekVector<NekSingle> &v);
1173
1174template <typename DataType> DataType Magnitude(const NekVector<DataType> &v)
1175{
1176 DataType result = DataType(0);
1177
1178 const unsigned int vdim = v.GetDimension();
1179 for (unsigned int i = 0; i < vdim; ++i)
1180 {
1181 result += v[i] * v[i];
1182 }
1183 return sqrt(result);
1184}
1185
1186template LIB_UTILITIES_EXPORT NekDouble
1187Magnitude(const NekVector<NekDouble> &v);
1188
1189template LIB_UTILITIES_EXPORT NekSingle
1190Magnitude(const NekVector<NekSingle> &v);
1191
1192template <typename DataType>
1193DataType Dot(const NekVector<DataType> &lhs, const NekVector<DataType> &rhs)
1194{
1195 ASSERTL1(lhs.GetDimension() == rhs.GetDimension(),
1196 "Dot, dimension of the two operands must be identical.");
1197
1198 DataType result = DataType(0);
1199 const unsigned int ldim = lhs.GetDimension();
1200 for (unsigned int i = 0; i < ldim; ++i)
1201 {
1202 result += lhs[i] * rhs[i];
1203 }
1204
1205 return result;
1206}
1207
1208template LIB_UTILITIES_EXPORT NekDouble Dot(const NekVector<NekDouble> &lhs,
1209 const NekVector<NekDouble> &rhs);
1210
1211template LIB_UTILITIES_EXPORT NekSingle Dot(const NekVector<NekSingle> &lhs,
1212 const NekVector<NekSingle> &rhs);
1213
1214template <typename DataType> void Normalize(NekVector<DataType> &v)
1215{
1216 DataType m = v.Magnitude();
1217 if (m > DataType(0))
1218 {
1219 v /= m;
1220 }
1221}
1222
1223template LIB_UTILITIES_EXPORT void Normalize(NekVector<NekDouble> &v);
1224
1225void NegateInPlace(NekDouble &v)
1226{
1227 v = -v;
1228}
1229void InvertInPlace(NekDouble &v)
1230{
1231 v = 1.0 / v;
1232}
1233
1234template LIB_UTILITIES_EXPORT void Normalize(NekVector<NekSingle> &v);
1235
1236void NegateInPlace(NekSingle &v)
1237{
1238 v = -v;
1239}
1240void InvertInPlace(NekSingle &v)
1241{
1242 v = 1.0 / v;
1243}
1244
1245template <typename DataType>
1246NekVector<DataType> Cross(const NekVector<DataType> &lhs,
1247 const NekVector<DataType> &rhs)
1248{
1249 ASSERTL1(lhs.GetDimension() == 3 && rhs.GetDimension() == 3,
1250 "Cross is only valid for 3D vectors.");
1251
1252 DataType first = lhs.y() * rhs.z() - lhs.z() * rhs.y();
1253 DataType second = lhs.z() * rhs.x() - lhs.x() * rhs.z();
1254 DataType third = lhs.x() * rhs.y() - lhs.y() * rhs.x();
1255
1256 NekVector<DataType> result(first, second, third);
1257 return result;
1258}
1259
1260template LIB_UTILITIES_EXPORT NekVector<NekDouble> Cross(
1261 const NekVector<NekDouble> &lhs, const NekVector<NekDouble> &rhs);
1262
1263template LIB_UTILITIES_EXPORT NekVector<NekSingle> Cross(
1264 const NekVector<NekSingle> &lhs, const NekVector<NekSingle> &rhs);
1265
1266template <typename DataType> std::string AsString(const NekVector<DataType> &v)
1267{
1268 unsigned int d = v.GetRows();
1269 std::string result = "(";
1270 for (unsigned int i = 0; i < d; ++i)
1271 {
1272 result += boost::lexical_cast<std::string>(v[i]);
1273 if (i < v.GetDimension() - 1)
1274 {
1275 result += ", ";
1276 }
1277 }
1278 result += ")";
1279 return result;
1280}
1281
1282template LIB_UTILITIES_EXPORT std::string AsString(
1283 const NekVector<NekDouble> &v);
1284
1285template LIB_UTILITIES_EXPORT std::string AsString(
1286 const NekVector<NekSingle> &v);
1287} // namespace Nektar
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
LIB_UTILITIES_EXPORT
#define LIB_UTILITIES_EXPORT
Definition: LibUtilitiesDeclspec.h:45
operator==
bool operator==(const VertexSharedPtr &v1, const VertexSharedPtr &v2)
Define comparison operator for the vertex struct.
Definition: VtkToFld.cpp:95
Nektar::Array< OneD, DataType >::begin
Array< OneD, constDataType >::const_iterator begin() const
Definition: SharedArray.hpp:661
Nektar::Array< OneD, const DataType >
1D Array of constant elements with garbage collection and bounds checking.
Definition: SharedArray.hpp:56
Nektar::Array< OneD, const DataType >::size
size_type size() const
Returns the array's size.
Definition: SharedArray.hpp:329
Nektar::NekVector::x
boost::call_traits< DataType >::reference x()
Definition: NekVector.cpp:275
Nektar::NekVector::m_size
unsigned int m_size
Definition: NekVector.hpp:204
Nektar::NekVector::GetDimension
unsigned int GetDimension() const
Returns the number of dimensions for the point.
Definition: NekVector.cpp:201
Nektar::NekVector::m_data
Array< OneD, DataType > m_data
Definition: NekVector.hpp:205
Nektar::NekVector::GetRows
unsigned int GetRows() const
Definition: NekVector.cpp:206
Nektar::NekVector::AsString
std::string AsString() const
Definition: NekVector.cpp:420
Nektar::NekVector::y
boost::call_traits< DataType >::reference y()
Definition: NekVector.cpp:282
Nektar::NekVector::begin
iterator begin()
Definition: NekVector.cpp:235
Nektar::NekVector::iterator
DataType * iterator
Definition: NekVector.hpp:109
Nektar::NekVector::end
iterator end()
Definition: NekVector.cpp:241
Nektar::NekVector::const_iterator
const DataType * const_iterator
Definition: NekVector.hpp:113
Nektar::NekVector::Magnitude
DataType Magnitude() const
Definition: NekVector.cpp:402
Nektar::NekVector::NekVector
NekVector()
Creates an empty vector.
Definition: NekVector.cpp:41
Nektar::NekVector::GetRawPtr
DataType * GetRawPtr()
Definition: NekVector.cpp:211
Nektar::NekVector::z
boost::call_traits< DataType >::reference z()
Definition: NekVector.cpp:289
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
CellMLToNektar.pycml.copy
def copy(self)
Definition: pycml.py:2663
Nektar::UnitTests::z
std::vector< double > z(NPUPPER)
Nektar::UnitTests::d
std::vector< double > d(NPUPPER *NPUPPER)
Nektar::Divide
template NekVector< NekSingle > Divide(const NekVector< NekSingle > &lhs, const NekSingle &rhs)
Nektar::Normalize
void Normalize(NekVector< DataType > &v)
Definition: NekVector.cpp:1214
Nektar::Multiply
template NekVector< NekSingle > Multiply(const NekSingle &lhs, const NekVector< NekSingle > &rhs)
Nektar::L2Norm
template NekSingle L2Norm(const NekVector< NekSingle > &v)
Nektar::Dot
template NekSingle Dot(const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::AsString
std::string AsString(const NekVector< DataType > &v)
Definition: NekVector.cpp:1266
Nektar::SubtractNegatedLhs
template void SubtractNegatedLhs(NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::AsString
template std::string AsString(const NekVector< NekSingle > &v)
Nektar::operator-
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > operator-(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
Definition: MatrixOperations.hpp:359
Nektar::AddEqualNegatedLhs
template void AddEqualNegatedLhs(NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
Nektar::findPointAlongVector
template NekPoint< NekSingle > findPointAlongVector(const NekVector< NekSingle > &lhs, const NekSingle &t)
Nektar::eVECTOR_WRAPPER
@ eVECTOR_WRAPPER
Definition: SharedArray.hpp:566
Nektar::Subtract
template NekVector< NekSingle > Subtract(const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::SubtractEqual
template void SubtractEqual(NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
Nektar::InfinityNorm
DataType InfinityNorm(const NekVector< DataType > &v)
Definition: NekVector.cpp:1125
Nektar::NegateInPlace
void NegateInPlace(NekSingle &v)
Definition: NekVector.cpp:1236
Nektar::AddNegatedLhs
template void AddNegatedLhs(NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::Normalize
template void Normalize(NekVector< NekSingle > &v)
Nektar::MultiplyEqual
template void MultiplyEqual(NekVector< NekSingle > &result, const NekSingle &rhs)
Nektar::Cross
template NekVector< NekSingle > Cross(const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::Negate
template NekVector< NekSingle > Negate(const NekVector< NekSingle > &v)
Nektar::createVectorFromPoints
template NekVector< NekSingle > createVectorFromPoints(const NekPoint< NekSingle > &source, const NekPoint< NekSingle > &dest)
Nektar::L1Norm
template NekSingle L1Norm(const NekVector< NekSingle > &v)
Nektar::InvertInPlace
void InvertInPlace(NekSingle &v)
Definition: NekVector.cpp:1240
Nektar::MultiplyInvertedLhs
template void MultiplyInvertedLhs(NekVector< NekSingle > &result, const NekSingle &lhs, const NekVector< NekSingle > &rhs)
Nektar::SubtractEqualNegatedLhs
template void SubtractEqualNegatedLhs(NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
Nektar::Magnitude
DataType Magnitude(const NekVector< DataType > &v)
Definition: NekVector.cpp:1174
Nektar::operator<<
template std::ostream & operator<<(std::ostream &os, const NekVector< NekSingle > &rhs)
Nektar::Cross
NekVector< DataType > Cross(const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
Definition: NekVector.cpp:1246
Nektar::DivideEqual
template void DivideEqual(NekVector< NekSingle > &result, const NekSingle &rhs)
Nektar::InfinityNorm
template NekSingle InfinityNorm(const NekVector< NekSingle > &v)
Nektar::L2Norm
DataType L2Norm(const NekVector< DataType > &v)
Definition: NekVector.cpp:1107
Nektar::FromString
template std::vector< NekDouble > FromString(const std::string &str)
Nektar::L1Norm
DataType L1Norm(const NekVector< DataType > &v)
Definition: NekVector.cpp:1089
Nektar::Add
template NekVector< NekSingle > Add(const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::operator!=
template bool operator!=(const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)
Nektar::AddEqual
template void AddEqual(NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::PointerWrapper
PointerWrapper
Specifies if the pointer passed to a NekMatrix or NekVector is copied into an internal representation...
Definition: PointerWrapper.h:44
Nektar::Dot
DataType Dot(const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
Definition: NekVector.cpp:1193
Nektar::CopyArray
void CopyArray(const Array< OneD, ConstDataType > &source, Array< OneD, DataType > &dest)
Definition: SharedArray.hpp:863
Nektar::Magnitude
template NekSingle Magnitude(const NekVector< NekSingle > &v)
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:294
Generated on Wed Jan 31 2024 09:35:54 for Nektar++ by doxygen 1.9.4