Nektar++
Namespaces | Functions
Vmath Namespace Reference

Namespaces

namespace  SIMD
 

Functions

template<class T >
T ran2 (long *idum)
 Generates a number from ~Normal(0,1) More...
 
template Nektar::NekDouble ran2 (long *idum)
 
template<class T >
void FillWhiteNoise (int n, const T eps, T *x, const int incx, int outseed)
 Fills a vector with white noise. More...
 
template void FillWhiteNoise (int n, const Nektar::NekDouble eps, Nektar::NekDouble *x, const int incx, int outseed)
 
template void FillWhiteNoise (int n, const Nektar::NekSingle eps, Nektar::NekSingle *x, const int incx, int outseed)
 
template<class T >
void Fill (int n, const T alpha, T *x, const int incx)
 Fill a vector with a constant value. More...
 
template<class T >
void Vmul (int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 Multiply vector z = x*y. More...
 
template<class T >
void Smul (int n, const T alpha, const T *x, const int incx, T *y, const int incy)
 Scalar multiply y = alpha*x. More...
 
template<class T >
void Vdiv (int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 Multiply vector z = x/y. More...
 
template<class T >
void Sdiv (int n, const T alpha, const T *x, const int incx, T *y, const int incy)
 Scalar multiply y = alpha/x. More...
 
template<class T >
void Vadd (int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 Add vector z = x+y. More...
 
template<class T >
void Sadd (int n, const T alpha, const T *x, const int incx, T *y, const int incy)
 Add vector y = alpha + x. More...
 
template<class T >
void Vsub (int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 Subtract vector z = x-y. More...
 
template<class T >
void Ssub (int n, const T alpha, const T *x, const int incx, T *y, const int incy)
 Substract vector y = alpha - x. More...
 
template<class T >
void Zero (int n, T *x, const int incx)
 Zero vector. More...
 
template<class T >
void Neg (int n, T *x, const int incx)
 Negate x = -x. More...
 
template<class T >
void Vlog (int n, const T *x, const int incx, T *y, const int incy)
 log y = log(x) More...
 
template<class T >
void Vexp (int n, const T *x, const int incx, T *y, const int incy)
 exp y = exp(x) More...
 
template<class T >
void Vpow (int n, const T *x, const int incx, const T f, T *y, const int incy)
 pow y = pow(x, f) More...
 
template<class T >
void Vsqrt (int n, const T *x, const int incx, T *y, const int incy)
 sqrt y = sqrt(x) More...
 
template<class T >
void Vabs (int n, const T *x, const int incx, T *y, const int incy)
 vabs: y = |x| More...
 
template<class T >
void Vvtvp (int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 vvtvp (vector times vector plus vector): z = w*x + y More...
 
template<class T >
void Vvtvm (int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 vvtvm (vector times vector minus vector): z = w*x - y More...
 
template<class T >
void Svtvp (int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 Svtvp (scalar times vector plus vector): z = alpha*x + y. More...
 
template<class T >
void Svtvm (int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
 Svtvm (scalar times vector minus vector): z = alpha*x - y. More...
 
template<class T >
void Vvtvvtp (int n, const T *v, int incv, const T *w, int incw, const T *x, int incx, const T *y, int incy, T *z, int incz)
 vvtvvtp (vector times vector plus vector times vector): More...
 
template<class T >
void Vvtvvtm (int n, const T *v, int incv, const T *w, int incw, const T *x, int incx, const T *y, int incy, T *z, int incz)
 vvtvvtm (vector times vector minus vector times vector): More...
 
template<class T >
void Svtsvtp (int n, const T alpha, const T *x, int incx, const T beta, const T *y, int incy, T *z, int incz)
 Svtsvtp (scalar times vector plus scalar times vector): More...
 
template<class T >
void Vstvpp (int n, const T alpha, const T *v, int incv, const T *w, int incw, const T *x, int incx, T *z, int incz)
 Vstvpp (scalar times vector plus vector plus vector): More...
 
template<class T , class I , typename = typename std::enable_if<std::is_floating_point<T>::value && std::is_integral<I>::value>::type>
void Gathr (I n, const T *x, const I *y, T *z)
 Gather vector z[i] = x[y[i]]. More...
 
template<class T >
void Gathr (int n, const T sign, const T *x, const int *y, T *z)
 Gather vector z[i] = sign*x[y[i]]. More...
 
template<class T >
void Gathr (int n, const T *sign, const T *x, const int *y, T *z)
 Gather vector z[i] = sign[i]*x[y[i]]. More...
 
template<class T >
void Scatr (int n, const T *x, const int *y, T *z)
 Scatter vector z[y[i]] = x[i]. More...
 
template<class T >
void Scatr (int n, const T sign, const T *x, const int *y, T *z)
 Scatter vector z[y[i]] = sign*x[i]. More...
 
template<class T >
void Scatr (int n, const T *sign, const T *x, const int *y, T *z)
 Scatter vector z[y[i]] = sign[i]*x[i]. More...
 
template<class T >
void Assmb (int n, const T *x, const int *y, T *z)
 Assemble z[y[i]] += x[i]; z should be zero'd first. More...
 
template<class T >
void Assmb (int n, const T sign, const T *x, const int *y, T *z)
 Assemble z[y[i]] += sign*x[i]; z should be zero'd first. More...
 
template<class T >
void Assmb (int n, const T *sign, const T *x, const int *y, T *z)
 Assemble z[y[i]] += sign[i]*x[i]; z should be zero'd first. More...
 
template<class T >
T Vsum (int n, const T *x, const int incx)
 Subtract return sum(x) More...
 
template<class T >
int Imax (int n, const T *x, const int incx)
 Return the index of the maximum element in x. More...
 
template<class T >
T Vmax (int n, const T *x, const int incx)
 Return the maximum element in x – called vmax to avoid conflict with max. More...
 
template<class T >
int Iamax (int n, const T *x, const int incx)
 Return the index of the maximum absolute element in x. More...
 
template<class T >
T Vamax (int n, const T *x, const int incx)
 Return the maximum absolute element in x called vamax to avoid conflict with max. More...
 
template<class T >
int Imin (int n, const T *x, const int incx)
 Return the index of the minimum element in x. More...
 
template<class T >
T Vmin (int n, const T *x, const int incx)
 Return the minimum element in x - called vmin to avoid conflict with min. More...
 
template<class T >
int Nnan (int n, const T *x, const int incx)
 Return number of NaN elements of x. More...
 
template<class T >
T Dot (int n, const T *w, const T *x)
 dot product More...
 
template<class T >
T Dot (int n, const T *w, const int incw, const T *x, const int incx)
 dot product More...
 
template<class T >
T Dot2 (int n, const T *w, const T *x, const int *y)
 dot product More...
 
template<class T >
T Dot2 (int n, const T *w, const int incw, const T *x, const int incx, const int *y, const int incy)
 dot product More...
 
template<class T >
void Vcopy (int n, const T *x, const int incx, T *y, const int incy)
 
template<class T >
void Reverse (int n, const T *x, const int incx, T *y, const int incy)
 
template<class T >
void Fill (int n, const T alpha, Array< OneD, T > &x, const int incx)
 Fill a vector with a constant value. More...
 
template<class T >
void FillWhiteNoise (int n, const T eps, Array< OneD, T > &x, const int incx, int outseed=9999)
 
template<class T >
void Vmul (int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 Multiply vector z = x*y. More...
 
template<class T >
void Vmul (int n, const Array< TwoD, NekDouble >::const_reference &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 
template<class T >
void Smul (int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 Scalar multiply y = alpha*x. More...
 
template<class T >
void Vdiv (int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 Multiply vector z = x/y. More...
 
template<class T >
void Sdiv (int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 Scalar multiply y = alpha/x. More...
 
template<class T >
void Vadd (int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 Add vector z = x+y. More...
 
template<class T >
void Sadd (int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 Add vector y = alpha + x. More...
 
template<class T >
void Vsub (int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 Subtract vector z = x-y. More...
 
template<class T >
void Ssub (int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 Add vector y = alpha - x. More...
 
template<class T >
void Zero (int n, Array< OneD, T > &x, const int incx)
 Zero vector. More...
 
template<class T >
void Neg (int n, Array< OneD, T > &x, const int incx)
 Negate x = -x. More...
 
template<class T >
void Vlog (int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 log y = log(x) More...
 
template<class T >
void Vexp (int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 exp y = exp(x) More...
 
template<class T >
void Vpow (int n, const Array< OneD, const T > &x, const int incx, const T f, Array< OneD, T > &y, const int incy)
 pow y = pow(x, f) More...
 
template<class T >
void Vsqrt (int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 sqrt y = sqrt(x) More...
 
template<class T >
void Vabs (int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 vabs: y = |x| More...
 
template<class T >
void Vvtvp (int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 vvtvp (vector times vector plus vector): z = w*x + y More...
 
template<class T >
void Vvtvp (int n, const Array< TwoD, NekDouble >::const_reference &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 Vvtvp (vector times vector plus vector): z = w*x + y. More...
 
template<class T >
void Vvtvm (int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 vvtvm (vector times vector minus vector): z = w*x - y More...
 
template<class T >
void Svtvp (int n, const T alpha, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 svtvp (scalar times vector plus vector): z = alpha*x + y More...
 
template<class T >
void Svtvm (int n, const T alpha, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 svtvm (scalar times vector minus vector): z = alpha*x - y More...
 
template<class T >
void Vvtvvtp (int n, const Array< OneD, const T > &v, int incv, const Array< OneD, const T > &w, int incw, const Array< OneD, const T > &x, int incx, const Array< OneD, const T > &y, int incy, Array< OneD, T > &z, int incz)
 vvtvvtp (vector times vector plus vector times vector): z = v*w + x*y More...
 
template<class T >
void Vvtvvtm (int n, const Array< OneD, const T > &v, int incv, const Array< OneD, const T > &w, int incw, const Array< OneD, const T > &x, int incx, const Array< OneD, const T > &y, int incy, Array< OneD, T > &z, int incz)
 vvtvvtm (vector times vector minus vector times vector): z = v*w - x*y More...
 
template<class T >
void Svtsvtp (int n, const T alpha, const Array< OneD, const T > &x, const int incx, const T beta, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
 svtsvtp (scalar times vector plus scalar times vector): z = alpha*x + beta*y More...
 
template<class T , class I , typename = typename std::enable_if<std::is_floating_point<T>::value && std::is_integral<I>::value>::type>
void Gathr (I n, const Array< OneD, const T > &x, const Array< OneD, I > &y, Array< OneD, T > &z)
 Gather vector z[i] = x[y[i]]. More...
 
template<class T >
void Scatr (int n, const Array< OneD, const T > &x, const Array< OneD, const int > &y, Array< OneD, T > &z)
 Scatter vector z[y[i]] = x[i]. More...
 
template<class T >
void Assmb (int n, const Array< OneD, T > &x, const Array< OneD, int > &y, Array< OneD, T > &z)
 Assemble z[y[i]] += x[i]; z should be zero'd first. More...
 
template<class T >
T Vsum (int n, const Array< OneD, const T > &x, const int incx)
 Subtract return sum(x) More...
 
template<class T >
int Imax (int n, const Array< OneD, const T > &x, const int incx)
 Return the index of the maximum element in x. More...
 
template<class T >
T Vmax (int n, const Array< OneD, const T > &x, const int incx)
 Return the maximum element in x – called vmax to avoid conflict with max. More...
 
template<class T >
int Iamax (int n, const Array< OneD, const T > &x, const int incx)
 Return the index of the maximum absolute element in x. More...
 
template<class T >
T Vamax (int n, const Array< OneD, const T > &x, const int incx)
 Return the maximum absolute element in x called vamax to avoid conflict with max. More...
 
template<class T >
int Imin (int n, const Array< OneD, const T > &x, const int incx)
 Return the index of the minimum element in x. More...
 
template<class T >
T Vmin (int n, const Array< OneD, const T > &x, const int incx)
 Return the minimum element in x - called vmin to avoid conflict with min. More...
 
template<class T >
int Nnan (int n, const Array< OneD, const T > &x, const int incx)
 Return number of NaN elements of x. More...
 
template<class T >
T Dot (int n, const Array< OneD, const T > &w, const Array< OneD, const T > &x)
 dot product More...
 
template<class T >
T Dot (int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx)
 dot product More...
 
template<class T >
T Dot2 (int n, const Array< OneD, const T > &w, const Array< OneD, const T > &x, const Array< OneD, const int > &y)
 dot product More...
 
template<class T >
T Ddot (int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const int > &y, const int incy)
 dot product More...
 
template<class T >
void Vcopy (int n, const Array< OneD, const T > &x, int incx, Array< OneD, T > &y, int const incy)
 
template<class T >
void Reverse (int n, const Array< OneD, const T > &x, int incx, Array< OneD, T > &y, int const incy)
 

Function Documentation

◆ Assmb() [1/4]

template<class T >
void Vmath::Assmb ( int  n,
const Array< OneD, T > &  x,
const Array< OneD, int > &  y,
Array< OneD, T > &  z 
)

Assemble z[y[i]] += x[i]; z should be zero'd first.

Definition at line 460 of file VmathArray.hpp.

462{
463 ASSERTL1(n <= x.size() + x.GetOffset(), "Array out of bounds");
464 ASSERTL1(n <= y.size() + y.GetOffset(), "Array out of bounds");
465
466 Assmb(n, &x[0], &y[0], &z[0]);
467}
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
Nektar::UnitTests::z
std::vector< double > z(NPUPPER)
Vmath::Assmb
void Assmb(int n, const Array< OneD, T > &x, const Array< OneD, int > &y, Array< OneD, T > &z)
Assemble z[y[i]] += x[i]; z should be zero'd first.
Definition: VmathArray.hpp:460

References ASSERTL1, Assmb(), and Nektar::UnitTests::z().

◆ Assmb() [2/4]

template<class T >
void Vmath::Assmb ( int  n,
const T *  sign,
const T *  x,
const int *  y,
T *  z 
)
inline

Assemble z[y[i]] += sign[i]*x[i]; z should be zero'd first.

Definition at line 597 of file Vmath.hpp.

598{
599 while (n--)
600 {
601 *(z + *(y++)) += *(sign++) * (*(x++));
602 }
603}
sign
#define sign(a, b)
return the sign(b)*a
Definition: Polylib.cpp:47

References sign, and Nektar::UnitTests::z().

◆ Assmb() [3/4]

template<class T >
void Vmath::Assmb ( int  n,
const T *  x,
const int *  y,
T *  z 
)
inline

Assemble z[y[i]] += x[i]; z should be zero'd first.

Definition at line 577 of file Vmath.hpp.

578{
579 while (n--)
580 {
581 *(z + *(y++)) += *(x++);
582 }
583}

References Nektar::UnitTests::z().

Referenced by Nektar::MultiRegions::LocTraceToTraceMap::AddLocTracesToField(), Nektar::MultiRegions::AssemblyMap::AssembleBnd(), Assmb(), Nektar::MultiRegions::AssemblyMap::PatchAssemble(), Nektar::MultiRegions::AssemblyMap::PrintStats(), Nektar::MultiRegions::AssemblyMapCG::v_Assemble(), and Nektar::MultiRegions::PreconditionerLowEnergy::v_BuildPreconditioner().

◆ Assmb() [4/4]

template<class T >
void Vmath::Assmb ( int  n,
const T  sign,
const T *  x,
const int *  y,
T *  z 
)
inline

Assemble z[y[i]] += sign*x[i]; z should be zero'd first.

Definition at line 587 of file Vmath.hpp.

588{
589 while (n--)
590 {
591 *(z + *(y++)) += sign * (*(x++));
592 }
593}

References sign, and Nektar::UnitTests::z().

◆ Ddot()

template<class T >
T Vmath::Ddot ( int  n,
const Array< OneD, const T > &  w,
const int  incw,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const int > &  y,
const int  incy 
)

dot product

Definition at line 577 of file VmathArray.hpp.

580{
581 ASSERTL1(n * incw <= w.size() + w.GetOffset(), "Array out of bounds");
582 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
583 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
584
585 return Dot2(n, &w[0], incw, &x[0], incx, &y[0], incy);
586}
Nektar::UnitTests::w
std::vector< double > w(NPUPPER)
Vmath::Dot2
T Dot2(int n, const Array< OneD, const T > &w, const Array< OneD, const T > &x, const Array< OneD, const int > &y)
dot product
Definition: VmathArray.hpp:565

References ASSERTL1, Dot2(), and Nektar::UnitTests::w().

◆ Dot() [1/4]

template<class T >
T Vmath::Dot ( int  n,
const Array< OneD, const T > &  w,
const Array< OneD, const T > &  x 
)

dot product

Definition at line 544 of file VmathArray.hpp.

545{
546 ASSERTL1(n <= w.size() + w.GetOffset(), "Array out of bounds");
547 ASSERTL1(n <= x.size() + x.GetOffset(), "Array out of bounds");
548
549 return Dot(n, &w[0], &x[0]);
550}
Vmath::Dot
T Dot(int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx)
dot product
Definition: VmathArray.hpp:554

References ASSERTL1, Dot(), and Nektar::UnitTests::w().

◆ Dot() [2/4]

template<class T >
T Vmath::Dot ( int  n,
const Array< OneD, const T > &  w,
const int  incw,
const Array< OneD, const T > &  x,
const int  incx 
)

dot product

Definition at line 554 of file VmathArray.hpp.

556{
557 ASSERTL1(n * incw <= w.size() + w.GetOffset(), "Array out of bounds");
558 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
559
560 return Dot(n, &w[0], incw, &x[0], incx);
561}

References ASSERTL1, Dot(), and Nektar::UnitTests::w().

◆ Dot() [3/4]

template<class T >
T Vmath::Dot ( int  n,
const T *  w,
const int  incw,
const T *  x,
const int  incx 
)
inline

dot product

Definition at line 776 of file Vmath.hpp.

777{
778 T sum = 0;
779
780 while (n--)
781 {
782 sum += (*w) * (*x);
783 w += incw;
784 x += incx;
785 }
786 return sum;
787}

References Nektar::UnitTests::w().

◆ Dot() [4/4]

template<class T >
T Vmath::Dot ( int  n,
const T *  w,
const T *  x 
)
inline

dot product

Definition at line 761 of file Vmath.hpp.

762{
763 T sum = 0;
764
765 while (n--)
766 {
767 sum += (*w) * (*x);
768 ++w;
769 ++x;
770 }
771 return sum;
772}

References Nektar::UnitTests::w().

Referenced by Nektar::StdRegions::StdExpansion::BaryEvaluate(), Nektar::FieldUtils::ProcessWallNormalData::BndElmtContainsPoint(), Nektar::CFSImplicit::CalcRefValues(), Nektar::FieldUtils::ProcessPhiFromFile::CheckHit(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Dot(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_small(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_test(), Nektar::FieldUtils::ProcessPhiFromFile::FindShortestDist(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GenPntwiseBodyFittedCoordSys(), Nektar::VariableConverter::GetSensor(), Nektar::FieldUtils::ProcessWallNormalData::isInProjectedArea2D(), Nektar::FieldUtils::ProcessWallNormalData::isInProjectedArea3D(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::SpatialDomains::Geometry3D::NewtonIterationForLocCoord(), Nektar::FieldUtils::ProcessWallNormalData::ProjectPoint(), Nektar::FieldUtils::ProcessWallNormalData::ProjectVertices(), Nektar::LibUtilities::NekLinSysIter::Set_Rhs_Magnitude(), Nektar::LibUtilities::NekSys::v_ConvergenceCheck(), Nektar::LibUtilities::NekNonlinSysNewton::v_ConvergenceCheck(), Nektar::FieldUtils::ProcessBodyFittedVelocity::v_Process(), Nektar::FieldUtils::ProcessWallNormalData::v_Process(), and Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge().

◆ Dot2() [1/3]

template<class T >
T Vmath::Dot2 ( int  n,
const Array< OneD, const T > &  w,
const Array< OneD, const T > &  x,
const Array< OneD, const int > &  y 
)

dot product

Definition at line 565 of file VmathArray.hpp.

567{
568 ASSERTL1(n <= w.size() + w.GetOffset(), "Array out of bounds");
569 ASSERTL1(n <= x.size() + x.GetOffset(), "Array out of bounds");
570 ASSERTL1(n <= y.size() + y.GetOffset(), "Array out of bounds");
571
572 return Dot2(n, &w[0], &x[0], &y[0]);
573}

References ASSERTL1, Dot2(), and Nektar::UnitTests::w().

◆ Dot2() [2/3]

template<class T >
T Vmath::Dot2 ( int  n,
const T *  w,
const int  incw,
const T *  x,
const int  incx,
const int *  y,
const int  incy 
)
inline

dot product

Definition at line 806 of file Vmath.hpp.

808{
809 T sum = 0;
810
811 while (n--)
812 {
813 sum += (*y == 1 ? (*w) * (*x) : 0.0);
814 w += incw;
815 x += incx;
816 y += incy;
817 }
818 return sum;
819}

References Nektar::UnitTests::w().

◆ Dot2() [3/3]

template<class T >
T Vmath::Dot2 ( int  n,
const T *  w,
const T *  x,
const int *  y 
)
inline

dot product

Definition at line 790 of file Vmath.hpp.

791{
792 T sum = 0;
793
794 while (n--)
795 {
796 sum += (*y == 1 ? (*w) * (*x) : 0);
797 ++w;
798 ++x;
799 ++y;
800 }
801 return sum;
802}

References Nektar::UnitTests::w().

Referenced by Ddot(), Nektar::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::MultiRegions::GlobalLinSysIterative::DoProjection(), Dot2(), Nektar::LibUtilities::NekLinSysIter::Set_Rhs_Magnitude(), Nektar::MultiRegions::GlobalLinSysIterative::UpdateKnownSolutions(), and Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_PreSolve().

◆ Fill() [1/2]

template<class T >
void Vmath::Fill ( int  n,
const T  alpha,
Array< OneD, T > &  x,
const int  incx 
)

Fill a vector with a constant value.

Definition at line 49 of file VmathArray.hpp.

50{
51
52 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Out of bounds");
53
54 Fill(n, alpha, &x[0], incx);
55}
Vmath::Fill
void Fill(int n, const T alpha, Array< OneD, T > &x, const int incx)
Fill a vector with a constant value.
Definition: VmathArray.hpp:49

References ASSERTL1, and Fill().

◆ Fill() [2/2]

template<class T >
void Vmath::Fill ( int  n,
const T  alpha,
T *  x,
const int  incx 
)
inline

Fill a vector with a constant value.

Definition at line 54 of file Vmath.hpp.

55{
56 while (n--)
57 {
58 *x = alpha;
59 x += incx;
60 }
61}

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::SpatialDomains::GeomFactors::Adjoint(), Nektar::SolverUtils::AdvectionWeakDG::AdvectCoeffs(), Nektar::SolverUtils::RiemannSolver::CalcFluxJacobian(), Nektar::VortexWaveInteraction::CalcL2ToLinfPressure(), Nektar::MultiRegions::LocTraceToTraceMap::CalcLocTracePhysToTraceIDMap_2D(), Nektar::MultiRegions::LocTraceToTraceMap::CalcLocTracePhysToTraceIDMap_3D(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames(), Nektar::SpatialDomains::GeomFactors::ComputePrincipleDirection(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::MMFSWE::EvaluateWaterDepth(), Fill(), Nektar::CFSImplicit::Fill1DArrayOfBlkDiagonalMat(), Nektar::NavierStokesCFE::GetDivCurlFromDvelT(), Nektar::Collections::CoalescedGeomData::GetJacWithStdWeights(), Nektar::FieldUtils::ProcessQualityMetric::GetQ(), Nektar::VariableConverter::GetSensor(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), main(), Nektar::SolverUtils::DriverArnoldi::MaskInit(), Nektar::PreconCfsBRJ::MinusOffDiag2Rhs(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::NekMatrix< DataType, StandardMatrixTag >::operator=(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrder(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::LocalRegions::HexExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::QuadExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TriExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::LocalRegions::SegExp::v_ComputeTraceNormal(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MultiRegions::DisContField::v_EvaluateBoundaryConditions(), Nektar::MultiRegions::DisContField::v_FillBwdWithBwdWeight(), Nektar::StdRegions::StdTriExp::v_FillMode(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::StdRegions::StdQuadExp::v_GetCoords(), Nektar::StdRegions::StdTriExp::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_GetCoords(), Nektar::IncNavierStokes::v_GetDensity(), Nektar::SolverUtils::FileSolution::v_GetDensity(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctn(), Nektar::GlobalMapping::MappingTranslation::v_GetJacobian(), Nektar::GlobalMapping::MappingXofZ::v_GetJacobian(), Nektar::GlobalMapping::MappingXYofZ::v_GetJacobian(), Nektar::MMFDiffusion::v_InitObject(), Nektar::DiffusionLDGNS::v_InitObject(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::FieldUtils::ProcessAddCompositeID::v_Process(), Nektar::FieldUtils::ProcessCFL::v_Process(), Nektar::FieldUtils::ProcessJacobianEnergy::v_Process(), Nektar::FieldUtils::ProcessNumModes::v_Process(), Nektar::FieldUtils::ProcessPowerSpectrum::v_Process(), Nektar::CellModelAlievPanfilov::v_SetInitialConditions(), Nektar::CourtemancheRamirezNattel98::v_SetInitialConditions(), Nektar::FentonKarma::v_SetInitialConditions(), Nektar::CellModelFitzHughNagumo::v_SetInitialConditions(), Nektar::Fox02::v_SetInitialConditions(), Nektar::LuoRudy91::v_SetInitialConditions(), Nektar::TenTusscher06::v_SetInitialConditions(), Nektar::Winslow99::v_SetInitialConditions(), Nektar::LocalRegions::HexExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PrismExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PyrExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::QuadExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TetExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TriExp::v_SVVLaplacianFilter(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteVtkPieceHeader(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_WriteVtkPieceHeader(), and Nektar::AcousticSystem::WhiteNoiseBC().

◆ FillWhiteNoise() [1/4]

template void Vmath::FillWhiteNoise ( int  n,
const Nektar::NekDouble  eps,
Nektar::NekDouble *  x,
const int  incx,
int  outseed 
)

◆ FillWhiteNoise() [2/4]

template void Vmath::FillWhiteNoise ( int  n,
const Nektar::NekSingle  eps,
Nektar::NekSingle *  x,
const int  incx,
int  outseed 
)

◆ FillWhiteNoise() [3/4]

template<class T >
void Vmath::FillWhiteNoise ( int  n,
const T  eps,
Array< OneD, T > &  x,
const int  incx,
int  outseed = 9999 
)

Definition at line 58 of file VmathArray.hpp.

60{
61 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Out of bounds");
62
63 FillWhiteNoise(n, eps, &x[0], incx, outseed);
64}
Vmath::FillWhiteNoise
void FillWhiteNoise(int n, const T eps, Array< OneD, T > &x, const int incx, int outseed=9999)
Definition: VmathArray.hpp:58

References ASSERTL1, and FillWhiteNoise().

◆ FillWhiteNoise() [4/4]

template<class T >
void Vmath::FillWhiteNoise ( int  n,
const T  eps,
T *  x,
const int  incx,
int  outseed 
)

Fills a vector with white noise.

Definition at line 154 of file Vmath.cpp.

155{
156#ifdef NEKTAR_USE_THREAD_SAFETY
157 // Protect the static vars here and in ran2
158 std::scoped_lock l(mutex);
159#endif
160
161 // Define static variables for generating random numbers
162 static int iset = 0;
163 static T gset;
164 static long seed = 0;
165
166 // Bypass seed if outseed was specified
167 if (outseed != 9999)
168 {
169 seed = long(outseed);
170 }
171
172 while (n--)
173 {
174 T fac, rsq, v1, v2;
175
176 if (iset == 0)
177 {
178 do
179 {
180 v1 = 2.0 * ran2<T>(&seed) - 1.0;
181 v2 = 2.0 * ran2<T>(&seed) - 1.0;
182 rsq = v1 * v1 + v2 * v2;
183 } while (rsq >= 1.0 || rsq == 0.0);
184 fac = sqrt(-2.0 * log(rsq) / rsq);
185 gset = v1 * fac;
186 iset = 1;
187 *x = eps * v2 * fac;
188 }
189 else
190 {
191 iset = 0;
192 *x = eps * gset;
193 }
194 x += incx;
195 }
196}
tinysimd::log
scalarT< T > log(scalarT< T > in)
Definition: scalar.hpp:303
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:294

References tinysimd::log(), and tinysimd::sqrt().

Referenced by FillWhiteNoise(), Nektar::SolverUtils::ForcingNoise::v_Apply(), Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute(), Nektar::SolverUtils::ForcingNoise::v_InitObject(), and Nektar::CompressibleFlowSystem::v_SetInitialConditions().

◆ Gathr() [1/4]

template<class T , class I , typename = typename std::enable_if<std::is_floating_point<T>::value && std::is_integral<I>::value>::type>
void Vmath::Gathr ( I  n,
const Array< OneD, const T > &  x,
const Array< OneD, I > &  y,
Array< OneD, T > &  z 
)

Gather vector z[i] = x[y[i]].

Definition at line 434 of file VmathArray.hpp.

436{
437 ASSERTL1(n <= y.size() + y.GetOffset(), "Array out of bounds");
438 ASSERTL1(n <= z.size() + z.GetOffset(), "Array out of bounds");
439
440#ifdef NEKTAR_ENABLE_SIMD_VMATH
441 SIMD::Gathr(n, &x[0], &y[0], &z[0]);
442#else
443 Gathr(n, &x[0], &y[0], &z[0]);
444#endif
445}
Vmath::Gathr
void Gathr(I n, const Array< OneD, const T > &x, const Array< OneD, I > &y, Array< OneD, T > &z)
Gather vector z[i] = x[y[i]].
Definition: VmathArray.hpp:434

References ASSERTL1, Vmath::SIMD::Gathr(), Gathr(), and Nektar::UnitTests::z().

◆ Gathr() [2/4]

template<class T , class I , typename = typename std::enable_if<std::is_floating_point<T>::value && std::is_integral<I>::value>::type>
void Vmath::Gathr ( I  n,
const T *  x,
const I *  y,
T *  z 
)
inline

Gather vector z[i] = x[y[i]].

Definition at line 507 of file Vmath.hpp.

508{
509 while (n--)
510 {
511 *z++ = *(x + *y++);
512 }
513 return;
514}

References Nektar::UnitTests::z().

Referenced by Nektar::MultiRegions::LocTraceToTraceMap::CalcLocTracePhysToTraceIDMap_2D(), Nektar::MultiRegions::LocTraceToTraceMap::CalcLocTracePhysToTraceIDMap_3D(), Nektar::MultiRegions::LocTraceToTraceMap::FwdLocTracesFromField(), Gathr(), Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd(), Nektar::MultiRegions::AssemblyMap::GlobalToLocalBndWithoutSign(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocEdgesToTraceTranspose(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocFacesToTraceTranspose(), Nektar::MultiRegions::LocTraceToTraceMap::InterpTraceToLocEdges(), Nektar::MultiRegions::LocTraceToTraceMap::InterpTraceToLocFaces(), Nektar::MultiRegions::LocTraceToTraceMap::InterpTraceToLocTrace(), Nektar::MultiRegions::AssemblyMap::LocalToLocalBnd(), Nektar::MultiRegions::AssemblyMap::LocalToLocalInt(), Nektar::MultiRegions::LocTraceToTraceMap::LocTracesFromField(), main(), Nektar::MultiRegions::AssemblyMap::PatchGlobalToLocal(), Nektar::MultiRegions::AllToAllV::PerformExchange(), Nektar::MultiRegions::NeighborAllToAllV::PerformExchange(), Nektar::MultiRegions::Pairwise::PerformExchange(), Nektar::MultiRegions::LocTraceToTraceMap::ReshuffleLocTracesForInterp(), Nektar::LocalRegions::Expansion3D::v_GetTracePhysVals(), and Nektar::MultiRegions::AssemblyMapCG::v_GlobalToLocal().

◆ Gathr() [3/4]

template<class T >
void Vmath::Gathr ( int  n,
const T *  sign,
const T *  x,
const int *  y,
T *  z 
)
inline

Gather vector z[i] = sign[i]*x[y[i]].

Definition at line 529 of file Vmath.hpp.

530{
531 while (n--)
532 {
533 *z++ = *(sign++) * (*(x + *y++));
534 }
535 return;
536}

References sign, and Nektar::UnitTests::z().

◆ Gathr() [4/4]

template<class T >
void Vmath::Gathr ( int  n,
const T  sign,
const T *  x,
const int *  y,
T *  z 
)
inline

Gather vector z[i] = sign*x[y[i]].

Definition at line 518 of file Vmath.hpp.

519{
520 while (n--)
521 {
522 *z++ = sign * (*(x + *y++));
523 }
524 return;
525}

References sign, and Nektar::UnitTests::z().

◆ Iamax() [1/2]

template<class T >
int Vmath::Iamax ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return the index of the maximum absolute element in x.

Definition at line 499 of file VmathArray.hpp.

500{
501 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
502
503 return Iamax(n, &x[0], incx);
504}
Vmath::Iamax
int Iamax(int n, const Array< OneD, const T > &x, const int incx)
Return the index of the maximum absolute element in x.
Definition: VmathArray.hpp:499

References ASSERTL1, and Iamax().

◆ Iamax() [2/2]

template<class T >
int Vmath::Iamax ( int  n,
const T *  x,
const int  incx 
)
inline

Return the index of the maximum absolute element in x.

Definition at line 662 of file Vmath.hpp.

663{
664
665 int i, indx = (n > 0) ? 0 : -1;
666 T xmax = *x;
667 T xm;
668
669 for (i = 0; i < n; i++)
670 {
671 xm = (*x > 0) ? *x : -*x;
672 if (xm > xmax)
673 {
674 xmax = xm;
675 indx = i;
676 }
677 x += incx;
678 }
679
680 return indx;
681}

Referenced by Iamax().

◆ Imax() [1/2]

template<class T >
int Vmath::Imax ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return the index of the maximum element in x.

Definition at line 481 of file VmathArray.hpp.

482{
483 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
484
485 return Imax(n, &x[0], incx);
486}
Vmath::Imax
int Imax(int n, const Array< OneD, const T > &x, const int incx)
Return the index of the maximum element in x.
Definition: VmathArray.hpp:481

References ASSERTL1, and Imax().

◆ Imax() [2/2]

template<class T >
int Vmath::Imax ( int  n,
const T *  x,
const int  incx 
)
inline

Return the index of the maximum element in x.

Definition at line 623 of file Vmath.hpp.

624{
625
626 int i, indx = (n > 0) ? 0 : -1;
627 T xmax = *x;
628
629 for (i = 0; i < n; i++)
630 {
631 if (*x > xmax)
632 {
633 xmax = *x;
634 indx = i;
635 }
636 x += incx;
637 }
638
639 return indx;
640}

Referenced by Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), Nektar::SolverUtils::AdvectionSystem::GetCFLEstimate(), Imax(), main(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), and Nektar::FieldUtils::ProcessInterpPointDataToFld::v_Process().

◆ Imin() [1/2]

template<class T >
int Vmath::Imin ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return the index of the minimum element in x.

Definition at line 517 of file VmathArray.hpp.

518{
519 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
520
521 return Imin(n, &x[0], incx);
522}
Vmath::Imin
int Imin(int n, const Array< OneD, const T > &x, const int incx)
Return the index of the minimum element in x.
Definition: VmathArray.hpp:517

References ASSERTL1, and Imin().

◆ Imin() [2/2]

template<class T >
int Vmath::Imin ( int  n,
const T *  x,
const int  incx 
)
inline

Return the index of the minimum element in x.

Definition at line 704 of file Vmath.hpp.

705{
706
707 int i, indx = (n > 0) ? 0 : -1;
708 T xmin = *x;
709
710 for (i = 0; i < n; i++)
711 {
712 if (*x < xmin)
713 {
714 xmin = *x;
715 indx = i;
716 }
717 x += incx;
718 }
719
720 return indx;
721}

Referenced by DetermineclosePointxindex(), Nektar::PulseWaveSystem::GetCommArray(), Imin(), MappingEVids(), MoveOutsidePointsNnormpos(), Orderfunctionx(), Nektar::Collections::CollectionOptimisation::SetWithTimings(), Nektar::VortexWaveInteraction::UpdateAlpha(), Nektar::VortexWaveInteraction::UpdateWaveForceMag(), Nektar::SpatialDomains::Geometry3D::v_GetLocCoords(), and Nektar::FieldUtils::ProcessInterpPointDataToFld::v_Process().

◆ Neg() [1/2]

template<class T >
void Vmath::Neg ( int  n,
Array< OneD, T > &  x,
const int  incx 
)

Negate x = -x.

Definition at line 210 of file VmathArray.hpp.

211{
212 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
213
214 Neg(n, &x[0], incx);
215}
Vmath::Neg
void Neg(int n, Array< OneD, T > &x, const int incx)
Negate x = -x.
Definition: VmathArray.hpp:210

References ASSERTL1, and Neg().

◆ Neg() [2/2]

template<class T >
void Vmath::Neg ( int  n,
T *  x,
const int  incx 
)
inline

Negate x = -x.

Definition at line 292 of file Vmath.hpp.

293{
294 while (n--)
295 {
296 *x = -(*x);
297 x += incx;
298 }
299}

Referenced by Nektar::MMFMaxwell::AddCoriolis(), Nektar::MMFSWE::AddCoriolis(), Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::MMFSWE::AddDivForGradient(), Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::MMFMaxwell::AddPML(), Nektar::MMFSWE::AddRotation(), Nektar::SolverUtils::AdvectionWeakDG::AdvectCoeffs(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames(), Nektar::MMFSWE::ComputeVorticity(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D_Gauss(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyInviscidBurgers::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::PulseWavePropagation::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GenPntwiseBodyFittedCoordSys(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), Nektar::MultiRegions::ContField::LaplaceSolve(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Neg(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::IncNavierStokes::SetZeroNormalVelocity(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvection(), Nektar::SubSteppingExtrapolate::SubStepAdvection(), Nektar::LocalRegions::Expansion2D::v_AddEdgeNormBoundaryInt(), Nektar::AdjointAdvection::v_Advect(), Nektar::LinearisedAdvection::v_Advect(), Nektar::NavierStokesAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::WallViscousBC::v_Apply(), Nektar::MultiRegions::ExpList::v_CurlCurl(), Nektar::LocalRegions::Expansion2D::v_DGDeriv(), Nektar::LocalRegions::Expansion3D::v_DGDeriv(), Nektar::SolverUtils::DiffusionLDG::v_DiffuseCalcDerivative(), Nektar::DiffusionLDGNS::v_DiffuseCalcDerivative(), Nektar::SolverUtils::DiffusionLDG::v_DiffuseCoeffs(), Nektar::DiffusionLDGNS::v_DiffuseCoeffs(), Nektar::SolverUtils::DiffusionIP::v_DiffuseCoeffs(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::LocalRegions::Expansion1D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetInvMetricTensor(), Nektar::MultiRegions::ExpList::v_GetNormals(), Nektar::MultiRegions::ContField::v_HelmSolve(), Nektar::MultiRegions::DisContField::v_HelmSolve(), Nektar::MMFMaxwell::v_InitObject(), Nektar::ShallowWaterSystem::v_InitObject(), Nektar::ForcingQuasi1D::v_InitObject(), Nektar::MultiRegions::ContField::v_LinearAdvectionDiffusionReactionSolve(), Nektar::FieldUtils::ProcessWallNormalData::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), and Nektar::MMFSWE::WeakDGSWEDirDeriv().

◆ Nnan() [1/2]

template<class T >
int Vmath::Nnan ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return number of NaN elements of x.

Definition at line 535 of file VmathArray.hpp.

536{
537 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
538
539 return Nnan(n, &x[0], incx);
540}
Vmath::Nnan
int Nnan(int n, const Array< OneD, const T > &x, const int incx)
Return number of NaN elements of x.
Definition: VmathArray.hpp:535

References ASSERTL1, and Nnan().

◆ Nnan() [2/2]

template<class T >
int Vmath::Nnan ( int  n,
const T *  x,
const int  incx 
)
inline

Return number of NaN elements of x.

Definition at line 743 of file Vmath.hpp.

744{
745
746 int nNan = 0;
747
748 while (n--)
749 {
750 if (*x != *x)
751 {
752 nNan++;
753 }
754 x += incx;
755 }
756
757 return nNan;
758}

Referenced by Nnan(), and Nektar::SolverUtils::UnsteadySystem::v_DoSolve().

◆ ran2() [1/2]

template<class T >
T Vmath::ran2 ( long *  idum)

Generates a number from ~Normal(0,1)

Definition at line 56 of file Vmath.cpp.

64{
65 int j;
66 long k;
67 static long idum2 = 123456789;
68 static long iy = 0;
69 static long iv[NTAB];
70 T temp;
71
72 if (*idum <= 0)
73 {
74 if (-(*idum) < 1)
75 {
76 *idum = 1;
77 }
78 else
79 {
80 *idum = -(*idum);
81 }
82 idum2 = (*idum);
83 for (j = NTAB + 7; j >= 0; j--)
84 {
85 k = (*idum) / IQ1;
86 *idum = IA1 * (*idum - k * IQ1) - k * IR1;
87 if (*idum < 0)
88 {
89 *idum += IM1;
90 }
91 if (j < NTAB)
92 {
93 iv[j] = *idum;
94 }
95 }
96 iy = iv[0];
97 }
98
99 k = (*idum) / IQ1;
100 *idum = IA1 * (*idum - k * IQ1) - k * IR1;
101 if (*idum < 0)
102 {
103 *idum += IM1;
104 }
105
106 k = idum2 / IQ2;
107 idum2 = IA2 * (idum2 - k * IQ2) - k * IR2;
108 if (idum2 < 0)
109 {
110 idum2 += IM2;
111 }
112
113 j = iy / NDIV;
114 iy = iv[j] - idum2;
115 iv[j] = *idum;
116 if (iy < 1)
117 {
118 iy += IMM1;
119 }
120
121 if ((temp = AM * iy) > RNMX)
122 {
123 return RNMX;
124 }
125 else
126 {
127 return temp;
128 }
129}
NTAB
#define NTAB
Definition: Vmath.cpp:50
IA2
#define IA2
Definition: Vmath.cpp:45
IR2
#define IR2
Definition: Vmath.cpp:49
NDIV
#define NDIV
Definition: Vmath.cpp:51
IA1
#define IA1
Definition: Vmath.cpp:44
IM1
#define IM1
Definition: Vmath.cpp:40
IR1
#define IR1
Definition: Vmath.cpp:48
IMM1
#define IMM1
Definition: Vmath.cpp:43
IQ1
#define IQ1
Definition: Vmath.cpp:46
RNMX
#define RNMX
Definition: Vmath.cpp:53
IQ2
#define IQ2
Definition: Vmath.cpp:47
AM
#define AM
Definition: Vmath.cpp:42
IM2
#define IM2
Definition: Vmath.cpp:41

References AM, IA1, IA2, IM1, IM2, IMM1, IQ1, IQ2, IR1, IR2, NDIV, NTAB, and RNMX.

◆ ran2() [2/2]

template Nektar::NekDouble Vmath::ran2 ( long *  idum)

◆ Reverse() [1/2]

template<class T >
void Vmath::Reverse ( int  n,
const Array< OneD, const T > &  x,
int  incx,
Array< OneD, T > &  y,
int const  incy 
)

Definition at line 607 of file VmathArray.hpp.

609{
610 ASSERTL1(static_cast<unsigned int>(std::abs(n * incx)) <=
611 x.size() + x.GetOffset(),
612 "Array out of bounds");
613 ASSERTL1(static_cast<unsigned int>(std::abs(n * incy)) <=
614 y.size() + y.GetOffset(),
615 "Array out of bounds");
616
617 Reverse(n, &x[0], incx, &y[0], incy);
618}
Vmath::Reverse
void Reverse(int n, const Array< OneD, const T > &x, int incx, Array< OneD, T > &y, int const incy)
Definition: VmathArray.hpp:607
tinysimd::abs
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:298

References tinysimd::abs(), ASSERTL1, and Reverse().

◆ Reverse() [2/2]

template<class T >
void Vmath::Reverse ( int  n,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

Definition at line 844 of file Vmath.hpp.

845{
846 int i;
847 T store;
848
849 // Perform element by element swaps in case x and y reference the same
850 // array.
851 int nloop = n / 2;
852
853 // copy value in case of n is odd number
854 y[nloop] = x[nloop];
855
856 const T *x_end = x + (n - 1) * incx;
857 T *y_end = y + (n - 1) * incy;
858 for (i = 0; i < nloop; ++i)
859 {
860 store = *x_end;
861 *y_end = *x;
862 *y = store;
863 x += incx;
864 y += incy;
865 x_end -= incx;
866 y_end -= incy;
867 }
868}

Referenced by Nektar::SolverUtils::DiffusionLFR::DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D_Gauss(), Reverse(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_GetTracePhysVals(), Nektar::LocalRegions::TriExp::v_GetTracePhysVals(), Nektar::LocalRegions::QuadExp::v_GetTraceQFactors(), and Nektar::FieldUtils::ProcessSurfDistance::v_Process().

◆ Sadd() [1/2]

template<class T >
void Vmath::Sadd ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

Add vector y = alpha + x.

Definition at line 166 of file VmathArray.hpp.

168{
169
170 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
171 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
172
173 Sadd(n, alpha, &x[0], incx, &y[0], incy);
174}
Vmath::Sadd
void Sadd(int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
Add vector y = alpha + x.
Definition: VmathArray.hpp:166

References ASSERTL1, and Sadd().

◆ Sadd() [2/2]

template<class T >
void Vmath::Sadd ( int  n,
const T  alpha,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

Add vector y = alpha + x.

Definition at line 194 of file Vmath.hpp.

196{
197 ++n;
198 if (incx == 1 && incy == 1)
199 {
200 while (--n)
201 {
202 *y = alpha + (*x);
203 ++x;
204 ++y;
205 }
206 }
207 else
208 {
209 while (--n)
210 {
211 *y = alpha + (*x);
212 x += incx;
213 y += incy;
214 }
215 }
216}

Referenced by Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFSWE::ComputeEnergy(), DetermineclosePointxindex(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), main(), MoveOutsidePointsNnormpos(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Sadd(), Nektar::FieldUtils::ProcessEquiSpacedOutput::SetHomogeneousConnectivity(), Nektar::IncNavierStokes::SetMRFWallBCs(), Nektar::FilterMovingBody::UpdateForce(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::DriverArpack::v_Execute(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_GetCoords(), Nektar::GlobalMapping::MappingTranslation::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetInvMetricTensor(), Nektar::SpatialDomains::Geometry3D::v_GetLocCoords(), Nektar::GlobalMapping::MappingTranslation::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXofXZ::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetMetricTensor(), Nektar::FilterElectrogram::v_Initialise(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::SolverUtils::ForcingMovingReferenceFrame::v_InitObject(), Nektar::GlobalMapping::MappingXofXZ::v_LowerIndex(), Nektar::GlobalMapping::MappingXofZ::v_LowerIndex(), Nektar::SolverUtils::StatLagrangianPoints::v_OutputData(), Nektar::FieldUtils::OutputTecplot::v_OutputFromExp(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::SolverUtils::ForcingMovingReferenceFrame::v_PreApply(), Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofZ::v_RaiseIndex(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), and Nektar::CellModelFitzHughNagumo::v_Update().

◆ Scatr() [1/4]

template<class T >
void Vmath::Scatr ( int  n,
const Array< OneD, const T > &  x,
const Array< OneD, const int > &  y,
Array< OneD, T > &  z 
)

Scatter vector z[y[i]] = x[i].

Definition at line 449 of file VmathArray.hpp.

451{
452 ASSERTL1(n <= x.size() + x.GetOffset(), "Array out of bounds");
453 ASSERTL1(n <= y.size() + y.GetOffset(), "Array out of bounds");
454
455 Scatr(n, &x[0], &y[0], &z[0]);
456}
Vmath::Scatr
void Scatr(int n, const Array< OneD, const T > &x, const Array< OneD, const int > &y, Array< OneD, T > &z)
Scatter vector z[y[i]] = x[i].
Definition: VmathArray.hpp:449

References ASSERTL1, Scatr(), and Nektar::UnitTests::z().

◆ Scatr() [2/4]

template<class T >
void Vmath::Scatr ( int  n,
const T *  sign,
const T *  x,
const int *  y,
T *  z 
)
inline

Scatter vector z[y[i]] = sign[i]*x[i].

Definition at line 559 of file Vmath.hpp.

560{
561 while (n--)
562 {
563 if (*sign)
564 {
565 *(z + *(y++)) = *(sign++) * (*(x++));
566 }
567 else
568 {
569 x++;
570 y++;
571 sign++;
572 }
573 }
574}

References sign, and Nektar::UnitTests::z().

◆ Scatr() [3/4]

template<class T >
void Vmath::Scatr ( int  n,
const T *  x,
const int *  y,
T *  z 
)
inline

Scatter vector z[y[i]] = x[i].

Definition at line 539 of file Vmath.hpp.

540{
541 while (n--)
542 {
543 *(z + *(y++)) = *(x++);
544 }
545}

References Nektar::UnitTests::z().

Referenced by Nektar::MultiRegions::LocTraceToTraceMap::InterpLocEdgesToTrace(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocFacesToTrace(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocTracesToTrace(), Nektar::MultiRegions::AssemblyMap::LocalBndToGlobal(), Nektar::MultiRegions::AssemblyMap::LocalBndToLocal(), Nektar::MultiRegions::AssemblyMap::LocalIntToLocal(), Nektar::MultiRegions::AssemblyMap::PatchLocalToGlobal(), Nektar::MultiRegions::AllToAllV::PerformExchange(), Nektar::MultiRegions::NeighborAllToAllV::PerformExchange(), Nektar::MultiRegions::Pairwise::PerformExchange(), Scatr(), Nektar::MultiRegions::LocTraceToTraceMap::UnshuffleLocTraces(), Nektar::MultiRegions::ExpList::v_GetNormals(), Nektar::LocalRegions::Expansion3D::v_GetTracePhysVals(), and Nektar::MultiRegions::AssemblyMapCG::v_LocalToGlobal().

◆ Scatr() [4/4]

template<class T >
void Vmath::Scatr ( int  n,
const T  sign,
const T *  x,
const int *  y,
T *  z 
)
inline

Scatter vector z[y[i]] = sign*x[i].

Definition at line 549 of file Vmath.hpp.

550{
551 while (n--)
552 {
553 *(z + *(y++)) = sign * (*(x++));
554 }
555}

References sign, and Nektar::UnitTests::z().

◆ Sdiv() [1/2]

template<class T >
void Vmath::Sdiv ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

Scalar multiply y = alpha/x.

Definition at line 130 of file VmathArray.hpp.

132{
133 ASSERTL1(static_cast<unsigned int>(n * incx) <= x.size() + x.GetOffset(),
134 "Array out of bounds");
135 ASSERTL1(static_cast<unsigned int>(n * incy) <= y.size() + y.GetOffset(),
136 "Array out of bounds");
137
138 Sdiv(n, alpha, &x[0], incx, &y[0], incy);
139}
Vmath::Sdiv
void Sdiv(int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
Scalar multiply y = alpha/x.
Definition: VmathArray.hpp:130

References ASSERTL1, and Sdiv().

◆ Sdiv() [2/2]

template<class T >
void Vmath::Sdiv ( int  n,
const T  alpha,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

Scalar multiply y = alpha/x.

Definition at line 154 of file Vmath.hpp.

156{
157 ++n;
158 if (incx == 1 && incy == 1)
159 {
160 while (--n)
161 {
162 *y = alpha / (*x);
163 ++x;
164 ++y;
165 }
166 }
167 else
168 {
169 while (--n)
170 {
171 *y = alpha / (*x);
172 x += incx;
173 y += incy;
174 }
175 }
176}

Referenced by Nektar::MultiRegions::PreconditionerDiagonal::DiagonalPreconditionerSum(), main(), Sdiv(), Nektar::MultiRegions::PreconditionerDiagonal::StaticCondDiagonalPreconditionerSum(), Nektar::CellModel::TimeIntegrate(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::FilterElectrogram::v_Initialise(), Nektar::MultiRegions::PreconditionerLinearWithLowEnergy::v_InitObject(), Nektar::DiffusionLDGNS::v_InitObject(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), and Nektar::CourtemancheRamirezNattel98::v_Update().

◆ Smul() [1/2]

template<class T >
void Vmath::Smul ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

Scalar multiply y = alpha*x.

Definition at line 101 of file VmathArray.hpp.

103{
104 ASSERTL1(static_cast<unsigned int>(n * incx) <= x.size() + x.GetOffset(),
105 "Array out of bounds");
106 ASSERTL1(static_cast<unsigned int>(n * incy) <= y.size() + y.GetOffset(),
107 "Array out of bounds");
108
109 Smul(n, alpha, &x[0], incx, &y[0], incy);
110}
Vmath::Smul
void Smul(int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
Scalar multiply y = alpha*x.
Definition: VmathArray.hpp:101

References ASSERTL1, and Smul().

◆ Smul() [2/2]

template<class T >
void Vmath::Smul ( int  n,
const T  alpha,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

Scalar multiply y = alpha*x.

Definition at line 100 of file Vmath.hpp.

102{
103 ++n;
104 if (incx == 1 && incy == 1)
105 {
106 while (--n)
107 {
108 *y = alpha * (*x);
109 ++x;
110 ++y;
111 }
112 }
113 else
114 {
115 while (--n)
116 {
117 *y = alpha * (*x);
118 x += incx;
119 y += incy;
120 }
121 }
122}

Referenced by Nektar::MMFSWE::AddElevationEffect(), Nektar::VCSImplicit::AddImplicitSkewSymAdvection(), Nektar::Extrapolate::AddPressureToOutflowBCs(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::SpatialDomains::GeomFactors::Adjoint(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::LinearElasticSystem::BuildLaplacianIJMatrix(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::SolverUtils::DiffusionIP::CalcTraceSymFlux(), Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::LibUtilities::GaussPoints::CalculateGalerkinProjectionMatrix(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFSWE::ComputeEnergy(), Nektar::MMFSWE::ComputeEnstrophy(), Computestreakpositions(), Nektar::CoupledLinearNS::Continuation(), Nektar::SolverUtils::DiffusionLFR::DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFR::DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_1D(), Nektar::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Diffusion::DoImplicitSolve(), Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::Bidomain::DoImplicitSolve(), Nektar::BidomainRoth::DoImplicitSolve(), Nektar::Monodomain::DoImplicitSolve(), Nektar::MMFDiffusion::DoImplicitSolve(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_big(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_small(), Nektar::Extrapolate::EvaluateBDFArray(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::VortexWaveInteraction::ExecuteRoll(), Nektar::Extrapolate::ExtrapolateArray(), Nektar::VortexWaveInteraction::FileRelaxation(), Nektar::FieldUtils::ProcessPhiFromFile::FindShortestDist(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GenPntwiseBodyFittedCoordSys(), Nektar::MultiRegions::ExpList::GetDiagMatIpwrtBase(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::UnsteadyDiffusion::GetFluxVector(), Nektar::UnsteadyInviscidBurgers::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvectionDiffusion::GetFluxVectorDiff(), Nektar::UnsteadyViscousBurgers::GetFluxVectorDiff(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), Nektar::VariableConverter::GetMuAv(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp(), Nektar::MultiRegions::GJPStabilisation::GJPStabilisation(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::InitializeData(), Nektar::LocalRegions::NodalTriExp::Integral(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::FieldUtils::ProcessWallNormalData::isInProjectedArea2D(), Nektar::FieldUtils::ProcessWallNormalData::isInProjectedArea3D(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), main(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::SolverUtils::DiffusionLDG::NumFluxforVector(), Nektar::Collections::IProductWRTDerivBase_StdMat::operator()(), Nektar::Collections::IProductWRTDerivBase_IterPerExp::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Seg::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Quad::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tri::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Hex::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tet::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Prism::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Pyr::operator()(), Nektar::Collections::Helmholtz_IterPerExp::operator()(), Nektar::Collections::IProductWRTBase_StdMat::operator()(), Nektar::Collections::PhysDeriv_IterPerExp::operator()(), Nektar::Collections::PhysDeriv_SumFac_Seg::operator()(), Nektar::Collections::PhysDeriv_SumFac_Quad::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tri::operator()(), Nektar::Collections::PhysDeriv_SumFac_Hex::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tet::operator()(), Nektar::Collections::PhysDeriv_SumFac_Prism::operator()(), Nektar::Collections::PhysDeriv_SumFac_Pyr::operator()(), Nektar::SolverUtils::FilterFieldConvert::OutputField(), Nektar::LocalRegions::NodalTriExp::PhysDeriv(), Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::PrepareLocalSchurComplement(), Nektar::PressureMachTemperatureBC::PressureMachTemperatureBC(), Nektar::FieldUtils::ProcessWallNormalData::ProjectPoint(), Nektar::FieldUtils::ProcessWallNormalData::ProjectVertices(), Nektar::SolverUtils::CouplingCwipi::ReceiveCwipi(), Nektar::LibUtilities::NekFFTW::Reshuffle_Nek2FFTW(), Nektar::SolverUtils::DriverPFASST::Restrict(), Nektar::IncNavierStokes::SetMRFWallBCs(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::IncNavierStokes::SetWomersleyBoundary(), Smul(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), Nektar::SolverUtils::UnsteadySystem::SVVVarDiffCoeff(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::FilterMovingBody::UpdateForce(), Nektar::SmoothedProfileMethod::UpdateForcing(), Nektar::MultiRegions::GlobalLinSysIterative::UpdateKnownSolutions(), Nektar::Extrapolate::v_AccelerationBDF(), Nektar::StandardExtrapolate::v_AccelerationBDF(), Nektar::SubSteppingExtrapolate::v_AccelerationBDF(), Nektar::AlternateSkewAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::LocalRegions::HexExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::NodalTriExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PrismExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PyrExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::QuadExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::TetExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::TriExp::v_AlignVectorToCollapsedDir(), Nektar::SymmetryBC::v_Apply(), Nektar::WallBC::v_Apply(), Nektar::ForcingAxiSymmetric::v_Apply(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_ComputeInitialGuess(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_ComputeInitialGuess(), Nektar::LocalRegions::TriExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::SegExp::v_ComputeTraceNormal(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::MultiRegions::ExpList::v_CurlCurl(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::PreconCfsBRJ::v_DoPreconCfs(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute(), Nektar::StdRegions::StdHexExp::v_GenMatrix(), Nektar::StdRegions::StdPrismExp::v_GenMatrix(), Nektar::StdRegions::StdQuadExp::v_GenMatrix(), Nektar::StdRegions::StdTetExp::v_GenMatrix(), Nektar::StdRegions::StdTriExp::v_GenMatrix(), Nektar::NonSmoothShockCapture::v_GetArtificialViscosity(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_GetCoords(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::MultiRegions::ContField::v_HelmSolve(), Nektar::MultiRegions::DisContField::v_HelmSolve(), Nektar::SolverUtils::FilterFieldConvert::v_Initialise(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::MMFMaxwell::v_InitObject(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::LocalRegions::HexExp::v_Integral(), Nektar::LocalRegions::PrismExp::v_Integral(), Nektar::LocalRegions::PyrExp::v_Integral(), Nektar::LocalRegions::QuadExp::v_Integral(), Nektar::LocalRegions::SegExp::v_Integral(), Nektar::LocalRegions::TetExp::v_Integral(), Nektar::LocalRegions::TriExp::v_Integral(), Nektar::StdRegions::StdTriExp::v_Integral(), Nektar::LocalRegions::SegExp::v_IProductWRTBase(), Nektar::LocalRegions::SegExp::v_IProductWRTDerivBase(), Nektar::MultiRegions::ExpListHomogeneous1D::v_IProductWRTDerivBase(), Nektar::StdRegions::StdPrismExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdPyrExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdTriExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::TriExp::v_IProductWRTDirectionalDerivBase_SumFac(), Nektar::MultiRegions::ContField::v_LinearAdvectionDiffusionReactionSolve(), Nektar::SubSteppingExtrapolate::v_MountHOPBCs(), Nektar::WeakPressureExtrapolate::v_MountHOPBCs(), Nektar::StdRegions::StdHexExp::v_MultiplyByStdQuadratureMetric(), Nektar::LocalRegions::HexExp::v_PhysDeriv(), Nektar::LocalRegions::PrismExp::v_PhysDeriv(), Nektar::LocalRegions::PyrExp::v_PhysDeriv(), Nektar::LocalRegions::TetExp::v_PhysDeriv(), Nektar::MultiRegions::ExpListHomogeneous1D::v_PhysDeriv(), Nektar::MultiRegions::ExpListHomogeneous2D::v_PhysDeriv(), Nektar::StdRegions::StdPrismExp::v_PhysDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDeriv(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv_s(), Nektar::FieldUtils::ProcessAddFld::v_Process(), Nektar::FieldUtils::ProcessAverageFld::v_Process(), Nektar::FieldUtils::ProcessBodyFittedVelocity::v_Process(), Nektar::FieldUtils::ProcessC0Projection::v_Process(), Nektar::FieldUtils::ProcessCombineAvg::v_Process(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::FieldUtils::ProcessPowerSpectrum::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessScaleInFld::v_Process(), Nektar::FieldUtils::ProcessWallNormalData::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSWeakPressure::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::CellModelFitzHughNagumo::v_Update(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), Nektar::AcousticSystem::WallBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), and Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1().

◆ Ssub() [1/2]

template<class T >
void Vmath::Ssub ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

Add vector y = alpha - x.

Definition at line 191 of file VmathArray.hpp.

193{
194
195 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
196 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
197
198 Ssub(n, alpha, &x[0], incx, &y[0], incy);
199}
Vmath::Ssub
void Ssub(int n, const T alpha, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
Add vector y = alpha - x.
Definition: VmathArray.hpp:191

References ASSERTL1, and Ssub().

◆ Ssub() [2/2]

template<class T >
void Vmath::Ssub ( int  n,
const T  alpha,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

Substract vector y = alpha - x.

Definition at line 248 of file Vmath.hpp.

250{
251 ++n;
252 if (incx == 1 && incy == 1)
253 {
254 while (--n)
255 {
256 *y = alpha - (*x);
257 ++x;
258 ++y;
259 }
260 }
261 else
262 {
263 while (--n)
264 {
265 *y = alpha - (*x);
266 x += incx;
267 y += incy;
268 }
269 }
270}

Referenced by Ssub().

◆ Svtsvtp() [1/2]

template<class T >
void Vmath::Svtsvtp ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
const T  beta,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

svtsvtp (scalar times vector plus scalar times vector): z = alpha*x + beta*y

Definition at line 417 of file VmathArray.hpp.

420{
421 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
422 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
423 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
424
425 Svtsvtp(n, alpha, &x[0], incx, beta, &y[0], incy, &z[0], incz);
426}
Nektar::LibUtilities::beta
@ beta
Gauss Radau pinned at x=-1,.
Definition: PointsType.h:59
Vmath::Svtsvtp
void Svtsvtp(int n, const T alpha, const Array< OneD, const T > &x, const int incx, const T beta, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
svtsvtp (scalar times vector plus scalar times vector): z = alpha*x + beta*y
Definition: VmathArray.hpp:417

References ASSERTL1, Nektar::LibUtilities::beta, Svtsvtp(), and Nektar::UnitTests::z().

◆ Svtsvtp() [2/2]

template<class T >
void Vmath::Svtsvtp ( int  n,
const T  alpha,
const T *  x,
int  incx,
const T  beta,
const T *  y,
int  incy,
T *  z,
int  incz 
)
inline

Svtsvtp (scalar times vector plus scalar times vector):

Definition at line 473 of file Vmath.hpp.

475{
476 while (n--)
477 {
478 *z = alpha * (*x) + beta * (*y);
479 x += incx;
480 y += incy;
481 z += incz;
482 }
483}

References Nektar::LibUtilities::beta, and Nektar::UnitTests::z().

Referenced by Nektar::IncNavierStokes::SetMRFWallBCs(), Svtsvtp(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::NavierStokesCFE::v_GetFluxPenalty(), Nektar::DiffusionLDGNS::v_InitObject(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::QuadExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::TriExp::v_NormVectorIProductWRTBase(), Nektar::SolverUtils::FilterMovingAverage::v_ProcessSample(), Nektar::SolverUtils::FilterReynoldsStresses::v_ProcessSample(), Nektar::SolverUtils::CouplingCwipi::v_Receive(), Nektar::LibUtilities::TimeIntegrationSchemeGEM::v_TimeIntegrate(), Nektar::CourtemancheRamirezNattel98::v_Update(), and Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge().

◆ Svtvm() [1/2]

template<class T >
void Vmath::Svtvm ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

svtvm (scalar times vector minus vector): z = alpha*x - y

Definition at line 352 of file VmathArray.hpp.

355{
356 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
357 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
358 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
359
360 Svtvm(n, alpha, &x[0], incx, &y[0], incy, &z[0], incz);
361}
Vmath::Svtvm
void Svtvm(int n, const T alpha, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
svtvm (scalar times vector minus vector): z = alpha*x - y
Definition: VmathArray.hpp:352

References ASSERTL1, Svtvm(), and Nektar::UnitTests::z().

◆ Svtvm() [2/2]

template<class T >
void Vmath::Svtvm ( int  n,
const T  alpha,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

Svtvm (scalar times vector minus vector): z = alpha*x - y.

Definition at line 424 of file Vmath.hpp.

426{
427 while (n--)
428 {
429 *z = alpha * (*x) - (*y);
430 x += incx;
431 y += incy;
432 z += incz;
433 }
434}

References Nektar::UnitTests::z().

Referenced by Nektar::Extrapolate::CalcOutflowBCs(), Nektar::MMFDiffusion::DoOdeRhs(), Svtvm(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::SolverUtils::FilterReynoldsStresses::v_ProcessSample(), Nektar::SolverUtils::StatLagrangianPoints::v_TimeAdvance(), and Nektar::CourtemancheRamirezNattel98::v_Update().

◆ Svtvp() [1/2]

template<class T >
void Vmath::Svtvp ( int  n,
const T  alpha,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

svtvp (scalar times vector plus vector): z = alpha*x + y

Definition at line 339 of file VmathArray.hpp.

342{
343 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
344 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
345 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
346
347 Svtvp(n, alpha, &x[0], incx, &y[0], incy, &z[0], incz);
348}
Vmath::Svtvp
void Svtvp(int n, const T alpha, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: VmathArray.hpp:339

References ASSERTL1, Svtvp(), and Nektar::UnitTests::z().

◆ Svtvp() [2/2]

template<class T >
void Vmath::Svtvp ( int  n,
const T  alpha,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

Svtvp (scalar times vector plus vector): z = alpha*x + y.

Definition at line 396 of file Vmath.hpp.

398{
399 ++n;
400 if (incx == 1 && incy == 1 && incz == 1)
401 {
402 while (--n)
403 {
404 *z = alpha * (*x) + (*y);
405 ++x;
406 ++y;
407 ++z;
408 }
409 }
410 else
411 {
412 while (--n)
413 {
414 *z = alpha * (*x) + (*y);
415 x += incx;
416 y += incy;
417 z += incz;
418 }
419 }
420}

References Nektar::UnitTests::z().

Referenced by Nektar::Extrapolate::AddDuDt(), Nektar::SolverUtils::ForcingMovingReferenceFrame::addRotation(), Nektar::Extrapolate::AddVelBC(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::LocalRegions::Expansion::ComputeGmatcdotMF(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::SolverUtils::DriverSteadyState::ComputeSFD(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::LocalRegions::Expansion2D::CreateMatrix(), Nektar::LocalRegions::Expansion3D::CreateMatrix(), Nektar::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_big(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_small(), Nektar::Extrapolate::EvaluateBDFArray(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::Extrapolate::ExtrapolateArray(), Nektar::VortexWaveInteraction::FileRelaxation(), Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase(), Nektar::FieldUtils::ProcessCFL::GetMaxStdVelocity(), Nektar::Extrapolate::GetMaxStdVelocity(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocEdgesToTraceTranspose(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocFacesToTraceTranspose(), Nektar::SolverUtils::DriverPFASST::Interpolate(), Nektar::SolverUtils::FileFieldInterpolator::InterpolateField(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), main(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::CFSImplicit::NonlinSysEvaluatorCoeff(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM(), Nektar::SolverUtils::DiffusionLFR::NumFluxforScalar(), Nektar::SolverUtils::DiffusionLFR::NumFluxforVector(), Nektar::Collections::IProductWRTDerivBase_StdMat::operator()(), Nektar::Collections::IProductWRTDerivBase_IterPerExp::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Seg::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Quad::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tri::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Hex::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tet::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Prism::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Pyr::operator()(), Nektar::Collections::Helmholtz_IterPerExp::operator()(), Nektar::Collections::PhysDeriv_StdMat::operator()(), Nektar::Collections::PhysDeriv_IterPerExp::operator()(), Nektar::Collections::PhysDeriv_SumFac_Quad::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tri::operator()(), Nektar::Collections::PhysDeriv_SumFac_Hex::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tet::operator()(), Nektar::Collections::PhysDeriv_SumFac_Prism::operator()(), Nektar::Collections::PhysDeriv_SumFac_Pyr::operator()(), Nektar::SolverUtils::DriverPFASST::Restrict(), Nektar::RiemannInvariantBC::RiemannInvariantBC(), Nektar::IncNavierStokes::SetMRFDomainVelBCs(), Nektar::IncNavierStokes::SetMRFWallBCs(), Svtvp(), Nektar::CellModel::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::LinearisedAdvection::UpdateBase(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualQFint(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualSFint(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateLastQuadrature(), Nektar::Extrapolate::v_AccelerationBDF(), Nektar::StandardExtrapolate::v_AccelerationBDF(), Nektar::SubSteppingExtrapolate::v_AccelerationBDF(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), Nektar::SolverUtils::ForcingBody::v_Apply(), Nektar::SolverUtils::ForcingBody::v_ApplyCoeff(), Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC::v_ComputeInitialGuess(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_ComputeInitialGuess(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TriExp::v_ComputeLaplacianMetric(), Nektar::PreconCfsBRJ::v_DoPreconCfs(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::StdRegions::StdExpansion2D::v_HelmholtzMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion3D::v_HelmholtzMatrixOp_MatFree(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::StandardExtrapolate::v_MountHOPBCs(), Nektar::LocalRegions::QuadExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::TriExp::v_NormVectorIProductWRTBase(), Nektar::StdRegions::StdPrismExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDirectionalDeriv(), Nektar::FieldUtils::ProcessCombineAvg::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessScalGrad::v_Process(), Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::VCSImplicit::v_SetUpPressureForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::VelocityCorrectionScheme::v_SolveUnsteadyStokesSystem(), Nektar::SolverUtils::StatLagrangianPoints::v_TimeAdvance(), Nektar::LibUtilities::TimeIntegrationSchemeGEM::v_TimeIntegrate(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), and Nektar::CellModelFitzHughNagumo::v_Update().

◆ Vabs() [1/2]

template<class T >
void Vmath::Vabs ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

vabs: y = |x|

Definition at line 263 of file VmathArray.hpp.

265{
266 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
267 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
268
269 Vabs(n, &x[0], incx, &y[0], incy);
270}
Vmath::Vabs
void Vabs(int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
vabs: y = |x|
Definition: VmathArray.hpp:263

References ASSERTL1, and Vabs().

◆ Vabs() [2/2]

template<class T >
void Vmath::Vabs ( int  n,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

vabs: y = |x|

Definition at line 352 of file Vmath.hpp.

353{
354 while (n--)
355 {
356 *y = (*x > 0) ? *x : -(*x);
357 x += incx;
358 y += incy;
359 }
360}

Referenced by Nektar::SolverUtils::MMFSystem::AbsIntegral(), Nektar::SolverUtils::MMFSystem::AvgAbsInt(), Nektar::VelocityCorrectionScheme::ComputeGJPNormalVelocity(), DetermineclosePointxindex(), Nektar::StdRegions::StdExpansion::Linf(), Nektar::EnforceEntropyPressure::v_Apply(), Nektar::EnforceEntropyTotalEnthalpy::v_Apply(), Nektar::EnforceEntropyVelocity::v_Apply(), Nektar::PressureInflowFileBC::v_Apply(), Nektar::PressureOutflowBC::v_Apply(), Nektar::PressureOutflowNonReflectiveBC::v_Apply(), Nektar::RiemannInvariantBC::v_Apply(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::GlobalMapping::MappingXYofXY::v_GetJacobian(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::MMFSWE::v_L2Error(), and Vabs().

◆ Vadd() [1/2]

template<class T >
void Vmath::Vadd ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

Add vector z = x+y.

Definition at line 143 of file VmathArray.hpp.

146{
147 ASSERTL1(static_cast<unsigned int>(n * incx) <= x.size() + x.GetOffset(),
148 "Array out of bounds");
149 ASSERTL1(static_cast<unsigned int>(n * incy) <= y.size() + y.GetOffset(),
150 "Array out of bounds");
151 ASSERTL1(static_cast<unsigned int>(n * incz) <= z.size() + z.GetOffset(),
152 "Array out of bounds");
153
154#ifdef NEKTAR_ENABLE_SIMD_VMATH
155 ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
156 ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
157 ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
158 SIMD::Vadd(n, &x[0], &y[0], &z[0]);
159#else
160 Vadd(n, &x[0], incx, &y[0], incy, &z[0], incz);
161#endif
162}
Vmath::Vadd
void Vadd(int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
Add vector z = x+y.
Definition: VmathArray.hpp:143

References ASSERTL1, Vmath::SIMD::Vadd(), Vadd(), and Nektar::UnitTests::z().

◆ Vadd() [2/2]

template<class T >
void Vmath::Vadd ( int  n,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

Add vector z = x+y.

Definition at line 180 of file Vmath.hpp.

182{
183 while (n--)
184 {
185 *z = (*x) + (*y);
186 x += incx;
187 y += incy;
188 z += incz;
189 }
190}

References Nektar::UnitTests::z().

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::AbsMaxtoMinEigenValueRatio(), Nektar::MMFMaxwell::AddCoriolis(), Nektar::MMFSWE::AddCoriolis(), Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::MMFSWE::AddDivForGradient(), Nektar::MMFSWE::AddElevationEffect(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::AddFASCorrectionToSFint(), Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::VCSImplicit::AddImplicitSkewSymAdvection(), Nektar::MultiRegions::LocTraceToTraceMap::AddLocTracesToField(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::MMFMaxwell::AddPML(), Nektar::Extrapolate::AddPressureToOutflowBCs(), Nektar::MultiRegions::ExpList::AddRightIPTBaseMatrix(), Nektar::MultiRegions::ExpList::AddRightIPTPhysDerivBase(), Nektar::MMFSWE::AddRotation(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToCoeff(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToPhys(), Nektar::SolverUtils::Advection::AddTraceJacToMat(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::MultiRegions::PreconditionerBlock::BlockPreconditionerCG(), Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::PrismCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::PyrCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::QuadCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::SegCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::TetCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::TriCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::SolverUtils::DiffusionIP::CalcTraceNumFlux(), Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::MMFMaxwell::Checkpoint_TotalFieldOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF(), Nektar::MMFSWE::ComputeEnergy(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::SolverUtils::DriverPFASST::ComputeFASCorrection(), Nektar::MMFSWE::ComputeMass(), Computestreakpositions(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::ComputeTotalResidual(), Nektar::MMFSWE::ComputeVorticity(), Nektar::CoupledLinearNS::Continuation(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverParareal::CorrectionWithNewCoarseSolution(), Nektar::SolverUtils::DiffusionLFR::DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFR::DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_1D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D_Gauss(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Nektar::Bidomain::DoImplicitSolve(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MultiRegions::DisContField::EvaluateHDGPostProcessing(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::SolverUtils::DriverPFASST::EvaluateSDCResidualNorm(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GenPntwiseBodyFittedCoordSys(), Nektar::VariableConverter::GetEnthalpy(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase(), Nektar::VariableConverter::GetMuAv(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::SolverUtils::FilterLagrangianPoints::GetPhysicsData(), Nektar::MMFSWE::GetSWEFluxVector(), Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp(), Nektar::LocalRegions::NodalTriExp::IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree_GenericImpl(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), MoveOutsidePointsNnormpos(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::SolverUtils::DiffusionLFRNS::NumericalFluxO2(), Nektar::DiffusionLDGNS::NumericalFluxO2(), Nektar::SolverUtils::DiffusionLFR::NumFluxforVector(), Nektar::SolverUtils::DiffusionLDG::NumFluxforVector(), Nektar::Collections::IProductWRTDerivBase_IterPerExp::operator()(), Nektar::Collections::IProductWRTDerivBase_NoCollection::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Quad::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tri::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Hex::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tet::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Prism::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Pyr::operator()(), Nektar::Collections::Helmholtz_IterPerExp::operator()(), Nektar::PressureMachTemperatureBC::PressureMachTemperatureBC(), Nektar::LinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::PrimitiveToConservative(), Nektar::FieldUtils::ProcessWallNormalData::ProjectPoint(), Nektar::FieldUtils::ProcessWallNormalData::ProjectVertices(), Nektar::SmoothedProfileMethod::SetUpCorrectionPressure(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), Nektar::SmoothedProfileMethod::SolveCorrectedVelocity(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::FilterMovingBody::UpdateForce(), Nektar::GlobalMapping::UpdateGeometry(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::AdvectionFR::v_Advect(), Nektar::AlternateSkewAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::SolverUtils::Advection3DHomogeneous1D::v_Advect(), Nektar::LocalRegions::NodalTriExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PrismExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PyrExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::TriExp::v_AlignVectorToCollapsedDir(), Nektar::WallViscousBC::v_Apply(), Nektar::SolverUtils::ForcingAbsorption::v_Apply(), Nektar::SolverUtils::ForcingBody::v_Apply(), Nektar::SolverUtils::ForcingNoise::v_Apply(), Nektar::SolverUtils::ForcingProgrammatic::v_Apply(), Nektar::ForcingAxiSymmetric::v_Apply(), Nektar::ForcingQuasi1D::v_Apply(), Nektar::ForcingMovingBody::v_Apply(), Nektar::ForcingStabilityCoupledLNS::v_Apply(), Nektar::SolverUtils::ForcingAbsorption::v_ApplyCoeff(), Nektar::SolverUtils::ForcingBody::v_ApplyCoeff(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::GlobalMapping::MappingXofZ::v_ContravarToCartesian(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::GlobalMapping::MappingXofXZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::Mapping::v_CurlCurlField(), Nektar::MultiRegions::ExpListHomogeneous2D::v_DealiasedDotProd(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::SolverUtils::DiffusionLFRNS::v_Diffuse(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::ArtificialDiffusion::v_DoArtificialDiffusion(), Nektar::ArtificialDiffusion::v_DoArtificialDiffusionCoeff(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::NavierStokesCFEAxisym::v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), Nektar::MultiRegions::PreconditionerLinearWithLowEnergy::v_DoPreconditioner(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::NonSmoothShockCapture::v_GetArtificialViscosity(), Nektar::APE::v_GetFluxVector(), Nektar::LEE::v_GetFluxVector(), Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofXZ::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetMetricTensor(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::GlobalMapping::Mapping::v_gradgradU(), Nektar::Bidomain::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::MultiRegions::ExpListHomogeneous1D::v_IProductWRTDerivBase(), Nektar::LocalRegions::TetExp::v_IProductWRTDerivBase(), Nektar::LocalRegions::HexExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::PrismExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::PyrExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::QuadExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::TriExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdPrismExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdPyrExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdTriExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::HexExp::v_IProductWRTDirectionalDerivBase_SumFac(), Nektar::LocalRegions::TriExp::v_IProductWRTDirectionalDerivBase_SumFac(), Nektar::LocalRegions::HexExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::QuadExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::TriExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::MMFSWE::v_LinfError(), Nektar::GlobalMapping::MappingXofXZ::v_LowerIndex(), Nektar::GlobalMapping::MappingXofZ::v_LowerIndex(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv_n(), Nektar::SolverUtils::ForcingMovingReferenceFrame::v_PreApply(), Nektar::LinearSWE::v_PrimitiveToConservative(), Nektar::NonlinearPeregrine::v_PrimitiveToConservative(), Nektar::NonlinearSWE::v_PrimitiveToConservative(), Nektar::FieldUtils::ProcessAddFld::v_Process(), Nektar::FieldUtils::ProcessAverageFld::v_Process(), Nektar::FieldUtils::ProcessBodyFittedVelocity::v_Process(), Nektar::FieldUtils::ProcessCombineAvg::v_Process(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessVelocityDivergence::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::SolverUtils::FilterAverageFields::v_ProcessSample(), Nektar::SolverUtils::FilterBodyFittedVelocity::v_ProcessSample(), Nektar::LibUtilities::ExplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::MultiRegions::GlobalLinSysIterativeFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysPETScFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve(), Nektar::MultiRegions::GlobalLinSysXxtFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysDirectFull::v_Solve(), Nektar::VCSMapping::v_SolvePressure(), Nektar::SmoothedProfileMethod::v_SolveUnsteadyStokesSystem(), Nektar::VCSMapping::v_SolveViscous(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::SolverUtils::FilterModalEnergy::v_Update(), Nektar::GlobalMapping::Mapping::v_UpdateBCs(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), Vadd(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), Nektar::MMFSWE::WeakDGSWEDirDeriv(), Nektar::StdRegions::StdExpansion::WeakDirectionalDerivMatrixOp_MatFree(), and Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1().

◆ Vamax() [1/2]

template<class T >
T Vmath::Vamax ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return the maximum absolute element in x called vamax to avoid conflict with max.

Definition at line 508 of file VmathArray.hpp.

509{
510 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
511
512 return Vamax(n, &x[0], incx);
513}
Vmath::Vamax
T Vamax(int n, const Array< OneD, const T > &x, const int incx)
Return the maximum absolute element in x called vamax to avoid conflict with max.
Definition: VmathArray.hpp:508

References ASSERTL1, and Vamax().

◆ Vamax() [2/2]

template<class T >
T Vmath::Vamax ( int  n,
const T *  x,
const int  incx 
)
inline

Return the maximum absolute element in x called vamax to avoid conflict with max.

Definition at line 685 of file Vmath.hpp.

686{
687
688 T xmax = *x;
689 T xm;
690
691 while (n--)
692 {
693 xm = (*x > 0) ? *x : -*x;
694 if (xm > xmax)
695 {
696 xmax = xm;
697 }
698 x += incx;
699 }
700 return xmax;
701}

Referenced by Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::MMFSWE::LaxFriedrichFlux(), Nektar::StdRegions::StdExpansion::Linf(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MMFSWE::v_LinfError(), and Vamax().

◆ Vcopy() [1/2]

template<class T >
void Vmath::Vcopy ( int  n,
const Array< OneD, const T > &  x,
int  incx,
Array< OneD, T > &  y,
int const  incy 
)

Definition at line 592 of file VmathArray.hpp.

594{
595 ASSERTL1(static_cast<unsigned int>(std::abs(n * incx)) <=
596 x.size() + x.GetOffset(),
597 "Array out of bounds");
598 ASSERTL1(static_cast<unsigned int>(std::abs(n * incy)) <=
599 y.size() + y.GetOffset(),
600 "Array out of bounds");
601
602 Vcopy(n, &x[0], incx, &y[0], incy);
603}
Vmath::Vcopy
void Vcopy(int n, const Array< OneD, const T > &x, int incx, Array< OneD, T > &y, int const incy)
Definition: VmathArray.hpp:592

References tinysimd::abs(), ASSERTL1, and Vcopy().

◆ Vcopy() [2/2]

template<class T >
void Vmath::Vcopy ( int  n,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

Definition at line 825 of file Vmath.hpp.

826{
827 if (incx == 1 && incy == 1)
828 {
829 memcpy(y, x, n * sizeof(T));
830 }
831 else
832 {
833 while (n--)
834 {
835 *y = *x;
836 x += incx;
837 y += incy;
838 }
839 }
840}

Referenced by Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzTraceTerms(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::MultiRegions::ExpList::AddRightIPTBaseMatrix(), Nektar::MultiRegions::ExpList::AddRightIPTPhysDerivBase(), Nektar::SolverUtils::ForcingMovingReferenceFrame::addRotation(), Nektar::MultiRegions::ExpList::AddTraceJacToElmtJac(), Nektar::SolverUtils::Advection::AddTraceJacToMat(), Nektar::SpatialDomains::GeomFactors::Adjoint(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VariableConverter::ApplyC0Smooth(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::SolverUtils::DiffusionLDG::ApplyScalarBCs(), Nektar::SolverUtils::DriverParareal::ApplyWindowing(), Nektar::MultiRegions::AssemblyMap::AssembleBnd(), Nektar::HexCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::PrismCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::PyrCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::QuadCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::SegCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::TetCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::TriCollectionTests::BOOST_AUTO_TEST_CASE(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::SolverUtils::ForcingAbsorption::CalculateForcing(), Nektar::LibUtilities::NodalTriEvenlySpaced::CalculateInterpMatrix(), Nektar::LibUtilities::NodalTriFekete::CalculateInterpMatrix(), Nektar::LibUtilities::NodalPrismElec::CalculateInterpMatrix(), Nektar::LibUtilities::NodalPrismEvenlySpaced::CalculateInterpMatrix(), Nektar::LibUtilities::NodalTetEvenlySpaced::CalculateInterpMatrix(), Nektar::LibUtilities::NodalTriElec::CalculateInterpMatrix(), Nektar::LibUtilities::NodalTetElec::CalculateInterpMatrix(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::SolverUtils::MMFSystem::ComputeCurl(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF(), Nektar::SolverUtils::MMFSystem::ComputeMFtrace(), Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::MMFMaxwell::ComputeRadCloak(), Computestreakpositions(), Nektar::LinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::GlobalMapping::Mapping::ContravarFromCartesian(), Nektar::GlobalMapping::Mapping::ContravarToCartesian(), Nektar::SolverUtils::DriverArnoldi::CopyArnoldiArrayToField(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::AcousticSystem::CopyBoundaryTrace(), Nektar::ShallowWaterSystem::CopyBoundaryTrace(), Nektar::SolverUtils::DriverArnoldi::CopyFieldToArnoldiArray(), Nektar::SolverUtils::EquationSystem::CopyFromPhysField(), Nektar::SolverUtils::DriverArnoldi::CopyFwdToAdj(), Nektar::Extrapolate::CopyPressureHBCsToPbndExp(), Nektar::SolverUtils::DriverParallelInTime::CopySolutionVector(), Nektar::SolverUtils::EquationSystem::CopyToPhysField(), Nektar::GlobalMapping::Mapping::CovarFromCartesian(), Nektar::GlobalMapping::Mapping::CovarToCartesian(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::SolverUtils::DiffusionLFR::DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_1D(), Nektar::SolverUtils::MMFSystem::DeriveCrossProductMF(), DetermineclosePointxindex(), Nektar::LinearisedAdvection::DFT(), Nektar::SolverUtils::FileFieldInterpolator::DFT(), Nektar::SolverUtils::AdvectionFR::DivCFlux_1D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D_Gauss(), Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::SolverUtils::UnsteadySystem::DoDummyProjection(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Nektar::Bidomain::DoImplicitSolve(), Nektar::MultiRegions::GlobalLinSysPETSc::DoNekppOperation(), Nektar::LibUtilities::NekSysOperators::DoNekSysPrecon(), Nektar::PreconCfsBRJ::DoNullPrecon(), Nektar::AcousticSystem::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurgers::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::Dummy::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeProjection(), Nektar::PulseWavePropagation::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::MultiRegions::GlobalLinSysIterative::DoProjection(), Nektar::NekMatrix< DataType, StandardMatrixTag >::EigenSolve(), Nektar::CFSImplicit::ElmtVarInvMtrx(), Nektar::EnforceEntropyPressure::EnforceEntropyPressure(), Nektar::EnforceEntropyTotalEnthalpy::EnforceEntropyTotalEnthalpy(), Nektar::EnforceEntropyVelocity::EnforceEntropyVelocity(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_sort(), Nektar::SolverUtils::SessionFunction::Evaluate(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MultiRegions::DisContField::EvaluateHDGPostProcessing(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::VortexWaveInteraction::ExecuteRoll(), Nektar::VortexWaveInteraction::FileRelaxation(), Nektar::MultiRegions::DisContField::FillBwdWithBoundCond(), Nektar::MultiRegions::LocTraceToTraceMap::FindElmtNeighbors(), Nektar::SolverUtils::EvaluatePoints::GatherMobilePhysics(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::LocalRegions::NodalTriExp::GeneralMatrixOp_MatOp(), Nektar::LocalRegions::TetExp::GeneralMatrixOp_MatOp(), Nektar::MultiRegions::ExpList::GenerateElementVector(), GenerateNeighbourArrays(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GenPntwiseBodyFittedCoordSys(), Nektar::Collections::CoalescedGeomData::GetDerivFactors(), Nektar::MultiRegions::ExpList::GetExpIndex(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::CFSImplicit::GetFluxVectorJacDirElmt(), Nektar::Collections::CoalescedGeomData::GetJac(), Nektar::Collections::CoalescedGeomData::GetJacWithStdWeights(), Nektar::FieldUtils::ProcessMapping::GetMapping(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D(), Nektar::LocalRegions::Expansion::GetMF(), Nektar::FieldUtils::ProcessBodyFittedVelocity::GetVelAndConvertToCartSys(), Nektar::FieldUtils::ProcessCFL::GetVelocity(), Nektar::FieldUtils::ProcessVelocityDivergence::GetVelocity(), Nektar::FieldUtils::ProcessVorticity::GetVelocity(), Nektar::FieldUtils::ProcessWSS::GetVelocity(), Nektar::LinearSWE::GetVelocityVector(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd(), Nektar::StdRegions::StdExpansion::H1(), Nektar::Collections::HexIProduct(), Nektar::MultiRegions::ExpListHomogeneous1D::Homogeneous1DTrans(), Nektar::LinearisedAdvection::ImportFldBase(), Nektar::SolverUtils::FileFieldInterpolator::ImportFldBase(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::SolverUtils::UnsteadySystem::InitializeSteadyState(), Nektar::LibUtilities::Interp1D(), Nektar::LibUtilities::Interp2D(), Nektar::LibUtilities::InterpCoeff1D(), Nektar::LibUtilities::InterpCoeff2D(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocEdgesToTrace(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocEdgesToTraceTranspose(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocFacesToTrace(), Nektar::MultiRegions::LocTraceToTraceMap::InterpLocFacesToTraceTranspose(), Nektar::SolverUtils::DriverParallelInTime::Interpolate(), Nektar::SolverUtils::FileFieldInterpolator::InterpolateField(), Nektar::MultiRegions::LocTraceToTraceMap::InterpTraceToLocEdges(), Nektar::MultiRegions::LocTraceToTraceMap::InterpTraceToLocFaces(), Nektar::Collections::IProductWRTDerivBase_StdMat::IProductWRTDerivBase_StdMat(), Nektar::MultiRegions::ExpList::IProductWRTDirectionalDerivBase(), Nektar::MultiRegions::DisContField::L2_DGDeriv(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree_GenericImpl(), Nektar::MultiRegions::AssemblyMap::LocalBndToGlobal(), Nektar::GlobalMapping::Mapping::LowerIndex(), main(), MappingEVids(), Nektar::SolverUtils::MobilePoint::MobilePoint(), Nektar::MultiRegions::GlobalMatrix::Multiply(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::ForcingMovingBody::Newmark_betaSolver(), Nektar::SpatialDomains::Geometry3D::NewtonIterationForLocCoord(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::SolverUtils::DiffusionLFRNS::NumericalFluxO1(), Nektar::DiffusionLDGNS::NumericalFluxO2(), Nektar::SolverUtils::DiffusionLFR::NumFluxforScalar(), Nektar::SolverUtils::DiffusionLDG::NumFluxforScalar(), Nektar::SolverUtils::DiffusionLDG::NumFluxforVector(), Nektar::Collections::IProductWRTDerivBase_MatrixFree::operator()(), Nektar::Collections::IProductWRTBase_MatrixFree::operator()(), Nektar::Collections::BwdTrans_MatrixFree::operator()(), Nektar::Collections::Helmholtz_MatrixFree::operator()(), Nektar::Collections::PhysDeriv_MatrixFree::operator()(), Nektar::Collections::PhysInterp1DScaled_MatrixFree::operator()(), Nektar::Collections::BwdTrans_SumFac_Seg::operator()(), Nektar::Collections::BwdTrans_SumFac_Quad::operator()(), Nektar::Collections::BwdTrans_SumFac_Hex::operator()(), Orderfunctionx(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrder(), Nektar::Collections::PhysDeriv_StdMat::PhysDeriv_StdMat(), Nektar::LibUtilities::PhysGalerkinProject1D(), Nektar::LibUtilities::PhysGalerkinProject2D(), Nektar::StdRegions::StdExpansion2D::PhysTensorDeriv(), Nektar::StdRegions::StdExpansion3D::PhysTensorDeriv(), PolyFit(), PolyInterp(), Nektar::SpatialDomains::QuadGeom::PreSolveStraightEdge(), Nektar::PressureInflowFileBC::PressureInflowFileBC(), Nektar::PressureMachTemperatureBC::PressureMachTemperatureBC(), Nektar::PressureOutflowBC::PressureOutflowBC(), Nektar::PressureOutflowNonReflectiveBC::PressureOutflowNonReflectiveBC(), Nektar::LinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::PrimitiveToConservative(), Nektar::MMFMaxwell::Printout_SurfaceCurrent(), Nektar::FieldUtils::ProcessGrad::ProcessMappingFld(), Nektar::SolverUtils::DriverPFASST::PropagateQuadratureSolutionAndResidual(), Nektar::Collections::QuadIProduct(), Nektar::GlobalMapping::Mapping::RaiseIndex(), Nektar::MultiRegions::AssemblyMapDG::RealignTraceElement(), Nektar::LibUtilities::NekFFTW::Reshuffle_FFTW2Nek(), Nektar::LibUtilities::NekFFTW::Reshuffle_Nek2FFTW(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::SolverUtils::MobilePoint::SetData(), Nektar::LocalRegions::Expansion3D::SetFaceToGeomOrientation(), Nektar::SolverUtils::MobilePoint::SetGlobalCoords(), Nektar::FieldUtils::ProcessEquiSpacedOutput::SetHomogeneousConnectivity(), Nektar::SolverUtils::MobilePoint::SetLocalCoords(), Nektar::IncNavierStokes::SetMRFDomainVelBCs(), Nektar::IncNavierStokes::SetMRFWallBCs(), Nektar::MultiRegions::ExpList::SetPhys(), Nektar::LibUtilities::NekLinSysIter::SetUniversalUniqueMap(), Nektar::MultiRegions::LocTraceToTraceMap::Setup(), Nektar::SolverUtils::ForcingMovingReferenceFrame::SolveBodyMotion(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::StagnationInflowBC::StagnationInflowBC(), Nektar::UnsteadyAdvectionDiffusion::SubStepProjection(), Nektar::SubSteppingExtrapolate::SubStepProjection(), Nektar::SolverUtils::EvaluatePoints::SyncColumnComm(), Diffusion::TimeIntegrate(), Nektar::CellModel::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationSolutionGLM::TimeIntegrationSolutionGLM(), Nektar::LibUtilities::Transposition::TransposeXtoYZ(), Nektar::LibUtilities::Transposition::TransposeXYtoZ(), Nektar::LibUtilities::Transposition::TransposeYZtoX(), Nektar::LibUtilities::Transposition::TransposeYZtoZY(), Nektar::LibUtilities::Transposition::TransposeZtoXY(), Nektar::LibUtilities::Transposition::TransposeZYtoYZ(), Nektar::MultiRegions::AssemblyMap::UniversalAssembleBnd(), Nektar::VortexWaveInteraction::UpdateAlpha(), Nektar::LinearisedAdvection::UpdateBase(), Nektar::SolverUtils::ForcingMovingReferenceFrame::UpdateBoundaryConditions(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateFirstQuadrature(), Nektar::MultiRegions::GlobalLinSysIterative::UpdateKnownSolutions(), Nektar::VortexWaveInteraction::UpdateWaveForceMag(), Nektar::LocalRegions::HexExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PrismExp::v_AlignVectorToCollapsedDir(), Nektar::IsentropicVortexBC::v_Apply(), Nektar::PressureMachTemperatureBC::v_Apply(), Nektar::RinglebFlowBC::v_Apply(), Nektar::SymmetryBC::v_Apply(), Nektar::WallBC::v_Apply(), Nektar::WallViscousBC::v_Apply(), Nektar::ForcingMovingBody::v_Apply(), Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelCovar(), Nektar::LocalRegions::Expansion3D::v_BuildInverseTransformationMatrix(), Nektar::LocalRegions::Expansion3D::v_BuildTransformationMatrix(), Nektar::MultiRegions::ExpList::v_BwdTrans(), Nektar::StdRegions::StdHexExp::v_BwdTrans(), Nektar::StdRegions::StdPointExp::v_BwdTrans(), Nektar::StdRegions::StdPrismExp::v_BwdTrans(), Nektar::StdRegions::StdPyrExp::v_BwdTrans(), Nektar::StdRegions::StdQuadExp::v_BwdTrans(), Nektar::StdRegions::StdSegExp::v_BwdTrans(), Nektar::StdRegions::StdTetExp::v_BwdTrans(), Nektar::StdRegions::StdHexExp::v_BwdTrans_SumFacKernel(), Nektar::StdRegions::StdQuadExp::v_BwdTrans_SumFacKernel(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::LocalRegions::HexExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::QuadExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::GlobalMapping::MappingTranslation::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXofZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingTranslation::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXofZ::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_ContravarToCartesian(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::GlobalMapping::MappingTranslation::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingTranslation::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXofZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarToCartesian(), Nektar::GlobalMapping::Mapping::v_CurlCurlField(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedDotProd(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedProd(), Nektar::MultiRegions::ExpListHomogeneous2D::v_DealiasedProd(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::SolverUtils::DiffusionLFRNS::v_Diffuse(), Nektar::MultiRegions::PreconditionerNull::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerJacobi::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditionerWithNonVertOutput(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::VCSImplicit::v_EvaluateAdvection_SetPressureBCs(), Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute(), Nektar::LocalRegions::HexExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::PrismExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::PyrExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::QuadExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::SegExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TetExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TriExp::v_ExtractDataToCoeffs(), Nektar::MultiRegions::ExpList::v_ExtractDataToCoeffs(), Nektar::MultiRegions::ExpListHomogeneous1D::v_ExtractDataToCoeffs(), Nektar::MultiRegions::ExpListHomogeneous2D::v_ExtractDataToCoeffs(), Nektar::MultiRegions::ExpList::v_ExtractPhysToBndElmt(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_ExtractTracePhys(), Nektar::LibUtilities::NekFFTW::v_FFTBwdTrans(), Nektar::LibUtilities::NekFFTW::v_FFTFwdTrans(), Nektar::StdRegions::StdQuadExp::v_FillMode(), Nektar::StdRegions::StdHexExp::v_FillMode(), Nektar::StdRegions::StdSegExp::v_FillMode(), Nektar::StdRegions::StdTriExp::v_FillMode(), Nektar::LocalRegions::HexExp::v_FwdTrans(), Nektar::LocalRegions::PrismExp::v_FwdTrans(), Nektar::LocalRegions::PyrExp::v_FwdTrans(), Nektar::LocalRegions::QuadExp::v_FwdTrans(), Nektar::LocalRegions::SegExp::v_FwdTrans(), Nektar::LocalRegions::TetExp::v_FwdTrans(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_FwdTrans(), Nektar::StdRegions::StdHexExp::v_FwdTrans(), Nektar::StdRegions::StdPointExp::v_FwdTrans(), Nektar::StdRegions::StdQuadExp::v_FwdTrans(), Nektar::StdRegions::StdSegExp::v_FwdTrans(), Nektar::LocalRegions::QuadExp::v_FwdTransBndConstrained(), Nektar::LocalRegions::SegExp::v_FwdTransBndConstrained(), Nektar::StdRegions::StdQuadExp::v_FwdTransBndConstrained(), Nektar::StdRegions::StdSegExp::v_FwdTransBndConstrained(), Nektar::StdRegions::StdHexExp::v_GenMatrix(), Nektar::StdRegions::StdPrismExp::v_GenMatrix(), Nektar::StdRegions::StdQuadExp::v_GenMatrix(), Nektar::StdRegions::StdSegExp::v_GenMatrix(), Nektar::StdRegions::StdTetExp::v_GenMatrix(), Nektar::StdRegions::StdTriExp::v_GenMatrix(), Nektar::LocalRegions::Expansion1D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::IncNavierStokes::v_GetAeroForce(), Nektar::MultiRegions::DisContField::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion(), Nektar::MultiRegions::ExpList::v_GetBoundaryNormals(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBoundaryNormals(), Nektar::GlobalMapping::Mapping::v_GetCartesianCoordinates(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::GlobalMapping::Mapping::v_GetCoordVelocity(), Nektar::SolverUtils::FileSolution::v_GetDensity(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctn(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctnElmt(), Nektar::GlobalMapping::MappingGeneral::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingGeneral::v_GetJacobian(), Nektar::GlobalMapping::MappingXofXZ::v_GetJacobian(), Nektar::GlobalMapping::MappingGeneral::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXofXZ::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXofZ::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetMetricTensor(), Nektar::GlobalMapping::MappingXYofZ::v_GetMetricTensor(), Nektar::MultiRegions::ExpList::v_GetMovingFrames(), Nektar::IncNavierStokes::v_GetMovingFrameVelocities(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetNormals(), Nektar::LocalRegions::QuadExp::v_GetTracePhysVals(), Nektar::LocalRegions::TriExp::v_GetTracePhysVals(), Nektar::LocalRegions::QuadExp::v_GetTraceQFactors(), Nektar::SolverUtils::FileSolution::v_GetVelocity(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_InitializeScheme(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_InitializeScheme(), Nektar::LibUtilities::TimeIntegrationSchemeGEM::v_InitializeScheme(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::v_InitializeScheme(), Nektar::MMFDiffusion::v_InitObject(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::GlobalMapping::Mapping::v_InitObject(), Nektar::DiffusionLDGNS::v_InitObject(), Nektar::StdRegions::StdPointExp::v_IProductWRTBase(), Nektar::StdRegions::StdHexExp::v_IProductWRTBase_SumFacKernel(), Nektar::StdRegions::StdQuadExp::v_IProductWRTBase_SumFacKernel(), Nektar::MultiRegions::ExpListHomogeneous1D::v_IProductWRTDerivBase(), Nektar::MMFSWE::v_LinfError(), Nektar::GlobalMapping::MappingTranslation::v_LowerIndex(), Nektar::GlobalMapping::MappingXofXZ::v_LowerIndex(), Nektar::GlobalMapping::MappingXofZ::v_LowerIndex(), Nektar::LibUtilities::NekSys::v_NekSysInitialGuess(), Nektar::FieldUtils::OutputTecplot::v_OutputFromExp(), Nektar::MultiRegions::ExpList::v_PhysDirectionalDeriv(), Nektar::SolverUtils::Forcing::v_PreApply(), Nektar::SolverUtils::ForcingMovingReferenceFrame::v_PreApply(), Nektar::FieldUtils::OutputFileBase::v_Process(), Nektar::FieldUtils::ProcessAddFld::v_Process(), Nektar::FieldUtils::ProcessBodyFittedVelocity::v_Process(), Nektar::FieldUtils::ProcessC0Projection::v_Process(), Nektar::FieldUtils::ProcessCFL::v_Process(), Nektar::FieldUtils::ProcessGrad::v_Process(), Nektar::FieldUtils::ProcessHomogeneousStretch::v_Process(), Nektar::FieldUtils::ProcessJacobianEnergy::v_Process(), Nektar::FieldUtils::ProcessL2Criterion::v_Process(), Nektar::FieldUtils::ProcessMapping::v_Process(), Nektar::FieldUtils::ProcessNumModes::v_Process(), Nektar::FieldUtils::ProcessPointDataToFld::v_Process(), Nektar::FieldUtils::ProcessPowerSpectrum::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessQualityMetric::v_Process(), Nektar::FieldUtils::ProcessVelocityDivergence::v_Process(), Nektar::FieldUtils::ProcessVorticity::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::SolverUtils::FilterFieldConvert::v_ProcessSample(), Nektar::SolverUtils::FilterMaxMinFields::v_ProcessSample(), Nektar::GlobalMapping::MappingTranslation::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofZ::v_RaiseIndex(), Nektar::SolverUtils::CouplingCwipi::v_Receive(), Nektar::SolverUtils::CouplingFile::v_Receive(), Nektar::LocalRegions::HexExp::v_ReduceOrderCoeffs(), Nektar::LocalRegions::QuadExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdPrismExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdPyrExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdQuadExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdSegExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdTetExp::v_ReduceOrderCoeffs(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::IncNavierStokes::v_SetAeroForce(), Nektar::LinearisedAdvection::v_SetBaseFlow(), Nektar::IncNavierStokes::v_SetMovingFrameVelocities(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::MultiRegions::GlobalLinSysPETSc::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_SolveLinearSystem(), Nektar::VCSMapping::v_SolvePressure(), Nektar::LibUtilities::NekLinSysIterFixedpointJacobi::v_SolveSystem(), Nektar::LibUtilities::NekNonlinSysNewton::v_SolveSystem(), Nektar::VCSMapping::v_SolveViscous(), Nektar::SubSteppingExtrapolate::v_SubStepSaveFields(), Nektar::LibUtilities::TimeIntegrationSchemeGEM::v_TimeIntegrate(), Nektar::MultiRegions::AssemblyMapCG::v_UniversalAssemble(), Nektar::GlobalMapping::Mapping::v_UpdateBCs(), Nektar::GlobalMapping::Mapping::v_UpdateMapping(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), Nektar::FieldUtils::OutputTecplot::v_WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotConnectivity(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteVtkPieceHeader(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_WriteVtkPieceHeader(), Vcopy(), Nektar::AcousticSystem::WallBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), Nektar::NonlinearPeregrine::WCESolve(), Nektar::SolverUtils::DiffusionLFR::WeakPenaltyforScalar(), Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1(), and Nektar::AcousticSystem::WhiteNoiseBC().

◆ Vdiv() [1/2]

template<class T >
void Vmath::Vdiv ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

Multiply vector z = x/y.

Definition at line 114 of file VmathArray.hpp.

117{
118 ASSERTL1(static_cast<unsigned int>(n * incx) <= x.size() + x.GetOffset(),
119 "Array out of bounds");
120 ASSERTL1(static_cast<unsigned int>(n * incy) <= y.size() + y.GetOffset(),
121 "Array out of bounds");
122 ASSERTL1(static_cast<unsigned int>(n * incz) <= z.size() + z.GetOffset(),
123 "Array out of bounds");
124
125 Vdiv(n, &x[0], incx, &y[0], incy, &z[0], incz);
126}
Vmath::Vdiv
void Vdiv(int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
Multiply vector z = x/y.
Definition: VmathArray.hpp:114

References ASSERTL1, Vdiv(), and Nektar::UnitTests::z().

◆ Vdiv() [2/2]

template<class T >
void Vmath::Vdiv ( int  n,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

Multiply vector z = x/y.

Definition at line 126 of file Vmath.hpp.

128{
129 ++n;
130 if (incx == 1 && incy == 1)
131 {
132 while (--n)
133 {
134 *z = (*x) / (*y);
135 ++x;
136 ++y;
137 ++z;
138 }
139 }
140 else
141 {
142 while (--n)
143 {
144 *z = (*x) / (*y);
145 x += incx;
146 y += incy;
147 z += incz;
148 }
149 }
150}

References Nektar::UnitTests::z().

Referenced by Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VariableConverter::ApplyC0Smooth(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SpatialDomains::GeomFactors::ComputeDerivFactors(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::SpatialDomains::GeomFactors::ComputeGmat(), Nektar::LinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::EnforceEntropyPressure::EnforceEntropyPressure(), Nektar::EnforceEntropyTotalEnthalpy::EnforceEntropyTotalEnthalpy(), Nektar::EnforceEntropyVelocity::EnforceEntropyVelocity(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::VariableConverter::GetEnthalpy(), Nektar::VariableConverter::GetInternalEnergy(), Nektar::VariableConverter::GetMach(), Nektar::FieldUtils::ProcessVelocityDivergence::GetVelocity(), Nektar::FieldUtils::ProcessVorticity::GetVelocity(), Nektar::FieldUtils::ProcessWSS::GetVelocity(), Nektar::VariableConverter::GetVelocityVector(), Nektar::NonlinearPeregrine::GetVelocityVector(), Nektar::NonlinearSWE::GetVelocityVector(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), main(), Nektar::VCSMapping::MappingPressureCorrection(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::AdvectionFR::v_Advect(), Nektar::EnforceEntropyPressure::v_Apply(), Nektar::EnforceEntropyTotalEnthalpy::v_Apply(), Nektar::EnforceEntropyVelocity::v_Apply(), Nektar::PressureInflowFileBC::v_Apply(), Nektar::PressureOutflowBC::v_Apply(), Nektar::PressureOutflowNonReflectiveBC::v_Apply(), Nektar::RiemannInvariantBC::v_Apply(), Nektar::ForcingAxiSymmetric::v_Apply(), Nektar::ForcingQuasi1D::v_Apply(), Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelCovar(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::LinearSWE::v_ConservativeToPrimitive(), Nektar::NonlinearPeregrine::v_ConservativeToPrimitive(), Nektar::NonlinearSWE::v_ConservativeToPrimitive(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarToCartesian(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::SolverUtils::DiffusionLFRNS::v_Diffuse(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::LocalRegions::Expansion::v_DivideByQuadratureMetric(), Nektar::APE::v_GetFluxVector(), Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor(), Nektar::SolverUtils::FileSolution::v_GetVelocity(), Nektar::ForcingQuasi1D::v_InitObject(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::LocalRegions::SegExp::v_PhysDeriv_s(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::LocalRegions::HexExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PrismExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PyrExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::QuadExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TetExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TriExp::v_SVVLaplacianFilter(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), Vdiv(), Nektar::SpatialDomains::GeomFactors::VectorNormalise(), Nektar::MMFSWE::WallBoundary2D(), and Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1().

◆ Vexp() [1/2]

template<class T >
void Vmath::Vexp ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

exp y = exp(x)

Definition at line 230 of file VmathArray.hpp.

232{
233 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
234 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
235
236 Vexp(n, &x[0], incx, &y[0], incy);
237}
Vmath::Vexp
void Vexp(int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
exp y = exp(x)
Definition: VmathArray.hpp:230

References ASSERTL1, and Vexp().

◆ Vexp() [2/2]

template<class T >
void Vmath::Vexp ( int  n,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

exp y = exp(x)

Definition at line 315 of file Vmath.hpp.

316{
317 while (n--)
318 {
319 *y = exp(*x);
320 x += incx;
321 y += incy;
322 }
323}

Referenced by Nektar::CellModel::TimeIntegrate(), Nektar::CourtemancheRamirezNattel98::v_Update(), and Vexp().

◆ Vlog() [1/2]

template<class T >
void Vmath::Vlog ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

log y = log(x)

Definition at line 219 of file VmathArray.hpp.

221{
222 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
223 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
224
225 Vlog(n, &x[0], incx, &y[0], incy);
226}
Vmath::Vlog
void Vlog(int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
log y = log(x)
Definition: VmathArray.hpp:219

References ASSERTL1, and Vlog().

◆ Vlog() [2/2]

template<class T >
void Vmath::Vlog ( int  n,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

log y = log(x)

Definition at line 303 of file Vmath.hpp.

304{
305 while (n--)
306 {
307 *y = log(*x);
308 x += incx;
309 y += incy;
310 }
311}

References tinysimd::log().

Referenced by Nektar::CourtemancheRamirezNattel98::v_Update(), and Vlog().

◆ Vmax() [1/2]

template<class T >
T Vmath::Vmax ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return the maximum element in x – called vmax to avoid conflict with max.

Definition at line 490 of file VmathArray.hpp.

491{
492 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
493
494 return Vmax(n, &x[0], incx);
495}
Vmath::Vmax
T Vmax(int n, const Array< OneD, const T > &x, const int incx)
Return the maximum element in x – called vmax to avoid conflict with max.
Definition: VmathArray.hpp:490

References ASSERTL1, and Vmax().

◆ Vmax() [2/2]

template<class T >
T Vmath::Vmax ( int  n,
const T *  x,
const int  incx 
)
inline

Return the maximum element in x – called vmax to avoid conflict with max.

Definition at line 644 of file Vmath.hpp.

645{
646
647 T xmax = *x;
648
649 while (n--)
650 {
651 if (*x > xmax)
652 {
653 xmax = *x;
654 }
655 x += incx;
656 }
657
658 return xmax;
659}

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::AbsMaxtoMinEigenValueRatio(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::VortexWaveInteraction::CalcL2ToLinfPressure(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::SolverUtils::UnsteadySystem::CheckSteadyState(), Computestreakpositions(), Nektar::SolverUtils::MMFSystem::ComputeZimYim(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), EnforceRotationalSymmetry(), ExpandVertices(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::PulseWaveSystem::GetCommArray(), Nektar::FieldUtils::ProcessCFL::GetMaxStdVelocity(), Nektar::Extrapolate::GetMaxStdVelocity(), Nektar::VariableConverter::GetMuAv(), Nektar::VortexWaveInteraction::GetReflectionIndex(), Nektar::MultiRegions::ExpList::Linf(), main(), MappingEVids(), MoveOutsidePointsNnormpos(), Orderfunctionx(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::NonSmoothShockCapture::v_GetArtificialViscosity(), Nektar::MMFMaxwell::v_InitObject(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), Nektar::FieldUtils::ProcessJacobianEnergy::v_Process(), Nektar::FilterBenchmark::v_Update(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and Vmax().

◆ Vmin() [1/2]

template<class T >
T Vmath::Vmin ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Return the minimum element in x - called vmin to avoid conflict with min.

Definition at line 526 of file VmathArray.hpp.

527{
528 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
529
530 return Vmin(n, &x[0], incx);
531}
Vmath::Vmin
T Vmin(int n, const Array< OneD, const T > &x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
Definition: VmathArray.hpp:526

References ASSERTL1, and Vmin().

◆ Vmin() [2/2]

template<class T >
T Vmath::Vmin ( int  n,
const T *  x,
const int  incx 
)
inline

Return the minimum element in x - called vmin to avoid conflict with min.

Definition at line 725 of file Vmath.hpp.

726{
727
728 T xmin = *x;
729
730 while (n--)
731 {
732 if (*x < xmin)
733 {
734 xmin = *x;
735 }
736 x += incx;
737 }
738
739 return xmin;
740}

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::AbsMaxtoMinEigenValueRatio(), Nektar::SpatialDomains::GeomFactors::CheckIfValid(), Computestreakpositions(), Nektar::SolverUtils::MMFSystem::ComputeZimYim(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::SolverUtils::MMFSystem::GetIncidentField(), Nektar::UnsteadyAdvectionDiffusion::GetSubstepTimeStep(), Nektar::SubSteppingExtrapolate::GetSubstepTimeStep(), main(), MoveOutsidePointsNnormpos(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::MMFMaxwell::v_InitObject(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), Nektar::FieldUtils::ProcessJacobianEnergy::v_Process(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and Vmin().

◆ Vmul() [1/3]

template<class T >
void Vmath::Vmul ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

Multiply vector z = x*y.

Definition at line 68 of file VmathArray.hpp.

71{
72 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
73 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
74 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
75
76#ifdef NEKTAR_ENABLE_SIMD_VMATH
77 ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
78 ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
79 ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
80 SIMD::Vmul(n, &x[0], &y[0], &z[0]);
81#else
82 Vmul(n, &x[0], incx, &y[0], incy, &z[0], incz);
83#endif
84}
Vmath::Vmul
void Vmul(int n, const Array< TwoD, NekDouble >::const_reference &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
Definition: VmathArray.hpp:87

References ASSERTL1, Vmath::SIMD::Vmul(), Vmul(), and Nektar::UnitTests::z().

◆ Vmul() [2/3]

template<class T >
void Vmath::Vmul ( int  n,
const Array< TwoD, NekDouble >::const_reference &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

Definition at line 87 of file VmathArray.hpp.

90{
91 ASSERTL1(n * incx <= x.size(), "Array out of bounds");
92 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
93 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
94
95 Vmul(n, x.origin(), incx, &y[0], incy, &z[0], incz);
96}

References ASSERTL1, Vmul(), and Nektar::UnitTests::z().

◆ Vmul() [3/3]

template<class T >
void Vmath::Vmul ( int  n,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

Multiply vector z = x*y.

Definition at line 72 of file Vmath.hpp.

74{
75 ++n;
76 if (incx == 1 && incy == 1 && incz == 1)
77 {
78 while (--n)
79 {
80 *z = (*x) * (*y);
81 ++x;
82 ++y;
83 ++z;
84 }
85 }
86 else
87 {
88 while (--n)
89 {
90 *z = (*x) * (*y);
91 x += incx;
92 y += incy;
93 z += incz;
94 }
95 }
96}

References Nektar::UnitTests::z().

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::AbsMaxtoMinEigenValueRatio(), Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux(), Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), Nektar::MMFMaxwell::AddCoriolis(), Nektar::MMFSWE::AddCoriolis(), Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddCoriolis(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::MMFSWE::AddDivForGradient(), Nektar::LocalRegions::Expansion2D::AddEdgeBoundaryInt(), Nektar::MMFSWE::AddElevationEffect(), Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzEdgeTerms(), Nektar::LocalRegions::Expansion3D::AddHDGHelmholtzFaceTerms(), Nektar::LocalRegions::Expansion2D::AddNormTraceInt(), Nektar::LocalRegions::Expansion3D::AddNormTraceInt(), Nektar::MMFMaxwell::AddPML(), Nektar::Extrapolate::AddPressureToOutflowBCs(), Nektar::MMFSWE::AddRotation(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::DiffusionLDGNS::ApplyBCsO2(), Nektar::SolverUtils::DiffusionLDG::ApplyVectorBCs(), Nektar::VortexWaveInteraction::CalcL2ToLinfPressure(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::FilterAeroForcesSPM::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::SolverUtils::ForcingAbsorption::CalculateForcing(), Nektar::LibUtilities::GaussPoints::CalculateGalerkinProjectionMatrix(), Nektar::GlobalMapping::MappingXYofXY::CalculateMetricTensor(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SolverUtils::MMFSystem::CartesianToMovingframes(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::MMFSWE::ComputeEnergy(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::VelocityCorrectionScheme::ComputeGJPNormalVelocity(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::ArtificialDiffusion::GetFluxVector(), Nektar::EigenValuesAdvection::GetFluxVector(), Nektar::MMFAdvection::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVector(), Nektar::UnsteadyInviscidBurgers::GetFluxVector(), Nektar::ImageWarpingSystem::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::VariableConverter::GetMach(), Nektar::FieldUtils::ProcessCFL::GetMaxStdVelocity(), Nektar::Extrapolate::GetMaxStdVelocity(), Nektar::MMFSWE::GetSWEFluxVector(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), Nektar::StdRegions::StdExpansion::H1(), Nektar::Collections::HexIProduct(), Nektar::LocalRegions::NodalTriExp::Integral(), Nektar::StdRegions::StdExpansion2D::Integral(), Nektar::FieldUtils::ProcessInnerProduct::IProduct(), Nektar::StdRegions::StdExpansion::L2(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), main(), Nektar::StdRegions::StdExpansion::MassMatrixOp_MatFree(), MoveOutsidePointsNnormpos(), Nektar::NekMultiplyDiagonalMatrix(), Nektar::DiffusionLDGNS::NumericalFluxO1(), Nektar::SolverUtils::DiffusionLFRNS::NumericalFluxO2(), Nektar::DiffusionLDGNS::NumericalFluxO2(), Nektar::SolverUtils::DiffusionLDG::NumFluxforScalar(), Nektar::SolverUtils::DiffusionLFR::NumFluxforVector(), Nektar::SolverUtils::DiffusionLDG::NumFluxforVector(), Nektar::Collections::IProductWRTDerivBase_StdMat::operator()(), Nektar::Collections::IProductWRTDerivBase_IterPerExp::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Seg::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Quad::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tri::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Hex::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tet::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Prism::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Pyr::operator()(), Nektar::Collections::Helmholtz_IterPerExp::operator()(), Nektar::Collections::IProductWRTBase_StdMat::operator()(), Nektar::Collections::IProductWRTBase_IterPerExp::operator()(), Nektar::Collections::IProductWRTBase_SumFac_Seg::operator()(), Nektar::Collections::PhysDeriv_IterPerExp::operator()(), Nektar::Collections::PhysDeriv_SumFac_Seg::operator()(), Nektar::Collections::PhysDeriv_SumFac_Quad::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tri::operator()(), Nektar::Collections::PhysDeriv_SumFac_Hex::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tet::operator()(), Nektar::Collections::PhysDeriv_SumFac_Prism::operator()(), Nektar::Collections::PhysDeriv_SumFac_Pyr::operator()(), Nektar::LocalRegions::NodalTriExp::PhysDeriv(), Nektar::PressureMachTemperatureBC::PressureMachTemperatureBC(), Nektar::LinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::PrimitiveToConservative(), Nektar::Collections::PrismIProduct(), Nektar::Collections::PyrIProduct(), Nektar::Collections::QuadIProduct(), Nektar::LibUtilities::NekFFTW::Reshuffle_FFTW2Nek(), Nektar::LibUtilities::NekFFTW::Reshuffle_Nek2FFTW(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::IncNavierStokes::SetRadiationBoundaryForcing(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::SolverUtils::MMFSystem::SetUpMovingFrames(), Nektar::SolverUtils::UnsteadySystem::SVVVarDiffCoeff(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::Collections::TetIProduct(), Nektar::Collections::TriIProduct(), Nektar::FilterMovingBody::UpdateForce(), Nektar::SmoothedProfileMethod::UpdateForcing(), Nektar::LocalRegions::Expansion2D::v_AddEdgeNormBoundaryInt(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::AdvectionNonConservative::v_Advect(), Nektar::SolverUtils::AdvectionFR::v_Advect(), Nektar::AdjointAdvection::v_Advect(), Nektar::AlternateSkewAdvection::v_Advect(), Nektar::LinearisedAdvection::v_Advect(), Nektar::NavierStokesAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::LocalRegions::HexExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::NodalTriExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PrismExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::PyrExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::QuadExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::TetExp::v_AlignVectorToCollapsedDir(), Nektar::LocalRegions::TriExp::v_AlignVectorToCollapsedDir(), Nektar::ForcingAxiSymmetric::v_Apply(), Nektar::ForcingQuasi1D::v_Apply(), Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXofZ::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXYofZ::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelCovar(), Nektar::GlobalMapping::MappingXofZ::v_ApplyChristoffelCovar(), Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelCovar(), Nektar::GlobalMapping::MappingXYofZ::v_ApplyChristoffelCovar(), Nektar::MappingExtrapolate::v_CalcNeumannPressureBCs(), Nektar::LocalRegions::TriExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXofZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXofZ::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarToCartesian(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::GlobalMapping::MappingXofXZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXofZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarToCartesian(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedProd(), Nektar::MultiRegions::ExpListHomogeneous2D::v_DealiasedProd(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::SolverUtils::DiffusionLFRNS::v_Diffuse(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::MultiRegions::PreconditionerDiagonal::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerJacobi::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLinearWithLowEnergy::v_DoPreconditioner(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::GlobalMapping::MappingXofXZ::v_DotGradJacobian(), Nektar::MultiRegions::PreconditionerLowEnergy::v_DoTransformBasisToLowEnergy(), Nektar::MultiRegions::PreconditionerLowEnergy::v_DoTransformCoeffsFromLowEnergy(), Nektar::MultiRegions::DisContField::v_EvaluateBoundaryConditions(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_EvaluateBoundaryConditions(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute(), Nektar::StdRegions::StdQuadExp::v_FillMode(), Nektar::StdRegions::StdHexExp::v_FillMode(), Nektar::StdRegions::StdTriExp::v_FillMode(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::NavierStokesCFE::v_GetFluxPenalty(), Nektar::APE::v_GetFluxVector(), Nektar::LEE::v_GetFluxVector(), Nektar::GlobalMapping::MappingXofXZ::v_GetInvMetricTensor(), Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor(), Nektar::SpatialDomains::Geometry3D::v_GetLocCoords(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::GlobalMapping::MappingXofXZ::v_GetMetricTensor(), Nektar::LocalRegions::QuadExp::v_GetTraceQFactors(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::LocalRegions::SegExp::v_HelmholtzMatrixOp(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::LocalRegions::HexExp::v_Integral(), Nektar::LocalRegions::PrismExp::v_Integral(), Nektar::LocalRegions::PyrExp::v_Integral(), Nektar::LocalRegions::QuadExp::v_Integral(), Nektar::LocalRegions::SegExp::v_Integral(), Nektar::LocalRegions::TetExp::v_Integral(), Nektar::LocalRegions::TriExp::v_Integral(), Nektar::StdRegions::StdSegExp::v_Integral(), Nektar::LocalRegions::SegExp::v_IProductWRTBase(), Nektar::StdRegions::StdPointExp::v_IProductWRTBase(), Nektar::StdRegions::StdSegExp::v_IProductWRTBase(), Nektar::StdRegions::StdSegExp::v_IProductWRTBase_SumFac(), Nektar::LocalRegions::SegExp::v_IProductWRTDerivBase(), Nektar::StdRegions::StdPrismExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdPyrExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase_SumFac(), Nektar::StdRegions::StdTriExp::v_IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::HexExp::v_IProductWRTDirectionalDerivBase_SumFac(), Nektar::LocalRegions::TriExp::v_IProductWRTDirectionalDerivBase_SumFac(), Nektar::MMFSWE::v_L2Error(), Nektar::LocalRegions::SegExp::v_LaplacianMatrixOp(), Nektar::MMFSWE::v_LinfError(), Nektar::GlobalMapping::MappingXofXZ::v_LowerIndex(), Nektar::GlobalMapping::MappingXofZ::v_LowerIndex(), Nektar::LocalRegions::Expansion::v_MultiplyByQuadratureMetric(), Nektar::StdRegions::StdHexExp::v_MultiplyByStdQuadratureMetric(), Nektar::StdRegions::StdPrismExp::v_MultiplyByStdQuadratureMetric(), Nektar::StdRegions::StdPyrExp::v_MultiplyByStdQuadratureMetric(), Nektar::StdRegions::StdQuadExp::v_MultiplyByStdQuadratureMetric(), Nektar::StdRegions::StdSegExp::v_MultiplyByStdQuadratureMetric(), Nektar::StdRegions::StdTetExp::v_MultiplyByStdQuadratureMetric(), Nektar::StdRegions::StdTriExp::v_MultiplyByStdQuadratureMetric(), Nektar::LocalRegions::SegExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::HexExp::v_PhysDeriv(), Nektar::LocalRegions::PrismExp::v_PhysDeriv(), Nektar::LocalRegions::PyrExp::v_PhysDeriv(), Nektar::LocalRegions::TetExp::v_PhysDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv(), Nektar::StdRegions::StdTetExp::v_PhysDeriv(), Nektar::LocalRegions::SegExp::v_PhysDeriv_n(), Nektar::LocalRegions::HexExp::v_PhysDirectionalDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDirectionalDeriv(), Nektar::LocalRegions::TriExp::v_PhysDirectionalDeriv(), Nektar::LinearSWE::v_PrimitiveToConservative(), Nektar::NonlinearPeregrine::v_PrimitiveToConservative(), Nektar::NonlinearSWE::v_PrimitiveToConservative(), Nektar::FieldUtils::ProcessBodyFittedVelocity::v_Process(), Nektar::FieldUtils::ProcessCombineAvg::v_Process(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::FieldUtils::ProcessPowerSpectrum::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::SolverUtils::FilterBodyFittedVelocity::v_ProcessSample(), Nektar::SolverUtils::FilterReynoldsStresses::v_ProcessSample(), Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofZ::v_RaiseIndex(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::MultiRegions::GlobalLinSysXxtStaticCond::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysXxtFull::v_SolveLinearSystem(), Nektar::VCSMapping::v_SolvePressure(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::LocalRegions::HexExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PrismExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PyrExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::QuadExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TetExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TriExp::v_SVVLaplacianFilter(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::CellModelFitzHughNagumo::v_Update(), Nektar::SolverUtils::FilterEnergy::v_Update(), Nektar::GlobalMapping::MappingXofZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofZ::v_UpdateGeomInfo(), Nektar::LocalRegions::Expansion1D::v_VectorFlux(), Nektar::LocalRegions::Expansion2D::v_VectorFlux(), Nektar::SolverUtils::MMFSystem::VectorCrossProd(), Nektar::SpatialDomains::GeomFactors::VectorCrossProd(), Vmul(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), Nektar::StdRegions::StdExpansion::WeakDerivMatrixOp_MatFree(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::StdRegions::StdExpansion::WeakDirectionalDerivMatrixOp_MatFree(), Nektar::SolverUtils::DiffusionLFR::WeakPenaltyforVector(), Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1(), and Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO2().

◆ Vpow() [1/2]

template<class T >
void Vmath::Vpow ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
const T  f,
Array< OneD, T > &  y,
const int  incy 
)

pow y = pow(x, f)

Definition at line 241 of file VmathArray.hpp.

243{
244 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
245 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
246
247 Vpow(n, &x[0], incx, f, &y[0], incy);
248}
Vmath::Vpow
void Vpow(int n, const Array< OneD, const T > &x, const int incx, const T f, Array< OneD, T > &y, const int incy)
pow y = pow(x, f)
Definition: VmathArray.hpp:241

References ASSERTL1, and Vpow().

◆ Vpow() [2/2]

template<class T >
void Vmath::Vpow ( int  n,
const T *  x,
const int  incx,
const T  f,
T *  y,
const int  incy 
)
inline

pow y = pow(x, f)

Definition at line 327 of file Vmath.hpp.

329{
330 while (n--)
331 {
332 *y = pow(*x, f);
333 x += incx;
334 y += incy;
335 }
336}

Referenced by Nektar::CourtemancheRamirezNattel98::v_Update(), and Vpow().

◆ Vsqrt() [1/2]

template<class T >
void Vmath::Vsqrt ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
Array< OneD, T > &  y,
const int  incy 
)

sqrt y = sqrt(x)

Definition at line 252 of file VmathArray.hpp.

254{
255 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
256 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
257
258 Vsqrt(n, &x[0], incx, &y[0], incy);
259}
Vmath::Vsqrt
void Vsqrt(int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
sqrt y = sqrt(x)
Definition: VmathArray.hpp:252

References ASSERTL1, and Vsqrt().

◆ Vsqrt() [2/2]

template<class T >
void Vmath::Vsqrt ( int  n,
const T *  x,
const int  incx,
T *  y,
const int  incy 
)
inline

sqrt y = sqrt(x)

Definition at line 340 of file Vmath.hpp.

341{
342 while (n--)
343 {
344 *y = sqrt(*x);
345 x += incx;
346 y += incy;
347 }
348}

References tinysimd::sqrt().

Referenced by Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::VortexWaveInteraction::CalcL2ToLinfPressure(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::SpatialDomains::GeomFactors::ComputeDerivFactors(), Nektar::SpatialDomains::GeomFactors::ComputeJac(), Nektar::VariableConverter::GetAbsoluteVelocity(), Nektar::VariableConverter::GetMach(), main(), Nektar::SolverUtils::UnsteadySystem::SVVVarDiffCoeff(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::FilterElectrogram::v_Initialise(), Nektar::MMFSWE::v_L2Error(), Nektar::MMFSWE::v_LinfError(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::FieldUtils::ProcessSurfDistance::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::LocalRegions::HexExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PrismExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::PyrExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::QuadExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TetExp::v_SVVLaplacianFilter(), Nektar::LocalRegions::TriExp::v_SVVLaplacianFilter(), Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude(), Nektar::SpatialDomains::GeomFactors::VectorNormalise(), and Vsqrt().

◆ Vstvpp()

template<class T >
void Vmath::Vstvpp ( int  n,
const T  alpha,
const T *  v,
int  incv,
const T *  w,
int  incw,
const T *  x,
int  incx,
T *  z,
int  incz 
)
inline

Vstvpp (scalar times vector plus vector plus vector):

Definition at line 488 of file Vmath.hpp.

490{
491 while (n--)
492 {
493 *z = alpha * (*v) + (*w) + (*x);
494 v += incv;
495 w += incw;
496 x += incx;
497 z += incz;
498 }
499}

References Nektar::UnitTests::w(), and Nektar::UnitTests::z().

◆ Vsub() [1/2]

template<class T >
void Vmath::Vsub ( int  n,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

Subtract vector z = x-y.

Definition at line 178 of file VmathArray.hpp.

181{
182 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
183 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
184 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
185
186 Vsub(n, &x[0], incx, &y[0], incy, &z[0], incz);
187}
Vmath::Vsub
void Vsub(int n, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
Subtract vector z = x-y.
Definition: VmathArray.hpp:178

References ASSERTL1, Vsub(), and Nektar::UnitTests::z().

◆ Vsub() [2/2]

template<class T >
void Vmath::Vsub ( int  n,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

Subtract vector z = x-y.

Definition at line 220 of file Vmath.hpp.

222{
223 ++n;
224 if (incx == 1 && incy == 1 && incz == 1)
225 {
226 while (--n)
227 {
228 *z = (*x) - (*y);
229 ++x;
230 ++y;
231 ++z;
232 }
233 }
234 else
235 {
236 while (--n)
237 {
238 *z = (*x) - (*y);
239 x += incx;
240 y += incy;
241 z += incz;
242 }
243 }
244}

References Nektar::UnitTests::z().

Referenced by Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux(), Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::AddFASCorrectionToSFint(), Nektar::MMFMaxwell::AddPML(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::CFSImplicit::CalcTraceNumericalFlux(), Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::FilterAeroForcesSPM::CalculateForces(), Nektar::SolverUtils::ForcingAbsorption::CalculateForcing(), Nektar::FieldUtils::ProcessPhiFromFile::CheckHit(), Nektar::SolverUtils::MMFSystem::ComputeCurl(), Nektar::MMFSWE::ComputeEnergy(), Nektar::SolverUtils::DriverPFASST::ComputeFASCorrection(), Nektar::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::LinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::SolverUtils::DriverParareal::CorrectionWithOldCoarseSolution(), Nektar::SolverUtils::DiffusionLFR::DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DerCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::DivCFlux_2D_Gauss(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::VariableConverter::GetInternalEnergy(), Nektar::SolverUtils::FilterLagrangianPoints::GetPhysicsData(), Nektar::VariableConverter::GetSensor(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::StdRegions::StdExpansion::H1(), Nektar::StdRegions::StdExpansion::L2(), Nektar::MultiRegions::DisContField::L2_DGDeriv(), Nektar::SolverUtils::MMFSystem::LaxFriedrichMaxwellFlux1D(), Nektar::StdRegions::StdExpansion::Linf(), main(), Nektar::VCSMapping::MappingPressureCorrection(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::CFSImplicit::NonlinSysEvaluatorCoeff(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::SolverUtils::DiffusionLDG::NumFluxforVector(), Nektar::SmoothedProfileMethod::SolveCorrectedVelocity(), Nektar::MMFSWE::TestVorticityComputation(), Nektar::CellModel::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::SmoothedProfileMethod::UpdateForcing(), Nektar::SolverUtils::MMFSystem::UpwindMaxwellFlux1D(), Nektar::ForcingAxiSymmetric::v_Apply(), Nektar::ForcingMovingBody::v_Apply(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_ComputeInitialGuess(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_ComputeInitialGuess(), Nektar::LinearSWE::v_ConservativeToPrimitive(), Nektar::NonlinearPeregrine::v_ConservativeToPrimitive(), Nektar::NonlinearSWE::v_ConservativeToPrimitive(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXofZ::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_ContravarFromCartesian(), Nektar::MappingExtrapolate::v_CorrectPressureBCs(), Nektar::GlobalMapping::MappingXofXZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXofZ::v_CovarToCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarToCartesian(), Nektar::MultiRegions::ExpList::v_Curl(), Nektar::MultiRegions::ExpList::v_CurlCurl(), Nektar::GlobalMapping::Mapping::v_CurlCurlField(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::MultiRegions::PreconditionerJacobi::v_DoPreconditioner(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::LocalRegions::QuadExp::v_FwdTransBndConstrained(), Nektar::LocalRegions::SegExp::v_FwdTransBndConstrained(), Nektar::LocalRegions::TriExp::v_FwdTransBndConstrained(), Nektar::StdRegions::StdQuadExp::v_FwdTransBndConstrained(), Nektar::StdRegions::StdSegExp::v_FwdTransBndConstrained(), Nektar::StdRegions::StdTriExp::v_FwdTransBndConstrained(), Nektar::NavierStokesCFE::v_GetFluxPenalty(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::GlobalMapping::Mapping::v_gradgradU(), Nektar::SolverUtils::DiffusionIP::v_InitObject(), Nektar::MMFSWE::v_L2Error(), Nektar::MMFSWE::v_LinfError(), Nektar::NavierStokesImplicitCFE::v_MinusDiffusionFluxJacPoint(), Nektar::FieldUtils::ProcessCombineAvg::v_Process(), Nektar::FieldUtils::ProcessDisplacement::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessStreamFunction::v_Process(), Nektar::FieldUtils::ProcessSurfDistance::v_Process(), Nektar::FieldUtils::ProcessVorticity::v_Process(), Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofZ::v_RaiseIndex(), Nektar::LibUtilities::IMEXTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::LibUtilities::ImplicitTimeIntegrationSchemeSDC::v_SDCIterationLoop(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::MultiRegions::GlobalLinSysIterativeFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysPETScFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve(), Nektar::MultiRegions::GlobalLinSysXxtFull::v_Solve(), Nektar::MultiRegions::GlobalLinSysDirectFull::v_Solve(), Nektar::VCSMapping::v_SolvePressure(), Nektar::LibUtilities::NekLinSysIterFixedpointJacobi::v_SolveSystem(), Nektar::LibUtilities::NekNonlinSysNewton::v_SolveSystem(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), Nektar::LibUtilities::TimeIntegrationSchemeGEM::v_TimeIntegrate(), Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::CellModelFitzHughNagumo::v_Update(), Nektar::SolverUtils::FilterEnergy::v_Update(), Nektar::SolverUtils::FilterModalEnergy::v_Update(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge(), Vsub(), and Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1().

◆ Vsum() [1/2]

template<class T >
T Vmath::Vsum ( int  n,
const Array< OneD, const T > &  x,
const int  incx 
)

Subtract return sum(x)

Definition at line 472 of file VmathArray.hpp.

473{
474 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
475
476 return Vsum(n, &x[0], incx);
477}
Vmath::Vsum
T Vsum(int n, const Array< OneD, const T > &x, const int incx)
Subtract return sum(x)
Definition: VmathArray.hpp:472

References ASSERTL1, and Vsum().

◆ Vsum() [2/2]

template<class T >
T Vmath::Vsum ( int  n,
const T *  x,
const int  incx 
)
inline

Subtract return sum(x)

Definition at line 608 of file Vmath.hpp.

609{
610
611 T sum = 0;
612
613 while (n--)
614 {
615 sum += (*x);
616 x += incx;
617 }
618
619 return sum;
620}

Referenced by Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::MultiRegions::GlobalLinSysPETSc::CalculateReordering(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Nektar::PulseWaveSystem::GetCommArray(), Nektar::VariableConverter::GetMuAv(), Nektar::StdRegions::StdExpansion2D::Integral(), Nektar::SpatialDomains::Geometry3D::NewtonIterationForLocCoord(), Nektar::SpatialDomains::Geometry2D::NewtonIterationForLocCoord(), Nektar::FieldUtils::ProcessWallNormalData::NewtonIterForLocCoordOnBndElmt(), Nektar::SpatialDomains::MeshPartition::PartitionGraph(), Nektar::PulseWaveSystem::SetUpDomainInterfaceBCs(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::StdRegions::StdExpansion3D::v_Integral(), Nektar::StdRegions::StdSegExp::v_Integral(), Nektar::SolverUtils::UnsteadySystem::v_SteadyStateResidual(), Nektar::CompressibleFlowSystem::v_SteadyStateResidual(), Nektar::SolverUtils::FilterAeroForces::v_Update(), Nektar::FieldUtils::OutputTecplot::v_WriteTecplotZone(), Nektar::FieldUtils::OutputTecplotBinary::v_WriteTecplotZone(), and Vsum().

◆ Vvtvm() [1/2]

template<class T >
void Vmath::Vvtvm ( int  n,
const Array< OneD, const T > &  w,
const int  incw,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

vvtvm (vector times vector minus vector): z = w*x - y

Definition at line 315 of file VmathArray.hpp.

320{
321 ASSERTL1(n * incw <= w.size() + w.GetOffset(), "Array out of bounds");
322 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
323 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
324 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
325
326#ifdef NEKTAR_ENABLE_SIMD_VMATH
327 ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
328 ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
329 ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
330 ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
331 SIMD::Vvtvm(n, &w[0], &x[0], &y[0], &z[0]);
332#else
333 Vvtvm(n, &w[0], incw, &x[0], incx, &y[0], incy, &z[0], incz);
334#endif
335}
Vmath::Vvtvm
void Vvtvm(int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
vvtvm (vector times vector minus vector): z = w*x - y
Definition: VmathArray.hpp:315

References ASSERTL1, Vmath::SIMD::Vvtvm(), Vvtvm(), Nektar::UnitTests::w(), and Nektar::UnitTests::z().

◆ Vvtvm() [2/2]

template<class T >
void Vmath::Vvtvm ( int  n,
const T *  w,
const int  incw,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

vvtvm (vector times vector minus vector): z = w*x - y

Definition at line 381 of file Vmath.hpp.

383{
384 while (n--)
385 {
386 *z = (*w) * (*x) - (*y);
387 w += incw;
388 x += incx;
389 y += incy;
390 z += incz;
391 }
392}

References Nektar::UnitTests::w(), and Nektar::UnitTests::z().

Referenced by Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::SmoothedProfileMethod::SolveCorrectedVelocity(), Nektar::LEE::v_AddLinTerm(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarToCartesian(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo(), Nektar::SolverUtils::MMFSystem::VectorCrossProd(), Nektar::SpatialDomains::GeomFactors::VectorCrossProd(), Vvtvm(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

◆ Vvtvp() [1/3]

template<class T >
void Vmath::Vvtvp ( int  n,
const Array< OneD, const T > &  w,
const int  incw,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

vvtvp (vector times vector plus vector): z = w*x + y

Definition at line 276 of file VmathArray.hpp.

281{
282 ASSERTL1(n * incw <= w.size() + w.GetOffset(), "Array out of bounds");
283 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
284 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
285 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
286
287#ifdef NEKTAR_ENABLE_SIMD_VMATH
288 ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
289 ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
290 ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
291 ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
292 SIMD::Vvtvp(n, &w[0], &x[0], &y[0], &z[0]);
293#else
294 Vvtvp(n, &w[0], incw, &x[0], incx, &y[0], incy, &z[0], incz);
295#endif
296}
Vmath::Vvtvp
void Vvtvp(int n, const Array< TwoD, NekDouble >::const_reference &w, const int incw, const Array< OneD, const T > &x, const int incx, const Array< OneD, const T > &y, const int incy, Array< OneD, T > &z, const int incz)
Vvtvp (vector times vector plus vector): z = w*x + y.
Definition: VmathArray.hpp:300

References ASSERTL1, Vmath::SIMD::Vvtvp(), Vvtvp(), Nektar::UnitTests::w(), and Nektar::UnitTests::z().

◆ Vvtvp() [2/3]

template<class T >
void Vmath::Vvtvp ( int  n,
const Array< TwoD, NekDouble >::const_reference &  w,
const int  incw,
const Array< OneD, const T > &  x,
const int  incx,
const Array< OneD, const T > &  y,
const int  incy,
Array< OneD, T > &  z,
const int  incz 
)

Vvtvp (vector times vector plus vector): z = w*x + y.

Definition at line 300 of file VmathArray.hpp.

304{
305 ASSERTL1(n * incw <= w.size(), "Array out of bounds");
306 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
307 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
308 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
309
310 Vvtvp(n, w.origin(), incw, &x[0], incx, &y[0], incy, &z[0], incz);
311}

References ASSERTL1, Vvtvp(), Nektar::UnitTests::w(), and Nektar::UnitTests::z().

◆ Vvtvp() [3/3]

template<class T >
void Vmath::Vvtvp ( int  n,
const T *  w,
const int  incw,
const T *  x,
const int  incx,
const T *  y,
const int  incy,
T *  z,
const int  incz 
)
inline

vvtvp (vector times vector plus vector): z = w*x + y

Definition at line 366 of file Vmath.hpp.

368{
369 while (n--)
370 {
371 *z = (*w) * (*x) + (*y);
372 w += incw;
373 x += incx;
374 y += incy;
375 z += incz;
376 }
377}

References Nektar::UnitTests::w(), and Nektar::UnitTests::z().

Referenced by Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::MMFMaxwell::AddPML(), Nektar::MMFSWE::AddRotation(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VortexWaveInteraction::CalcL2ToLinfPressure(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::GlobalMapping::MappingGeneral::CalculateChristoffel(), Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::GlobalMapping::MappingXYofXY::CalculateMetricTensor(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SolverUtils::MMFSystem::CartesianToMovingframes(), Nektar::SpatialDomains::GeomFactors::CheckIfValid(), Nektar::SolverUtils::MMFSystem::CheckMovingFrames(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFMaxwell::Checkpoint_PlotOutput(), Nektar::MMFMaxwell::Checkpoint_TotPlotOutput(), Nektar::MMFSWE::Compute_demdt_cdot_ek(), Nektar::SolverUtils::MMFSystem::Computedemdxicdote(), Nektar::SpatialDomains::GeomFactors::ComputeDerivFactors(), Nektar::SolverUtils::MMFSystem::ComputeDivCurlMF(), Nektar::MMFSWE::ComputeEnergy(), Nektar::MMFMaxwell::ComputeEnergyDensity(), Nektar::VelocityCorrectionScheme::ComputeGJPNormalVelocity(), Nektar::SpatialDomains::GeomFactors::ComputeGmat(), Nektar::LocalRegions::Expansion::ComputeGmatcdotMF(), Nektar::SpatialDomains::GeomFactors::ComputeJac(), Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::MMFAdvection::ComputeveldotMF(), Nektar::MMFSWE::ComputeVorticity(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::VariableConverter::GetAbsoluteVelocity(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::VariableConverter::GetMach(), Nektar::FieldUtils::ProcessCFL::GetMaxStdVelocity(), Nektar::Extrapolate::GetMaxStdVelocity(), Nektar::LocalRegions::Expansion2D::GetnEdgecdotMF(), Nektar::LocalRegions::Expansion3D::GetnFacecdotMF(), Nektar::UnsteadyAdvection::GetNormalVel(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), Nektar::StdRegions::StdExpansion::H1(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LinearAdvectionMatrixOp_MatFree(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Nektar::SolverUtils::DiffusionLFRNS::NumericalFluxO1(), Nektar::SolverUtils::DiffusionLFRNS::NumericalFluxO2(), Nektar::DiffusionLDGNS::NumericalFluxO2(), Nektar::Collections::IProductWRTDerivBase_StdMat::operator()(), Nektar::Collections::IProductWRTDerivBase_IterPerExp::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Seg::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Quad::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tri::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Hex::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Tet::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Prism::operator()(), Nektar::Collections::IProductWRTDerivBase_SumFac_Pyr::operator()(), Nektar::Collections::Helmholtz_IterPerExp::operator()(), Nektar::Collections::PhysDeriv_StdMat::operator()(), Nektar::Collections::PhysDeriv_IterPerExp::operator()(), Nektar::Collections::PhysDeriv_SumFac_Quad::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tri::operator()(), Nektar::Collections::PhysDeriv_SumFac_Hex::operator()(), Nektar::Collections::PhysDeriv_SumFac_Tet::operator()(), Nektar::Collections::PhysDeriv_SumFac_Prism::operator()(), Nektar::Collections::PhysDeriv_SumFac_Pyr::operator()(), Nektar::LocalRegions::NodalTriExp::PhysDeriv(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::IncNavierStokes::SetZeroNormalVelocity(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::SolverUtils::UnsteadySystem::SVVVarDiffCoeff(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::CellModel::TimeIntegrate(), Nektar::FilterMovingBody::UpdateForce(), Nektar::LocalRegions::Expansion2D::v_AddEdgeNormBoundaryInt(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::AdvectionNonConservative::v_Advect(), Nektar::AdjointAdvection::v_Advect(), Nektar::AlternateSkewAdvection::v_Advect(), Nektar::LinearisedAdvection::v_Advect(), Nektar::NavierStokesAdvection::v_Advect(), Nektar::SkewSymmetricAdvection::v_Advect(), Nektar::PressureInflowFileBC::v_Apply(), Nektar::PressureOutflowBC::v_Apply(), Nektar::PressureOutflowNonReflectiveBC::v_Apply(), Nektar::RiemannInvariantBC::v_Apply(), Nektar::SymmetryBC::v_Apply(), Nektar::WallBC::v_Apply(), Nektar::GlobalMapping::MappingGeneral::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXofXZ::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelContravar(), Nektar::GlobalMapping::MappingGeneral::v_ApplyChristoffelCovar(), Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelCovar(), Nektar::GlobalMapping::MappingXYofZ::v_ApplyChristoffelCovar(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TriExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::GlobalMapping::MappingGeneral::v_ContravarFromCartesian(), Nektar::GlobalMapping::MappingGeneral::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXofXZ::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_ContravarToCartesian(), Nektar::GlobalMapping::MappingGeneral::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofXY::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingXYofZ::v_CovarFromCartesian(), Nektar::GlobalMapping::MappingGeneral::v_CovarToCartesian(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedDotProd(), Nektar::MultiRegions::PreconditionerJacobi::v_DoPreconditioner(), Nektar::GlobalMapping::Mapping::v_DotGradJacobian(), Nektar::GlobalMapping::MappingXofXZ::v_DotGradJacobian(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::APE::v_GetFluxVector(), Nektar::LEE::v_GetFluxVector(), Nektar::SpatialDomains::Geometry3D::v_GetLocCoords(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::LocalRegions::SegExp::v_HelmholtzMatrixOp(), Nektar::FilterElectrogram::v_Initialise(), Nektar::MMFDiffusion::v_InitObject(), Nektar::MMFSWE::v_L2Error(), Nektar::LocalRegions::SegExp::v_LaplacianMatrixOp(), Nektar::LocalRegions::HexExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::GlobalMapping::Mapping::v_LowerIndex(), Nektar::LocalRegions::SegExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::QuadExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::TriExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::HexExp::v_PhysDeriv(), Nektar::LocalRegions::PrismExp::v_PhysDeriv(), Nektar::LocalRegions::PyrExp::v_PhysDeriv(), Nektar::LocalRegions::TetExp::v_PhysDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDeriv(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), Nektar::LocalRegions::HexExp::v_PhysDirectionalDeriv(), Nektar::LocalRegions::QuadExp::v_PhysDirectionalDeriv(), Nektar::LocalRegions::TriExp::v_PhysDirectionalDeriv(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::FieldUtils::ProcessPowerSpectrum::v_Process(), Nektar::FieldUtils::ProcessQCriterion::v_Process(), Nektar::FieldUtils::ProcessScalGrad::v_Process(), Nektar::FieldUtils::ProcessSurfDistance::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::GlobalMapping::Mapping::v_RaiseIndex(), Nektar::APE::v_RiemannInvariantBC(), Nektar::LEE::v_RiemannInvariantBC(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::SolverUtils::FilterEnergy::v_Update(), Nektar::FilterElectrogram::v_Update(), Nektar::LocalRegions::Expansion1D::v_VectorFlux(), Nektar::LocalRegions::Expansion2D::v_VectorFlux(), Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude(), Nektar::SolverUtils::MMFSystem::VectorDotProd(), Nektar::SpatialDomains::GeomFactors::VectorNormalise(), Vvtvp(), Nektar::AcousticSystem::WallBC(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

◆ Vvtvvtm() [1/2]

template<class T >
void Vmath::Vvtvvtm ( int  n,
const Array< OneD, const T > &  v,
int  incv,
const Array< OneD, const T > &  w,
int  incw,
const Array< OneD, const T > &  x,
int  incx,
const Array< OneD, const T > &  y,
int  incy,
Array< OneD, T > &  z,
int  incz 
)

vvtvvtm (vector times vector minus vector times vector): z = v*w - x*y

Definition at line 391 of file VmathArray.hpp.

396{
397 ASSERTL1(n * incv <= v.size() + v.GetOffset(), "Array out of bounds");
398 ASSERTL1(n * incw <= w.size() + w.GetOffset(), "Array out of bounds");
399 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
400 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
401 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
402
403#ifdef NEKTAR_ENABLE_SIMD_VMATH
404 ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
405 ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
406 ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
407 ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
408 SIMD::Vvtvvtm(n, &v[0], &w[0], &x[0], &y[0], &z[0]);
409#else
410 Vvtvvtm(n, &v[0], incv, &w[0], incw, &x[0], incx, &y[0], incy, &z[0], incz);
411#endif
412}
Vmath::Vvtvvtm
void Vvtvvtm(int n, const Array< OneD, const T > &v, int incv, const Array< OneD, const T > &w, int incw, const Array< OneD, const T > &x, int incx, const Array< OneD, const T > &y, int incy, Array< OneD, T > &z, int incz)
vvtvvtm (vector times vector minus vector times vector): z = v*w - x*y
Definition: VmathArray.hpp:391

References ASSERTL1, Vmath::SIMD::Vvtvvtm(), Vvtvvtm(), Nektar::UnitTests::w(), and Nektar::UnitTests::z().

◆ Vvtvvtm() [2/2]

template<class T >
void Vmath::Vvtvvtm ( int  n,
const T *  v,
int  incv,
const T *  w,
int  incw,
const T *  x,
int  incx,
const T *  y,
int  incy,
T *  z,
int  incz 
)
inline

vvtvvtm (vector times vector minus vector times vector):

Definition at line 456 of file Vmath.hpp.

458{
459 while (n--)
460 {
461 *z = (*v) * (*w) - (*x) * (*y);
462 v += incv;
463 w += incw;
464 x += incx;
465 y += incy;
466 z += incz;
467 }
468}

References Nektar::UnitTests::w(), and Nektar::UnitTests::z().

Referenced by Nektar::SpatialDomains::GeomFactors::Adjoint(), Nektar::SpatialDomains::GeomFactors::CheckIfValid(), and Vvtvvtm().

◆ Vvtvvtp() [1/2]

template<class T >
void Vmath::Vvtvvtp ( int  n,
const Array< OneD, const T > &  v,
int  incv,
const Array< OneD, const T > &  w,
int  incw,
const Array< OneD, const T > &  x,
int  incx,
const Array< OneD, const T > &  y,
int  incy,
Array< OneD, T > &  z,
int  incz 
)

vvtvvtp (vector times vector plus vector times vector): z = v*w + x*y

Definition at line 365 of file VmathArray.hpp.

370{
371 ASSERTL1(n * incv <= v.size() + v.GetOffset(), "Array out of bounds");
372 ASSERTL1(n * incw <= w.size() + w.GetOffset(), "Array out of bounds");
373 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
374 ASSERTL1(n * incy <= y.size() + y.GetOffset(), "Array out of bounds");
375 ASSERTL1(n * incz <= z.size() + z.GetOffset(), "Array out of bounds");
376
377#ifdef NEKTAR_ENABLE_SIMD_VMATH
378 ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
379 ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
380 ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
381 ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
382 SIMD::Vvtvvtp(n, &v[0], &w[0], &x[0], &y[0], &z[0]);
383#else
384 Vvtvvtp(n, &v[0], incv, &w[0], incw, &x[0], incx, &y[0], incy, &z[0], incz);
385#endif
386}
Vmath::Vvtvvtp
void Vvtvvtp(int n, const Array< OneD, const T > &v, int incv, const Array< OneD, const T > &w, int incw, const Array< OneD, const T > &x, int incx, const Array< OneD, const T > &y, int incy, Array< OneD, T > &z, int incz)
vvtvvtp (vector times vector plus vector times vector): z = v*w + x*y
Definition: VmathArray.hpp:365

References ASSERTL1, Vmath::SIMD::Vvtvvtp(), Vvtvvtp(), Nektar::UnitTests::w(), and Nektar::UnitTests::z().

◆ Vvtvvtp() [2/2]

template<class T >
void Vmath::Vvtvvtp ( int  n,
const T *  v,
int  incv,
const T *  w,
int  incw,
const T *  x,
int  incx,
const T *  y,
int  incy,
T *  z,
int  incz 
)
inline

vvtvvtp (vector times vector plus vector times vector):

Definition at line 439 of file Vmath.hpp.

441{
442 while (n--)
443 {
444 *z = (*v) * (*w) + (*x) * (*y);
445 v += incv;
446 w += incw;
447 x += incx;
448 y += incy;
449 z += incz;
450 }
451}

References Nektar::UnitTests::w(), and Nektar::UnitTests::z().

Referenced by Nektar::SolverUtils::FilterAeroForces::CalculateForces(), Nektar::SolverUtils::FilterAeroForces::CalculateForcesMapping(), Nektar::SolverUtils::AdvectionFR::DivCFlux_2D(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::SolverUtils::AdvectionFR::v_Advect(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LEE::v_GetFluxVector(), Nektar::FilterElectrogram::v_Initialise(), Nektar::LocalRegions::HexExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::QuadExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::TriExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::QuadExp::v_NormVectorIProductWRTBase(), Nektar::LocalRegions::TriExp::v_NormVectorIProductWRTBase(), Nektar::FilterElectrogram::v_Update(), and Vvtvvtp().

◆ Zero() [1/2]

template<class T >
void Vmath::Zero ( int  n,
Array< OneD, T > &  x,
const int  incx 
)

Zero vector.

Definition at line 202 of file VmathArray.hpp.

203{
204 ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
205
206 Zero(n, &x[0], incx);
207}
Vmath::Zero
void Zero(int n, Array< OneD, T > &x, const int incx)
Zero vector.
Definition: VmathArray.hpp:202

References ASSERTL1, and Zero().

◆ Zero() [2/2]

template<class T >
void Vmath::Zero ( int  n,
T *  x,
const int  incx 
)
inline

Zero vector.

Definition at line 273 of file Vmath.hpp.

274{
275 if (incx == 1)
276 {
277 std::memset(x, '\0', n * sizeof(T));
278 }
279 else
280 {
281 T zero = 0;
282 ++n;
283 while (--n)
284 {
285 *x = zero;
286 x += incx;
287 }
288 }
289}

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToCoeff(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToPhys(), Nektar::MultiRegions::ExpList::AddTraceJacToElmtJac(), Nektar::MultiRegions::GJPStabilisation::Apply(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::DiffusionLDGNS::ApplyBCsO2(), Nektar::SolverUtils::DiffusionIP::ApplyFluxBndConds(), Nektar::SolverUtils::DiffusionLDG::ApplyVectorBCs(), Nektar::MultiRegions::AssemblyMap::AssembleBnd(), Nektar::SolverUtils::DiffusionIP::CalcTraceNumFlux(), Nektar::MMFMaxwell::Checkpoint_EnergyOutput(), Nektar::MMFAdvection::ComputeNablaCdotVelocity(), Nektar::MMFSWE::ComputeNablaCdotVelocity(), Nektar::SolverUtils::DriverPFASST::Correct(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LinearisedAdvection::DFT(), Nektar::SolverUtils::FileFieldInterpolator::DFT(), Nektar::MultiRegions::Preconditioner::DoAssembleLoc(), Nektar::LibUtilities::NekLinSysIterCGLoc::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Nektar::UnsteadyReactionDiffusion::DoOdeRhs(), Nektar::Dummy::DoOdeRhs(), Nektar::SolverUtils::FileSolution::DoOdeRhs(), Nektar::MultiRegions::GlobalLinSysIterative::DoProjection(), Nektar::NekMatrix< DataType, StandardMatrixTag >::EigenSolve(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_big(), Nektar::GlobalMapping::Mapping::EvaluateFunction(), Nektar::IsentropicVortexBC::EvaluateIsentropicVortex(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::MMFSWE::EvaluateWaterDepth(), ExpList_LoadField(), Nektar::SolverUtils::CouplingCwipi::ExtrapolateFields(), Nektar::VariableConverter::GetAbsoluteVelocity(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::MultiRegions::ExpList::GetElmtNormalLength(), Nektar::LinearSWE::GetFluxVector(), Nektar::SolverUtils::MMFSystem::GetIncidentField(), Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase(), Nektar::FieldUtils::ProcessCFL::GetMaxStdVelocity(), Nektar::Extrapolate::GetMaxStdVelocity(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), Nektar::UnsteadyAdvection::GetNormalVel(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurgers::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), Nektar::SolverUtils::EquationSystem::ImportFld(), Nektar::SolverUtils::EquationSystem::ImportFldToMultiDomains(), Nektar::SolverUtils::FileFieldInterpolator::InterpolateField(), Nektar::Collections::IProductWRTDerivBase_StdMat::IProductWRTDerivBase_StdMat(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LinearAdvectionMatrixOp_MatFree(), Nektar::CellModel::LoadCellModel(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Nektar::PreconCfsBRJ::MinusOffDiag2Rhs(), MoveOutsidePointsNnormpos(), Nektar::Collections::BwdTrans_SumFac_Prism::operator()(), Nektar::Collections::BwdTrans_SumFac_Pyr::operator()(), Nektar::Collections::PhysDeriv_StdMat::operator()(), Nektar::Collections::PhysDeriv_IterPerExp::operator()(), Nektar::MultiRegions::AssemblyMap::PatchAssemble(), Nektar::Collections::PhysDeriv_StdMat::PhysDeriv_StdMat(), Nektar::FieldUtils::Iso::SeparateRegions(), Nektar::VarcoeffHashingTest::setupContFieldSolve(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::PulseWaveSystem::SetUpDomainInterfaces(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::LocalRegions::Expansion::StdDerivBaseOnTraceMat(), Diffusion::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::LinearisedAdvection::UpdateBase(), Nektar::FilterMovingBody::UpdateForce(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualQFint(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateIntegratedResidualSFint(), Nektar::LibUtilities::TimeIntegrationSchemeSDC::UpdateLastQuadrature(), Nektar::LEE::v_AddLinTerm(), Nektar::NoAdvection::v_Advect(), Nektar::WallBC::v_Apply(), Nektar::WallViscousBC::v_Apply(), Nektar::MultiRegions::AssemblyMapCG::v_Assemble(), Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::HexExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal(), Nektar::LocalRegions::PyrExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TetExp::v_ComputeTraceNormal(), Nektar::MultiRegions::ExpListHomogeneous1D::v_DealiasedDotProd(), Nektar::MultiRegions::ExpListHomogeneous2D::v_DealiasedDotProd(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::MultiRegions::PreconditionerBlock::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerDiagonal::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerNull::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerJacobi::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLinear::v_DoPreconditionerWithNonVertOutput(), Nektar::Laplace::v_DoSolve(), Nektar::Projection::v_DoSolve(), Nektar::SteadyAdvectionDiffusion::v_DoSolve(), Nektar::GlobalMapping::MappingTranslation::v_DotGradJacobian(), Nektar::GlobalMapping::MappingXofZ::v_DotGradJacobian(), Nektar::GlobalMapping::MappingXYofZ::v_DotGradJacobian(), Nektar::VCSImplicit::v_EvaluateAdvection_SetPressureBCs(), Nektar::SolverUtils::EquationSystem::v_EvaluateExactSolution(), Nektar::LocalRegions::HexExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::PrismExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::QuadExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::SegExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TetExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TriExp::v_ExtractDataToCoeffs(), Nektar::MultiRegions::DisContField::v_ExtractTracePhys(), Nektar::StdRegions::StdNodalPrismExp::v_FillMode(), Nektar::StdRegions::StdNodalTetExp::v_FillMode(), Nektar::StdRegions::StdNodalTriExp::v_FillMode(), Nektar::LocalRegions::Expansion1D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctnElmt(), Nektar::APE::v_GetFluxVector(), Nektar::MultiRegions::DisContField::v_GetFwdBwdTracePhys(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias(), Nektar::MultiRegions::DisContField::v_HelmSolve(), Nektar::GlobalMapping::Mapping::v_InitObject(), Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap(), Nektar::LocalRegions::SegExp::v_PhysDeriv_n(), Nektar::LocalRegions::SegExp::v_PhysDeriv_s(), Nektar::FieldUtils::ProcessC0Projection::v_Process(), Nektar::FieldUtils::ProcessHomogeneousStretch::v_Process(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), Nektar::FieldUtils::ProcessMultiShear::v_Process(), Nektar::FieldUtils::ProcessScalGrad::v_Process(), Nektar::FieldUtils::ProcessSurfDistance::v_Process(), Nektar::FieldUtils::ProcessWSS::v_Process(), Nektar::FieldUtils::ProcessZeroHomogeneousPlane::v_Process(), Nektar::SolverUtils::FilterBodyFittedVelocity::v_ProcessSample(), Nektar::LocalRegions::HexExp::v_ReduceOrderCoeffs(), Nektar::LocalRegions::QuadExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdQuadExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdSegExp::v_ReduceOrderCoeffs(), Nektar::StdRegions::StdTetExp::v_ReduceOrderCoeffs(), Nektar::SolverUtils::EquationSystem::v_SetInitialConditions(), Nektar::MMFDiffusion::v_SetInitialConditions(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::VCSImplicit::v_SetUpViscousForcing(), Nektar::MultiRegions::GlobalLinSysIterativeFull::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysPETSc::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysPETScStaticCond::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysXxtStaticCond::v_SolveLinearSystem(), Nektar::MultiRegions::GlobalLinSysXxtFull::v_SolveLinearSystem(), Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::SolverUtils::FilterEnergy::v_Update(), Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO1(), Nektar::SolverUtils::DiffusionLFRNS::WeakPenaltyO2(), Zero(), and Nektar::SolverUtils::EquationSystem::ZeroPhysFields().

Generated on Wed Jan 31 2024 09:36:07 for Nektar++ by doxygen 1.9.4