Nektar++
Namespaces | Functions
Vmath Namespace Reference

Namespaces

 SIMD
 

Functions

template<class T >
void Fill (int n, const T alpha, T *x, const int incx)
 Fill a vector with a constant value. More...
 
template void Fill (int n, const Nektar::NekDouble alpha, Nektar::NekDouble *x, const int incx)
 
template void Fill (int n, const Nektar::NekSingle alpha, Nektar::NekSingle *x, const int incx)
 
template<class T >
T ran2 (long *idum)
 Generates a number from ~Normal(0,1) More...
 
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 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 void Vmul (int n, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Vmul (int n, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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 void Smul (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Smul (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
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 void Vdiv (int n, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Vdiv (int n, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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/y. More...
 
template void Sdiv (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Sdiv (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
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 void Vadd (int n, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Vadd (int n, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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 void Sadd (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Sadd (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
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 void Vsub (int n, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Vsub (int n, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
template<class T >
void Ssub (int n, const T alpha, const T *x, const int incx, T *y, const int incy)
 Add vector y = alpha - x. More...
 
template void Ssub (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Ssub (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
template<class T >
void Zero (int n, T *x, const int incx)
 Zero vector. More...
 
template void Zero (int n, Nektar::NekDouble *x, const int incx)
 
template void Zero (int n, Nektar::NekSingle *x, const int incx)
 
template void Zero (int n, int *x, const int incx)
 
template void Zero (int n, long *x, const int incx)
 
template<class T >
void Neg (int n, T *x, const int incx)
 Negate x = -x. More...
 
template void Neg (int n, Nektar::NekDouble *x, const int incx)
 
template void Neg (int n, Nektar::NekSingle *x, const int incx)
 
template<class T >
void Vsqrt (int n, const T *x, const int incx, T *y, const int incy)
 sqrt y = sqrt(x) More...
 
template void Vsqrt (int n, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Vsqrt (int n, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
template<class T >
void Vabs (int n, const T *x, const int incx, T *y, const int incy)
 vabs: y = |x| More...
 
template void Vabs (int n, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Vabs (int n, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
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 void Vvtvp (int n, const Nektar::NekDouble *w, const int incw, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Vvtvp (int n, const Nektar::NekSingle *w, const int incw, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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 plus vector): z = w*x - y More...
 
template void Vvtvm (int n, const Nektar::NekDouble *w, const int incw, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Vvtvm (int n, const Nektar::NekSingle *w, const int incw, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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 void Svtvp (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Svtvp (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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)
 svtvp (scalar times vector plus vector): z = alpha*x - y More...
 
template void Svtvm (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, const int incx, const Nektar::NekDouble *y, const int incy, Nektar::NekDouble *z, const int incz)
 
template void Svtvm (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, const int incx, const Nektar::NekSingle *y, const int incy, Nektar::NekSingle *z, const int incz)
 
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 void Vvtvvtp (int n, const Nektar::NekDouble *v, int incv, const Nektar::NekDouble *w, int incw, const Nektar::NekDouble *x, int incx, const Nektar::NekDouble *y, int incy, Nektar::NekDouble *z, int incz)
 
template void Vvtvvtp (int n, const Nektar::NekSingle *v, int incv, const Nektar::NekSingle *w, int incw, const Nektar::NekSingle *x, int incx, const Nektar::NekSingle *y, int incy, Nektar::NekSingle *z, int incz)
 
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 void Vvtvvtm (int n, const Nektar::NekDouble *v, int incv, const Nektar::NekDouble *w, int incw, const Nektar::NekDouble *x, int incx, const Nektar::NekDouble *y, int incy, Nektar::NekDouble *z, int incz)
 
template void Vvtvvtm (int n, const Nektar::NekSingle *v, int incv, const Nektar::NekSingle *w, int incw, const Nektar::NekSingle *x, int incx, const Nektar::NekSingle *y, int incy, Nektar::NekSingle *z, int incz)
 
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)
 vvtvvtp (scalar times vector plus scalar times vector): More...
 
template void Svtsvtp (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *x, int incx, const Nektar::NekDouble beta, const Nektar::NekDouble *y, int incy, Nektar::NekDouble *z, int incz)
 
template void Svtsvtp (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *x, int incx, const Nektar::NekSingle beta, const Nektar::NekSingle *y, int incy, Nektar::NekSingle *z, int incz)
 
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 void Vstvpp (int n, const Nektar::NekDouble alpha, const Nektar::NekDouble *v, int incv, const Nektar::NekDouble *w, int incw, const Nektar::NekDouble *x, int incx, Nektar::NekDouble *z, int incz)
 
template void Vstvpp (int n, const Nektar::NekSingle alpha, const Nektar::NekSingle *v, int incv, const Nektar::NekSingle *w, int incw, const Nektar::NekSingle *x, int incx, Nektar::NekSingle *z, int incz)
 
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 void Gathr (int n, const Nektar::NekDouble *sign, const Nektar::NekDouble *x, const int *y, Nektar::NekDouble *z)
 
template void Gathr (int n, const Nektar::NekSingle *sign, const Nektar::NekSingle *x, const int *y, Nektar::NekSingle *z)
 
template<class T >
void Scatr (int n, const T *x, const int *y, T *z)
 Scatter vector z[y[i]] = x[i]. More...
 
template void Scatr (int n, const Nektar::NekDouble *x, const int *y, Nektar::NekDouble *z)
 
template void Scatr (int n, const Nektar::NekSingle *x, const int *y, Nektar::NekSingle *z)
 
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 void Scatr (int n, const Nektar::NekDouble *sign, const Nektar::NekDouble *x, const int *y, Nektar::NekDouble *z)
 
template void Scatr (int n, const Nektar::NekSingle *sign, const Nektar::NekSingle *x, const int *y, Nektar::NekSingle *z)
 
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 void Assmb (int n, const Nektar::NekDouble *x, const int *y, Nektar::NekDouble *z)
 
template void Assmb (int n, const Nektar::NekSingle *x, const int *y, Nektar::NekSingle *z)
 
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 void Assmb (int n, const Nektar::NekDouble *sign, const Nektar::NekDouble *x, const int *y, Nektar::NekDouble *z)
 
template void Assmb (int n, const Nektar::NekSingle *sign, const Nektar::NekSingle *x, const int *y, Nektar::NekSingle *z)
 
template<class T >
T Vsum (int n, const T *x, const int incx)
 Subtract return sum(x) More...
 
template Nektar::NekDouble Vsum (int n, const Nektar::NekDouble *x, const int incx)
 
template Nektar::NekSingle Vsum (int n, const Nektar::NekSingle *x, const int incx)
 
template int Vsum (int n, const int *x, const int incx)
 
template<class T >
int Imax (int n, const T *x, const int incx)
 Return the index of the maximum element in x. More...
 
template int Imax (int n, const Nektar::NekDouble *x, const int incx)
 
template int Imax (int n, const Nektar::NekSingle *x, const int incx)
 
template int Imax (int n, const int *x, const int incx)
 
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 Nektar::NekDouble Vmax (int n, const Nektar::NekDouble *x, const int incx)
 
template Nektar::NekSingle Vmax (int n, const Nektar::NekSingle *x, const int incx)
 
template int Vmax (int n, const int *x, const int incx)
 
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 int Iamax (int n, const Nektar::NekDouble *x, const int incx)
 
template int Iamax (int n, const Nektar::NekSingle *x, const int incx)
 
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 Nektar::NekDouble Vamax (int n, const Nektar::NekDouble *x, const int incx)
 
template Nektar::NekSingle Vamax (int n, const Nektar::NekSingle *x, const int incx)
 
template<class T >
int Imin (int n, const T *x, const int incx)
 Return the index of the minimum element in x. More...
 
template int Imin (int n, const Nektar::NekDouble *x, const int incx)
 
template int Imin (int n, const Nektar::NekSingle *x, const int incx)
 
template int Imin (int n, const int *x, const int incx)
 
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 Nektar::NekDouble Vmin (int n, const Nektar::NekDouble *x, const int incx)
 
template Nektar::NekSingle Vmin (int n, const Nektar::NekSingle *x, const int incx)
 
template int Vmin (int n, const int *x, const int incx)
 
template<class T >
int Nnan (int n, const T *x, const int incx)
 Return number of NaN elements of x. More...
 
template int Nnan (int n, const Nektar::NekDouble *x, const int incx)
 
template int Nnan (int n, const Nektar::NekSingle *x, const int incx)
 
template int Nnan (int n, const int *x, const int incx)
 
template<class T >
T Dot (int n, const T *w, const T *x)
 vvtvp (vector times vector times vector): z = w*x*y More...
 
template Nektar::NekDouble Dot (int n, const Nektar::NekDouble *w, const Nektar::NekDouble *x)
 
template Nektar::NekSingle Dot (int n, const Nektar::NekSingle *w, const Nektar::NekSingle *x)
 
template<class T >
T Dot (int n, const T *w, const int incw, const T *x, const int incx)
 vvtvp (vector times vector times vector): z = w*x*y More...
 
template Nektar::NekDouble Dot (int n, const Nektar::NekDouble *w, const int incw, const Nektar::NekDouble *x, const int incx)
 
template Nektar::NekSingle Dot (int n, const Nektar::NekSingle *w, const int incw, const Nektar::NekSingle *x, const int incx)
 
template<class T >
T Dot2 (int n, const T *w, const T *x, const int *y)
 vvtvp (vector times vector times vector): z = w*x*y More...
 
template Nektar::NekDouble Dot2 (int n, const Nektar::NekDouble *w, const Nektar::NekDouble *x, const int *y)
 
template Nektar::NekSingle Dot2 (int n, const Nektar::NekSingle *w, const Nektar::NekSingle *x, const int *y)
 
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)
 vvtvp (vector times vector times vector): z = w*x*y More...
 
template Nektar::NekDouble Dot2 (int n, const Nektar::NekDouble *w, const int incw, const Nektar::NekDouble *x, const int incx, const int *y, const int incy)
 
template Nektar::NekSingle Dot2 (int n, const Nektar::NekSingle *w, const int incw, const Nektar::NekSingle *x, const int incx, const int *y, const int incy)
 
template<typename T >
void Vcopy (int n, const T *x, const int incx, T *y, const int incy)
 
template void Vcopy (int n, const int *x, const int incx, int *y, const int incy)
 
template void Vcopy (int n, const unsigned int *x, const int incx, unsigned int *y, const int incy)
 
template void Vcopy (int n, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Vcopy (int n, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
template<class T >
void Reverse (int n, const T *x, const int incx, T *y, const int incy)
 
template void Reverse (int n, const Nektar::NekDouble *x, const int incx, Nektar::NekDouble *y, const int incy)
 
template void Reverse (int n, const Nektar::NekSingle *x, const int incx, Nektar::NekSingle *y, const int incy)
 
template<class T >
void Vlog (int n, const T *x, const int incx, T *y, const int incy)
 
template<class T >
void Vexp (int n, const T *x, const int incx, T *y, const int incy)
 
template<class T >
void Vpow (int n, const T *x, const int incx, const T f, T *y, const int incy)
 
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 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*y. 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/y. 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)
 
template<class T >
void Vexp (int n, const Array< OneD, const T > &x, const int incx, Array< OneD, T > &y, const int incy)
 
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)
 
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)
 
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)
 svtvp (scalar times vector plus vector): z = alpha*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 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 + y*z 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)
 
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)
 
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)
 
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)
 
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/7]

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 385 of file VmathArray.hpp.

386  {
387  ASSERTL1(n <= x.size()+x.GetOffset(),"Array out of bounds");
388  ASSERTL1(n <= y.size()+y.GetOffset(),"Array out of bounds");
389 
390  Assmb(n,&x[0],&y[0],&z[0]);
391  }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:250
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:385

References ASSERTL1, and Assmb().

◆ Assmb() [2/7]

template void Vmath::Assmb ( int  n,
const Nektar::NekDouble *  sign,
const Nektar::NekDouble *  x,
const int *  y,
Nektar::NekDouble *  z 
)

◆ Assmb() [3/7]

template void Vmath::Assmb ( int  n,
const Nektar::NekDouble *  x,
const int *  y,
Nektar::NekDouble *  z 
)

◆ Assmb() [4/7]

template void Vmath::Assmb ( int  n,
const Nektar::NekSingle *  sign,
const Nektar::NekSingle *  x,
const int *  y,
Nektar::NekSingle *  z 
)

◆ Assmb() [5/7]

template void Vmath::Assmb ( int  n,
const Nektar::NekSingle *  x,
const int *  y,
Nektar::NekSingle *  z 
)

◆ Assmb() [6/7]

template<class T >
void Vmath::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.

Definition at line 828 of file Vmath.cpp.

830  {
831  while (n--)
832  {
833  *(z + *(y++)) += *(sign++) * (*(x++));
834  }
835  }
sign
#define sign(a, b)
return the sign(b)*a
Definition: Polylib.cpp:15

References sign.

◆ Assmb() [7/7]

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

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

Definition at line 813 of file Vmath.cpp.

815  {
816  while (n--)
817  {
818  *(z + *(y++)) += *(x++);
819  }
820  }

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

◆ 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 
)

Definition at line 502 of file VmathArray.hpp.

506  {
507  ASSERTL1(n*incw <= w.size()+w.GetOffset(),"Array out of bounds");
508  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
509  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
510 
511  return Dot2(n,&w[0],incw,&x[0],incx,&y[0],incy);
512  }
Vmath::Dot2
T Dot2(int n, const Array< OneD, const T > &w, const Array< OneD, const T > &x, const Array< OneD, const int > &y)
Definition: VmathArray.hpp:489

References ASSERTL1, and Dot2().

◆ Dot() [1/8]

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

Definition at line 467 of file VmathArray.hpp.

470  {
471  ASSERTL1(n <= w.size()+w.GetOffset(),"Array out of bounds");
472  ASSERTL1(n <= x.size()+x.GetOffset(),"Array out of bounds");
473 
474  return Dot(n,&w[0],&x[0]);
475  }
Vmath::Dot
T Dot(int n, const Array< OneD, const T > &w, const int incw, const Array< OneD, const T > &x, const int incx)
Definition: VmathArray.hpp:478

References ASSERTL1, and Dot().

◆ Dot() [2/8]

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 
)

Definition at line 478 of file VmathArray.hpp.

481  {
482  ASSERTL1(n*incw <= w.size()+w.GetOffset(),"Array out of bounds");
483  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
484 
485  return Dot(n,&w[0],incw,&x[0],incx);
486  }

References ASSERTL1, and Dot().

◆ Dot() [3/8]

template Nektar::NekDouble Vmath::Dot ( int  n,
const Nektar::NekDouble *  w,
const int  incw,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Dot() [4/8]

template Nektar::NekDouble Vmath::Dot ( int  n,
const Nektar::NekDouble *  w,
const Nektar::NekDouble *  x 
)

◆ Dot() [5/8]

template Nektar::NekSingle Vmath::Dot ( int  n,
const Nektar::NekSingle *  w,
const int  incw,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Dot() [6/8]

template Nektar::NekSingle Vmath::Dot ( int  n,
const Nektar::NekSingle *  w,
const Nektar::NekSingle *  x 
)

◆ Dot() [7/8]

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

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

Definition at line 1061 of file Vmath.cpp.

1064  {
1065  T sum = 0;
1066 
1067  while( n-- )
1068  {
1069  sum += (*w) * (*x);
1070  w += incw;
1071  x += incx;
1072  }
1073  return sum;
1074  }

◆ Dot() [8/8]

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

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

Definition at line 1038 of file Vmath.cpp.

1041  {
1042  T sum = 0;
1043 
1044  while( n-- )
1045  {
1046  sum += (*w) * (*x);
1047  ++w;
1048  ++x;
1049  }
1050  return sum;
1051  }

Referenced by Nektar::FieldUtils::ProcessWallNormalData::BndElmtContainsPoint(), Nektar::CFSImplicit::CalcRefValues(), Nektar::FieldUtils::ProcessPhiFromFile::CheckHit(), Dot(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_small(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_test(), Nektar::FieldUtils::ProcessPhiFromFile::FindShortestDist(), Nektar::VariableConverter::GetSensor(), Nektar::FieldUtils::ProcessWallNormalData::isInProjectedArea2D(), Nektar::FieldUtils::ProcessWallNormalData::isInProjectedArea3D(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::FieldUtils::ProcessWallNormalData::Process(), Nektar::FieldUtils::ProcessWallNormalData::ProjectPoint(), Nektar::FieldUtils::ProcessWallNormalData::ProjectVertices(), Nektar::LibUtilities::NekNonlinSysNewton::v_ConvergenceCheck(), Nektar::LibUtilities::NekSys::v_ConvergenceCheck(), and Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge().

◆ Dot2() [1/7]

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 
)

Definition at line 489 of file VmathArray.hpp.

493  {
494  ASSERTL1(n <= w.size()+w.GetOffset(),"Array out of bounds");
495  ASSERTL1(n <= x.size()+x.GetOffset(),"Array out of bounds");
496  ASSERTL1(n <= y.size()+y.GetOffset(),"Array out of bounds");
497 
498  return Dot2(n,&w[0],&x[0],&y[0]);
499  }

References ASSERTL1, and Dot2().

◆ Dot2() [2/7]

template Nektar::NekDouble Vmath::Dot2 ( int  n,
const Nektar::NekDouble *  w,
const int  incw,
const Nektar::NekDouble *  x,
const int  incx,
const int *  y,
const int  incy 
)

◆ Dot2() [3/7]

template Nektar::NekDouble Vmath::Dot2 ( int  n,
const Nektar::NekDouble *  w,
const Nektar::NekDouble *  x,
const int *  y 
)

◆ Dot2() [4/7]

template Nektar::NekSingle Vmath::Dot2 ( int  n,
const Nektar::NekSingle *  w,
const int  incw,
const Nektar::NekSingle *  x,
const int  incx,
const int *  y,
const int  incy 
)

◆ Dot2() [5/7]

template Nektar::NekSingle Vmath::Dot2 ( int  n,
const Nektar::NekSingle *  w,
const Nektar::NekSingle *  x,
const int *  y 
)

◆ Dot2() [6/7]

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 
)

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

Definition at line 1112 of file Vmath.cpp.

1116  {
1117  T sum = 0;
1118 
1119  while( n-- )
1120  {
1121  sum += (*y == 1 ? (*w) * (*x) : 0.0 );
1122  w += incw;
1123  x += incx;
1124  y += incy;
1125  }
1126  return sum;
1127  }

◆ Dot2() [7/7]

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

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

Definition at line 1084 of file Vmath.cpp.

1088  {
1089  T sum = 0;
1090 
1091  while( n-- )
1092  {
1093  sum += (*y == 1 ? (*w) * (*x) : 0 );
1094  ++w;
1095  ++x;
1096  ++y;
1097  }
1098  return sum;
1099  }

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::Set_Rhs_Magnitude(), and Nektar::MultiRegions::GlobalLinSysIterative::UpdateKnownSolutions().

◆ Fill() [1/4]

template void Vmath::Fill ( int  n,
const Nektar::NekDouble  alpha,
Nektar::NekDouble *  x,
const int  incx 
)

◆ Fill() [2/4]

template void Vmath::Fill ( int  n,
const Nektar::NekSingle  alpha,
Nektar::NekSingle *  x,
const int  incx 
)

◆ Fill() [3/4]

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 48 of file VmathArray.hpp.

49  {
50 
51  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Out of bounds");
52 
53  Fill(n,alpha,&x[0],incx);
54  }
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:48

References ASSERTL1, and Fill().

◆ Fill() [4/4]

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

Fill a vector with a constant value.

Definition at line 45 of file Vmath.cpp.

46  {
47  while( n-- )
48  {
49  *x = alpha;
50  x += incx;
51  }
52  }

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::SpatialDomains::GeomFactors::Adjoint(), 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::NavierStokesCFE::CalcViscosity(), Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames(), Nektar::SpatialDomains::GeomFactors::ComputePrincipleDirection(), Nektar::NavierStokesCFE::Ducros(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::MMFSWE::EvaluateWaterDepth(), Fill(), Nektar::CFSImplicit::Fill1DArrayOfBlkDiagonalMat(), Nektar::MultiRegions::ExpList1DHomogeneous2D::GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::GetCoords(), Nektar::IncNavierStokes::GetDensity(), Nektar::SolverUtils::Diffusion::GetDivCurl(), Nektar::Collections::CoalescedGeomData::GetJacWithStdWeights(), Nektar::SolverUtils::DiffusionIP::GetPenaltyFactorConst(), Nektar::FieldUtils::ProcessQualityMetric::GetQ(), Nektar::VariableConverter::GetSensor(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::LinearisedAdvection::ImportFldBase(), main(), Nektar::SolverUtils::DriverArnoldi::MaskInit(), Nektar::PreconCfsBRJ::MinusOffDiag2Rhs(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::NekMatrix< DataType, StandardMatrixTag >::operator=(), Nektar::FieldUtils::ProcessAddCompositeID::Process(), Nektar::FieldUtils::ProcessJacobianEnergy::Process(), Nektar::FieldUtils::ProcessNumModes::Process(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::SubSteppingExtrapolate::SubStepExtrapolateField(), Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff(), Nektar::SolverUtils::AdvectionWeakDG::v_AdvectCoeffs(), Nektar::LocalRegions::HexExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::QuadExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TetExp::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::MultiRegions::ExpList1DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_GetCoords(), Nektar::StdRegions::StdQuadExp::v_GetCoords(), Nektar::StdRegions::StdTriExp::v_GetCoords(), 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::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::AcousticSystem::v_WhiteNoiseBC(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteVtkPieceHeader(), and Nektar::MultiRegions::ExpList3DHomogeneous1D::v_WriteVtkPieceHeader().

◆ 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 56 of file VmathArray.hpp.

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

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 142 of file Vmath.cpp.

144  {
145 #ifdef NEKTAR_USE_THREAD_SAFETY
146  // Protect the static vars here and in ran2
147  boost::mutex::scoped_lock l(mutex);
148 #endif
149 
150  // Define static variables for generating random numbers
151  static int iset = 0;
152  static T gset;
153  static long seed = 0;
154 
155  // Bypass seed if outseed was specified
156  if( outseed != 9999)
157  {
158  seed = long(outseed);
159  }
160 
161  while( n-- )
162  {
163  T fac, rsq, v1, v2;
164 
165  if (iset == 0)
166  {
167  do
168  {
169  v1 = 2.0 * ran2<T> (&seed) - 1.0;
170  v2 = 2.0 * ran2<T> (&seed) - 1.0;
171  rsq = v1*v1 + v2*v2;
172  } while (rsq >= 1.0 || rsq == 0.0);
173  fac = sqrt(-2.0 * log (rsq) / rsq);
174  gset = v1 * fac;
175  iset = 1;
176  *x = eps * v2 * fac;
177  }
178  else
179  {
180  iset = 0;
181  *x = eps * gset;
182  }
183  x += incx;
184  }
185  }
tinysimd::log
scalarT< T > log(scalarT< T > in)
Definition: scalar.hpp:278
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:267

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/5]

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 361 of file VmathArray.hpp.

363  {
364  ASSERTL1(n <= y.size()+y.GetOffset(),"Array out of bounds");
365  ASSERTL1(n <= z.size()+z.GetOffset(),"Array out of bounds");
366 
367 #ifdef NEKTAR_ENABLE_SIMD_VMATH
368  SIMD::Gathr(n,&x[0],&y[0],&z[0]);
369 #else
370  Gathr(n,&x[0],&y[0],&z[0]);
371 #endif
372  }
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:361

References ASSERTL1, Vmath::SIMD::Gathr(), and Gathr().

◆ Gathr() [2/5]

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 
)

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

Definition at line 217 of file Vmath.hpp.

218  {
219  while (n--)
220  {
221  *z++ = *(x + *y++);
222  }
223  return;
224  }

◆ Gathr() [3/5]

template void Vmath::Gathr ( int  n,
const Nektar::NekDouble *  sign,
const Nektar::NekDouble *  x,
const int *  y,
Nektar::NekDouble *  z 
)

◆ Gathr() [4/5]

template void Vmath::Gathr ( int  n,
const Nektar::NekSingle *  sign,
const Nektar::NekSingle *  x,
const int *  y,
Nektar::NekSingle *  z 
)

◆ Gathr() [5/5]

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

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

Definition at line 756 of file Vmath.cpp.

758  {
759  while (n--)
760  {
761  *z++ = *(sign++) * (*(x + *y++));
762  }
763  return;
764  }

References sign.

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::GlobalLinSysXxt::GlobalToLocalNoSign(), Nektar::MultiRegions::AssemblyMap::LocalToLocalBnd(), Nektar::MultiRegions::AssemblyMap::LocalToLocalInt(), Nektar::MultiRegions::LocTraceToTraceMap::LocTracesFromField(), Nektar::MultiRegions::AssemblyMap::PatchGlobalToLocal(), Nektar::MultiRegions::LocTraceToTraceMap::RightIPTWLocEdgesToTraceInterpMat(), Nektar::MultiRegions::LocTraceToTraceMap::RightIPTWLocFacesToTraceInterpMat(), Nektar::LocalRegions::Expansion3D::v_GetTracePhysVals(), and Nektar::MultiRegions::AssemblyMapCG::v_GlobalToLocal().

◆ Iamax() [1/4]

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 423 of file VmathArray.hpp.

424  {
425  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
426 
427  return Iamax(n,&x[0],incx);
428 
429  }
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:423

References ASSERTL1, and Iamax().

◆ Iamax() [2/4]

template int Vmath::Iamax ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Iamax() [3/4]

template int Vmath::Iamax ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Iamax() [4/4]

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

Return the index of the maximum absolute element in x.

Definition at line 915 of file Vmath.cpp.

916  {
917 
918  int i, indx = ( n > 0 ) ? 0 : -1;
919  T xmax = *x;
920  T xm;
921 
922  for (i = 0; i < n; i++)
923  {
924  xm = (*x > 0)? *x: -*x;
925  if (xm > xmax)
926  {
927  xmax = xm;
928  indx = i;
929  }
930  x += incx;
931  }
932 
933  return indx;
934  }

Referenced by Iamax().

◆ Imax() [1/5]

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 406 of file VmathArray.hpp.

407  {
408  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
409 
410  return Imax(n,&x[0],incx);
411  }
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:406

References ASSERTL1, and Imax().

◆ Imax() [2/5]

template int Vmath::Imax ( int  n,
const int *  x,
const int  incx 
)

◆ Imax() [3/5]

template int Vmath::Imax ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Imax() [4/5]

template int Vmath::Imax ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Imax() [5/5]

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

Return the index of the maximum element in x.

Definition at line 866 of file Vmath.cpp.

867  {
868 
869  int i, indx = ( n > 0 ) ? 0 : -1;
870  T xmax = *x;
871 
872  for (i = 0; i < n; i++)
873  {
874  if (*x > xmax)
875  {
876  xmax = *x;
877  indx = i;
878  }
879  x += incx;
880  }
881 
882  return indx;
883  }

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

◆ Imin() [1/5]

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 442 of file VmathArray.hpp.

443  {
444  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
445 
446  return Imin(n,&x[0],incx);
447  }
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:442

References ASSERTL1, and Imin().

◆ Imin() [2/5]

template int Vmath::Imin ( int  n,
const int *  x,
const int  incx 
)

◆ Imin() [3/5]

template int Vmath::Imin ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Imin() [4/5]

template int Vmath::Imin ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Imin() [5/5]

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

Return the index of the minimum element in x.

Definition at line 966 of file Vmath.cpp.

967  {
968 
969  int i, indx = ( n > 0 ) ? 0 : -1;
970  T xmin = *x;
971 
972  for(i = 0;i < n;i++)
973  {
974  if( *x < xmin )
975  {
976  xmin = *x;
977  indx = i;
978  }
979  x += incx;
980  }
981 
982  return indx;
983  }

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

◆ Neg() [1/4]

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

Negate x = -x.

Definition at line 184 of file VmathArray.hpp.

185  {
186  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
187 
188  Neg(n,&x[0],incx);
189 
190  }
Vmath::Neg
void Neg(int n, Array< OneD, T > &x, const int incx)
Negate x = -x.
Definition: VmathArray.hpp:184

References ASSERTL1, and Neg().

◆ Neg() [2/4]

template void Vmath::Neg ( int  n,
Nektar::NekDouble *  x,
const int  incx 
)

◆ Neg() [3/4]

template void Vmath::Neg ( int  n,
Nektar::NekSingle *  x,
const int  incx 
)

◆ Neg() [4/4]

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

Negate x = -x.

Definition at line 461 of file Vmath.cpp.

462  {
463  while( n-- )
464  {
465  *x = -(*x);
466  x += incx;
467  }
468  }

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::DiffusionIP::AddSecondDerivToTrace(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames(), Nektar::MMFSWE::ComputeVorticity(), Nektar::SolverUtils::MMFSystem::CopyBoundaryTrace(), Nektar::CFLtester::DoOdeRhs(), Nektar::UnsteadyAdvection::DoOdeRhs(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyInviscidBurger::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::AcousticSystem::DoOdeRhs(), Nektar::MMFAdvection::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::PulseWavePropagation::DoOdeRhs(), Nektar::MMFSWE::DoOdeRhs(), Nektar::CFSImplicit::DoOdeRhsCoeff(), Nektar::SolverUtils::Diffusion::GetDivCurl(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), Nektar::MultiRegions::ContField::LaplaceSolve(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Neg(), Nektar::FieldUtils::ProcessWallNormalData::Process(), Nektar::FieldUtils::ProcessWSS::Process(), 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::SolverUtils::AdvectionWeakDG::v_AdvectCoeffs(), 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::SolverUtils::AdvectionFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D_Gauss(), 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::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::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/5]

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 459 of file VmathArray.hpp.

460  {
461  ASSERTL1(n * incx <= x.size() + x.GetOffset(), "Array out of bounds");
462 
463  return Nnan(n, &x[0], incx);
464  }
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:459

References ASSERTL1, and Nnan().

◆ Nnan() [2/5]

template int Vmath::Nnan ( int  n,
const int *  x,
const int  incx 
)

◆ Nnan() [3/5]

template int Vmath::Nnan ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Nnan() [4/5]

template int Vmath::Nnan ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Nnan() [5/5]

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

Return number of NaN elements of x.

Definition at line 1015 of file Vmath.cpp.

1016  {
1017 
1018  int nNan = 0;
1019 
1020  while (n--)
1021  {
1022  if (*x != *x)
1023  {
1024  nNan++;
1025  }
1026  x += incx;
1027  }
1028 
1029  return nNan;
1030  }

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

◆ ran2()

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

Generates a number from ~Normal(0,1)

Definition at line 74 of file Vmath.cpp.

82  {
83  int j;
84  long k;
85  static long idum2=123456789;
86  static long iy=0;
87  static long iv[NTAB];
88  T temp;
89 
90  if (*idum <= 0) {
91  if (-(*idum) < 1) *idum = 1;
92  else *idum = -(*idum);
93  idum2 = (*idum);
94  for (j=NTAB+7; j>=0; j--) {
95  k = (*idum) / IQ1;
96  *idum = IA1 * (*idum - k*IQ1) - k*IR1;
97  if (*idum < 0) *idum += IM1;
98  if (j < NTAB) iv[j] = *idum;
99  }
100  iy = iv[0];
101  }
102 
103  k = (*idum) / IQ1;
104  *idum = IA1*(*idum - k*IQ1) - k*IR1;
105  if (*idum < 0) *idum += IM1;
106 
107  k = idum2 / IQ2;
108  idum2 = IA2*(idum2 - k*IQ2) - k*IR2;
109  if (idum2 < 0) idum2 += IM2;
110 
111  j = iy / NDIV;
112  iy = iv[j] - idum2;
113  iv[j] = *idum;
114  if (iy < 1) iy += IMM1;
115 
116  if ((temp=AM*iy) > RNMX) return RNMX;
117  else return temp;
118  }
NTAB
#define NTAB
Definition: Vmath.cpp:68
IA2
#define IA2
Definition: Vmath.cpp:63
IR2
#define IR2
Definition: Vmath.cpp:67
NDIV
#define NDIV
Definition: Vmath.cpp:69
IA1
#define IA1
Definition: Vmath.cpp:62
IM1
#define IM1
Definition: Vmath.cpp:58
IR1
#define IR1
Definition: Vmath.cpp:66
IMM1
#define IMM1
Definition: Vmath.cpp:61
IQ1
#define IQ1
Definition: Vmath.cpp:64
RNMX
#define RNMX
Definition: Vmath.cpp:71
IQ2
#define IQ2
Definition: Vmath.cpp:65
AM
#define AM
Definition: Vmath.cpp:60
IM2
#define IM2
Definition: Vmath.cpp:59

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

◆ Reverse() [1/4]

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 524 of file VmathArray.hpp.

525  {
526  ASSERTL1(static_cast<unsigned int>(std::abs(n*incx)) <= x.size()+x.GetOffset(),"Array out of bounds");
527  ASSERTL1(static_cast<unsigned int>(std::abs(n*incy)) <= y.size()+y.GetOffset(),"Array out of bounds");
528 
529  Reverse(n,&x[0],incx,&y[0],incy);
530  }
Vmath::Reverse
void Reverse(int n, const Array< OneD, const T > &x, int incx, Array< OneD, T > &y, int const incy)
Definition: VmathArray.hpp:524
tinysimd::abs
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:272

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

◆ Reverse() [2/4]

template void Vmath::Reverse ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Reverse() [3/4]

template void Vmath::Reverse ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Reverse() [4/4]

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

Definition at line 1226 of file Vmath.cpp.

1227  {
1228  int i;
1229  T store;
1230 
1231  // Perform element by element swaps in case x and y reference the same
1232  // array.
1233  int nloop = n/2;
1234 
1235  // copy value in case of n is odd number
1236  y[nloop] = x[nloop];
1237 
1238  const T* x_end = x + (n-1)*incx;
1239  T* y_end = y + (n-1)*incy;
1240  for (i = 0; i < nloop; ++i) {
1241  store = *x_end;
1242  *y_end = *x;
1243  *y = store;
1244  x += incx;
1245  y += incy;
1246  x_end -= incx;
1247  y_end -= incy;
1248  }
1249  }

Referenced by Nektar::FieldUtils::ProcessSurfDistance::Process(), Reverse(), Nektar::LocalRegions::NodalTriExp::v_ComputeTraceNormal(), Nektar::LocalRegions::QuadExp::v_ComputeTraceNormal(), Nektar::LocalRegions::TriExp::v_ComputeTraceNormal(), Nektar::SolverUtils::DiffusionLFR::v_DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_2D(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D_Gauss(), Nektar::LocalRegions::QuadExp::v_GetTracePhysVals(), Nektar::LocalRegions::TriExp::v_GetTracePhysVals(), and Nektar::LocalRegions::QuadExp::v_GetTraceQFactors().

◆ Sadd() [1/4]

template void Vmath::Sadd ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Sadd() [2/4]

template void Vmath::Sadd ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Sadd() [3/4]

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 142 of file VmathArray.hpp.

143  {
144 
145  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
146  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
147 
148  Sadd(n,alpha,&x[0],incx,&y[0],incy);
149  }
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:142

References ASSERTL1, and Sadd().

◆ Sadd() [4/4]

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

Add vector y = alpha - x.

Add vector y = alpha + x.

Definition at line 341 of file Vmath.cpp.

343  {
344  ++n;
345  if (incx == 1 && incy == 1)
346  {
347  while( --n )
348  {
349  *y = alpha + (*x);
350  ++x;
351  ++y;
352  }
353  }
354  else
355  {
356  while( --n )
357  {
358  *y = alpha + (*x);
359  x += incx;
360  y += incy;
361  }
362  }
363  }

Referenced by Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::MMFSWE::Checkpoint_Output_Cartesian(), Nektar::MMFSWE::ComputeEnergy(), DetermineclosePointxindex(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::MultiRegions::ExpList1DHomogeneous2D::GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::GetCoords(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), main(), MoveOutsidePointsNnormpos(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::FieldUtils::OutputTecplot::OutputFromExp(), Sadd(), Nektar::FieldUtils::ProcessEquiSpacedOutput::SetHomogeneousConnectivity(), Nektar::FilterMovingBody::UpdateForce(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::DriverArpack::v_Execute(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::MultiRegions::ExpList1DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::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::Geometry2D::v_GetLocCoords(), 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::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/7]

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 375 of file VmathArray.hpp.

376  {
377  ASSERTL1(n <= x.size()+x.GetOffset(),"Array out of bounds");
378  ASSERTL1(n <= y.size()+y.GetOffset(),"Array out of bounds");
379 
380  Scatr(n,&x[0],&y[0],&z[0]);
381  }
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:375

References ASSERTL1, and Scatr().

◆ Scatr() [2/7]

template void Vmath::Scatr ( int  n,
const Nektar::NekDouble *  sign,
const Nektar::NekDouble *  x,
const int *  y,
Nektar::NekDouble *  z 
)

◆ Scatr() [3/7]

template void Vmath::Scatr ( int  n,
const Nektar::NekDouble *  x,
const int *  y,
Nektar::NekDouble *  z 
)

◆ Scatr() [4/7]

template void Vmath::Scatr ( int  n,
const Nektar::NekSingle *  sign,
const Nektar::NekSingle *  x,
const int *  y,
Nektar::NekSingle *  z 
)

◆ Scatr() [5/7]

template void Vmath::Scatr ( int  n,
const Nektar::NekSingle *  x,
const int *  y,
Nektar::NekSingle *  z 
)

◆ Scatr() [6/7]

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

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

Definition at line 787 of file Vmath.cpp.

789  {
790  while (n--)
791  {
792  if(*sign)
793  {
794  *(z + *(y++)) = *(sign++) * (*(x++));
795  }
796  else
797  {
798  x++;
799  y++;
800  sign++;
801  }
802  }
803  }

References sign.

◆ Scatr() [7/7]

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

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

Definition at line 772 of file Vmath.cpp.

774  {
775  while (n--)
776  {
777  *(z + *(y++)) = *(x++);
778  }
779  }

Referenced by Nektar::MultiRegions::LocTraceToTraceMap::AddLocTracesToField(), 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::GlobalLinSysXxt::LocalToGlobalNoSign(), Nektar::MultiRegions::AssemblyMap::PatchLocalToGlobal(), Scatr(), Nektar::MultiRegions::ExpList::v_GetNormals(), Nektar::LocalRegions::Expansion3D::v_GetTracePhysVals(), and Nektar::MultiRegions::AssemblyMapCG::v_LocalToGlobal().

◆ Sdiv() [1/4]

template void Vmath::Sdiv ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Sdiv() [2/4]

template void Vmath::Sdiv ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Sdiv() [3/4]

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/y.

Definition at line 115 of file VmathArray.hpp.

116  {
117  ASSERTL1(static_cast<unsigned int>(n*incx) <= x.size()+x.GetOffset(),"Array out of bounds");
118  ASSERTL1(static_cast<unsigned int>(n*incy) <= y.size()+y.GetOffset(),"Array out of bounds");
119 
120  Sdiv(n,alpha,&x[0],incx,&y[0],incy);
121  }
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/y.
Definition: VmathArray.hpp:115

References ASSERTL1, and Sdiv().

◆ Sdiv() [4/4]

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

Scalar multiply y = alpha/y.

Definition at line 291 of file Vmath.cpp.

293  {
294  ++n;
295  if (incx == 1 && incy == 1)
296  {
297  while( --n )
298  {
299  *y = alpha / (*x);
300  ++x;
301  ++y;
302  }
303  }
304  else
305  {
306  while( --n )
307  {
308  *y = alpha / (*x);
309  x += incx;
310  y += incy;
311  }
312  }
313  }

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::SolverUtils::DiffusionIP::v_InitObject(), Nektar::DiffusionLDGNS::v_InitObject(), Nektar::StdRegions::StdTriExp::v_PhysDeriv(), and Nektar::CourtemancheRamirezNattel98::v_Update().

◆ Smul() [1/4]

template void Vmath::Smul ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Smul() [2/4]

template void Vmath::Smul ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Smul() [3/4]

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*y.

Definition at line 95 of file VmathArray.hpp.

96  {
97  ASSERTL1(static_cast<unsigned int>(n*incx) <= x.size()+x.GetOffset(),"Array out of bounds");
98  ASSERTL1(static_cast<unsigned int>(n*incy) <= y.size()+y.GetOffset(),"Array out of bounds");
99 
100  Smul(n,alpha, &x[0],incx,&y[0],incy);
101  }
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*y.
Definition: VmathArray.hpp:95

References ASSERTL1, and Smul().

◆ Smul() [4/4]

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

Scalar multiply y = alpha*x.

Scalar multiply y = alpha*y.

Definition at line 225 of file Vmath.cpp.

227  {
228  ++n;
229  if (incx == 1 && incy == 1)
230  {
231  while( --n )
232  {
233  *y = alpha * (*x);
234  ++x;
235  ++y;
236  }
237  }
238  else
239  {
240  while( --n )
241  {
242  *y = alpha * (*x);
243  x += incx;
244  y += incy;
245  }
246  }
247  }

Referenced by Nektar::MMFSWE::AddElevationEffect(), Nektar::Extrapolate::AddPressureToOutflowBCs(), Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), 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::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Diffusion::DoImplicitSolve(), Nektar::UnsteadyAdvectionDiffusion::DoImplicitSolve(), Nektar::UnsteadyDiffusion::DoImplicitSolve(), Nektar::UnsteadyReactionDiffusion::DoImplicitSolve(), Nektar::UnsteadyViscousBurgers::DoImplicitSolve(), Nektar::Bidomain::DoImplicitSolve(), Nektar::BidomainRoth::DoImplicitSolve(), Nektar::Monodomain::DoImplicitSolve(), Nektar::MMFDiffusion::DoImplicitSolve(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::CompressibleFlowSystem::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::MultiRegions::ExpList1DHomogeneous2D::GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::GetCoords(), Nektar::MultiRegions::ExpList::GetDiagMatIpwrtBase(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::UnsteadyDiffusion::GetFluxVector(), Nektar::UnsteadyInviscidBurger::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvectionDiffusion::GetFluxVectorDiff(), Nektar::UnsteadyViscousBurgers::GetFluxVectorDiff(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::NavierStokesCFE::GetPhysicalAV(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::ForcingMovingBody::InitialiseCableModel(), Nektar::LocalRegions::NodalTriExp::Integral(), 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::ProcessAddFld::Process(), Nektar::FieldUtils::ProcessC0Projection::Process(), Nektar::FieldUtils::ProcessCombineAvg::Process(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessScaleInFld::Process(), Nektar::FieldUtils::ProcessWallNormalData::Process(), Nektar::FieldUtils::ProcessWSS::Process(), Nektar::FieldUtils::ProcessWallNormalData::ProjectPoint(), Nektar::FieldUtils::ProcessWallNormalData::ProjectVertices(), Nektar::SolverUtils::CouplingCwipi::ReceiveCwipi(), Nektar::LibUtilities::NekFFTW::Reshuffle_Nek2FFTW(), 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::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::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::DiffusionLFR::v_DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFR::v_DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_2D(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_1D(), Nektar::PreconCfsBRJ::v_DoPreconCfs(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute(), 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::ExpList1DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::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::LocalRegions::HexExp::v_Integral(), Nektar::LocalRegions::PrismExp::v_Integral(), Nektar::LocalRegions::PyrExp::v_Integral(), Nektar::LocalRegions::QuadExp::v_Integral(), Nektar::LocalRegions::TetExp::v_Integral(), Nektar::LocalRegions::TriExp::v_Integral(), Nektar::StdRegions::StdTriExp::v_Integral(), Nektar::LocalRegions::SegExp::v_Integral(), Nektar::LocalRegions::SegExp::v_IProductWRTBase(), 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::TriExp::v_IProductWRTDirectionalDerivBase_SumFac(), 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::VCSMapping::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSWeakPressure::v_SetUpPressureForcing(), 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::v_WallBC(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), and Nektar::NonlinearSWE::WallBoundary().

◆ Ssub() [1/4]

template void Vmath::Ssub ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Ssub() [2/4]

template void Vmath::Ssub ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Ssub() [3/4]

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 163 of file VmathArray.hpp.

166  {
167 
168  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
169  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
170 
171  Ssub(n,alpha,&x[0],incx,&y[0],incy);
172  }
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:163

References ASSERTL1, and Ssub().

◆ Ssub() [4/4]

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

Add vector y = alpha - x.

Definition at line 405 of file Vmath.cpp.

407  {
408  ++n;
409  if (incx == 1 && incy == 1)
410  {
411  while( --n )
412  {
413  *y = alpha - (*x);
414  ++x;
415  ++y;
416  }
417  }
418  else
419  {
420  while( --n )
421  {
422  *y = alpha - (*x);
423  x += incx;
424  y += incy;
425  }
426  }
427  }

Referenced by Ssub().

◆ Svtsvtp() [1/4]

template void Vmath::Svtsvtp ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
int  incx,
const Nektar::NekDouble  beta,
const Nektar::NekDouble *  y,
int  incy,
Nektar::NekDouble *  z,
int  incz 
)

◆ Svtsvtp() [2/4]

template void Vmath::Svtsvtp ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
int  incx,
const Nektar::NekSingle  beta,
const Nektar::NekSingle *  y,
int  incy,
Nektar::NekSingle *  z,
int  incz 
)

◆ Svtsvtp() [3/4]

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 340 of file VmathArray.hpp.

341  {
342  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
343  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
344  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
345 
346  Svtsvtp(n,alpha,&x[0],incx,beta,&y[0],incy,&z[0],incz);
347  }
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:340

References ASSERTL1, and Svtsvtp().

◆ Svtsvtp() [4/4]

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 
)

vvtvvtp (scalar times vector plus scalar times vector):

Svtsvtp (scalar times vector plus scalar times vector):

Definition at line 691 of file Vmath.cpp.

697  {
698  while( n-- )
699  {
700  *z = alpha * (*x) + beta * (*y);
701  x += incx;
702  y += incy;
703  z += incz;
704  }
705  }

Referenced by Svtsvtp(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TetExp::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::CourtemancheRamirezNattel98::v_Update(), and Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge().

◆ Svtvm() [1/4]

template void Vmath::Svtvm ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Svtvm() [2/4]

template void Vmath::Svtvm ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Svtvm() [3/4]

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 
)

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

Definition at line 279 of file VmathArray.hpp.

280  {
281  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
282  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
283  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
284 
285  Svtvm(n,alpha,&x[0],incx,&y[0],incy,&z[0],incz);
286 
287  }
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)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: VmathArray.hpp:279

References ASSERTL1, and Svtvm().

◆ Svtvm() [4/4]

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 
)

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

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

Definition at line 602 of file Vmath.cpp.

605  {
606  while( n-- )
607  {
608  *z = alpha * (*x) - (*y);
609  x += incx;
610  y += incy;
611  z += incz;
612  }
613  }

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

◆ Svtvp() [1/4]

template void Vmath::Svtvp ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Svtvp() [2/4]

template void Vmath::Svtvp ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Svtvp() [3/4]

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 268 of file VmathArray.hpp.

269  {
270  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
271  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
272  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
273 
274  Svtvp(n,alpha,&x[0],incx,&y[0],incy,&z[0],incz);
275 
276  }
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:268

References ASSERTL1, and Svtvp().

◆ Svtvp() [4/4]

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 
)

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

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

Definition at line 565 of file Vmath.cpp.

568  {
569  ++n;
570  if (incx == 1 && incy == 1 && incz == 1)
571  {
572  while( --n )
573  {
574  *z = alpha * (*x) + (*y);
575  ++x;
576  ++y;
577  ++z;
578  }
579  }
580  else
581  {
582  while( --n )
583  {
584  *z = alpha * (*x) + (*y);
585  x += incx;
586  y += incy;
587  z += incz;
588  }
589  }
590  }

Referenced by Nektar::Extrapolate::AddDuDt(), Nektar::SolverUtils::ForcingMovingReferenceFrame::addRotation(), Nektar::Extrapolate::AddVelBC(), Nektar::VortexWaveInteraction::CalcNonLinearWaveForce(), Nektar::Extrapolate::CalcOutflowBCs(), Nektar::LocalRegions::Expansion::ComputeGmatcdotMF(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::SolverUtils::DriverSteadyState::ComputeSFD(), Nektar::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::LibUtilities::NekLinSysIterGMRES::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::Extrapolate::GetMaxStdVelocity(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), main(), Nektar::CFSImplicit::MatrixMultiplyMatrixFreeCoeff(), Nektar::PreconCfsBRJ::MinusOffDiag2Rhs(), Nektar::CFSImplicit::NonlinSysEvaluatorCoeff(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTE(), Nektar::SolverUtils::MMFSystem::NumericalMaxwellFluxTM(), 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::FieldUtils::ProcessCombineAvg::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessScalGrad::Process(), Nektar::RiemannInvariantBC::RiemannInvariantBC(), Nektar::MultiRegions::LocTraceToTraceMap::RightIPTWLocEdgesToTraceInterpMat(), Nektar::MultiRegions::LocTraceToTraceMap::RightIPTWLocFacesToTraceInterpMat(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), Svtvp(), Nektar::CellModel::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::LinearisedAdvection::UpdateBase(), Nektar::Extrapolate::v_AccelerationBDF(), Nektar::StandardExtrapolate::v_AccelerationBDF(), Nektar::SubSteppingExtrapolateWeakPressure::v_AddNormVelOnOBC(), Nektar::WeakPressureExtrapolate::v_AddNormVelOnOBC(), Nektar::LocalRegions::SegExp::v_AddVertexPhysVals(), Nektar::SolverUtils::ForcingBody::v_Apply(), Nektar::SolverUtils::ForcingBody::v_ApplyCoeff(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TetExp::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::SolverUtils::DiffusionLFR::v_NumFluxforScalar(), Nektar::SolverUtils::DiffusionLFR::v_NumFluxforVector(), Nektar::StdRegions::StdPrismExp::v_PhysDeriv(), Nektar::LocalRegions::TriExp::v_PhysDirectionalDeriv(), Nektar::CellModelAlievPanfilov::v_Update(), Nektar::CourtemancheRamirezNattel98::v_Update(), and Nektar::CellModelFitzHughNagumo::v_Update().

◆ Vabs() [1/4]

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 227 of file VmathArray.hpp.

228  {
229  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
230  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
231 
232  Vabs(n,&x[0],incx,&y[0],incy);
233  }
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:227

References ASSERTL1, and Vabs().

◆ Vabs() [2/4]

template void Vmath::Vabs ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Vabs() [3/4]

template void Vmath::Vabs ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Vabs() [4/4]

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

vabs: y = |x|

Definition at line 493 of file Vmath.cpp.

495  {
496  while( n-- )
497  {
498  *y = ( *x >0)? *x:-(*x);
499  x += incx;
500  y += incy;
501  }
502  }

Referenced by Nektar::SolverUtils::MMFSystem::AbsIntegral(), Nektar::SolverUtils::MMFSystem::AvgAbsInt(), DetermineclosePointxindex(), Nektar::StdRegions::StdExpansion::Linf(), 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/4]

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 124 of file VmathArray.hpp.

125  {
126  ASSERTL1(static_cast<unsigned int>(n*incx) <= x.size()+x.GetOffset(),"Array out of bounds");
127  ASSERTL1(static_cast<unsigned int>(n*incy) <= y.size()+y.GetOffset(),"Array out of bounds");
128  ASSERTL1(static_cast<unsigned int>(n*incz) <= z.size()+z.GetOffset(),"Array out of bounds");
129 
130 #ifdef NEKTAR_ENABLE_SIMD_VMATH
131  boost::ignore_unused(incx, incy, incz);
132  ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
133  ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
134  ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
135  SIMD::Vadd(n,&x[0],&y[0],&z[0]);
136 #else
137  Vadd(n,&x[0],incx,&y[0],incy,&z[0],incz);
138 #endif
139  }
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:124

References ASSERTL1, Vmath::SIMD::Vadd(), and Vadd().

◆ Vadd() [2/4]

template void Vmath::Vadd ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Vadd() [3/4]

template void Vmath::Vadd ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Vadd() [4/4]

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 
)

Add vector z = x+y.

Definition at line 322 of file Vmath.cpp.

324  {
325  while( n-- )
326  {
327  *z = (*x) + (*y);
328  x += incx;
329  y += incy;
330  z += incz;
331  }
332  }

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::MMFMaxwell::AddGreenDerivCompensate(), 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::Diffusion::AddSymmFluxIntegralToOffDiag(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToPhys(), Nektar::SolverUtils::Advection::AddTraceJacToMat(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::MultiRegions::PreconditionerBlock::BlockPreconditionerCG(), 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::MMFSWE::ComputeMass(), Computestreakpositions(), Nektar::MMFMaxwell::ComputeSurfaceCurrent(), Nektar::MMFSWE::ComputeVorticity(), Nektar::CoupledLinearNS::Continuation(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::Bidomain::DoImplicitSolve(), Nektar::UnsteadyAdvectionDiffusion::DoOdeRhs(), Nektar::UnsteadyViscousBurgers::DoOdeRhs(), Nektar::Bidomain::DoOdeRhs(), Nektar::BidomainRoth::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::LinearSWE::DoOdeRhs(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::NonlinearSWE::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::NavierStokesCFE::Ducros(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MultiRegions::DisContField::EvaluateHDGPostProcessing(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::SolverUtils::Diffusion::GetDivCurl(), Nektar::VariableConverter::GetEnthalpy(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase(), Nektar::NavierStokesCFE::GetPhysicalAV(), Nektar::MMFSWE::GetSWEFluxVector(), Nektar::LocalRegions::HexExp::IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::NodalTriExp::IProductWRTDerivBase_SumFac(), Nektar::LocalRegions::HexExp::IProductWRTDirectionalDerivBase_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::DiffusionLDGNS::NumericalFluxO2(), 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::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::FieldUtils::ProcessAddFld::Process(), Nektar::FieldUtils::ProcessCombineAvg::Process(), Nektar::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessWSS::Process(), 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::AdvectionWeakDG::v_AddVolumJacToMat(), 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::LocalRegions::TetExp::v_ComputeLaplacianMetric(), 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::DiffusionLFR::v_DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFR::v_DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_Diffuse(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_1D(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D_Gauss(), 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::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctn(), 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::LocalRegions::TetExp::v_IProductWRTDerivBase(), 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::TriExp::v_IProductWRTDirectionalDerivBase_SumFac(), Nektar::LocalRegions::HexExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PyrExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::QuadExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::TetExp::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::SolverUtils::DiffusionLFRNS::v_NumericalFluxO2(), Nektar::SolverUtils::DiffusionLFR::v_NumFluxforVector(), 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::SolverUtils::FilterAverageFields::v_ProcessSample(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::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(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Vadd(), Nektar::MMFAdvection::WeakDGDirectionalAdvection(), Nektar::MMFMaxwell::WeakDGMaxwellDirDeriv(), Nektar::MMFSWE::WeakDGSWEDirDeriv(), and Nektar::StdRegions::StdExpansion::WeakDirectionalDerivMatrixOp_MatFree().

◆ Vamax() [1/4]

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 433 of file VmathArray.hpp.

434  {
435  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
436 
437  return Vamax(n,&x[0],incx);
438  }
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:433

References ASSERTL1, and Vamax().

◆ Vamax() [2/4]

template Nektar::NekDouble Vmath::Vamax ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Vamax() [3/4]

template Nektar::NekSingle Vmath::Vamax ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Vamax() [4/4]

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

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

Definition at line 942 of file Vmath.cpp.

943  {
944 
945  T xmax = *x;
946  T xm;
947 
948  while( n-- )
949  {
950  xm = (*x > 0)? *x: -*x;
951  if (xm > xmax)
952  {
953  xmax = xm;
954  }
955  x += incx;
956  }
957  return xmax;
958  }

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/6]

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 516 of file VmathArray.hpp.

517  {
518  ASSERTL1(static_cast<unsigned int>(std::abs(n*incx)) <= x.size()+x.GetOffset(),"Array out of bounds");
519  ASSERTL1(static_cast<unsigned int>(std::abs(n*incy)) <= y.size()+y.GetOffset(),"Array out of bounds");
520 
521  Vcopy(n,&x[0],incx,&y[0],incy);
522  }
Vmath::Vcopy
void Vcopy(int n, const Array< OneD, const T > &x, int incx, Array< OneD, T > &y, int const incy)
Definition: VmathArray.hpp:516

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

◆ Vcopy() [2/6]

template void Vmath::Vcopy ( int  n,
const int *  x,
const int  incx,
int *  y,
const int  incy 
)

◆ Vcopy() [3/6]

template void Vmath::Vcopy ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Vcopy() [4/6]

template void Vmath::Vcopy ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Vcopy() [5/6]

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

Definition at line 1199 of file Vmath.cpp.

1201  {
1202  if( incx ==1 && incy == 1)
1203  {
1204  memcpy(y,x,n*sizeof(T));
1205  }
1206  else
1207  {
1208  while( n-- )
1209  {
1210  *y = *x;
1211  x += incx;
1212  y += incy;
1213  }
1214  }
1215  }

Referenced by Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzTraceTerms(), Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::MultiRegions::ExpList::AddRightIPTBaseMatrix(), Nektar::MultiRegions::ExpList::AddRightIPTPhysDerivBase(), Nektar::MultiRegions::ExpList::AddTraceJacToElmtJac(), Nektar::SolverUtils::Advection::AddTraceJacToMat(), Nektar::SpatialDomains::GeomFactors::Adjoint(), Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::SolverUtils::DiffusionLDG::ApplyScalarBCs(), Nektar::MultiRegions::AssemblyMap::AssembleBnd(), Nektar::NavierStokesCFE::C0Smooth(), 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::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::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::EquationSystem::CopyToPhysField(), Nektar::GlobalMapping::Mapping::CovarFromCartesian(), Nektar::GlobalMapping::Mapping::CovarToCartesian(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::SolverUtils::MMFSystem::DeriveCrossProductMF(), DetermineclosePointxindex(), Nektar::LinearisedAdvection::DFT(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::Bidomain::DoImplicitSolve(), Nektar::MultiRegions::GlobalLinSysPETSc::DoNekppOperation(), Nektar::LibUtilities::NekSysOperators::DoNekSysPrecon(), Nektar::PreconCfs::DoNullPrecon(), Nektar::CFLtester::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::UnsteadyAdvectionDiffusion::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyInviscidBurger::DoOdeProjection(), Nektar::UnsteadyViscousBurgers::DoOdeProjection(), Nektar::Dummy::DoOdeProjection(), Nektar::ImageWarpingSystem::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::AcousticSystem::DoOdeProjection(), Nektar::MMFAdvection::DoOdeProjection(), Nektar::CompressibleFlowSystem::DoOdeProjection(), Nektar::MMFMaxwell::DoOdeProjection(), Nektar::PulseWavePropagation::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::MultiRegions::GlobalLinSysIterative::DoProjection(), Nektar::NekMatrix< DataType, StandardMatrixTag >::EigenSolve(), Nektar::CFSImplicit::ElmtVarInvMtrx(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_sort(), Nektar::SolverUtils::SessionFunction::Evaluate(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::MultiRegions::DisContField::EvaluateHDGPostProcessing(), Nektar::ForcingMovingBody::EvaluateStructDynModel(), Nektar::VortexWaveInteraction::ExecuteRoll(), Nektar::VortexWaveInteraction::FileRelaxation(), Nektar::MultiRegions::LocTraceToTraceMap::FindElmtNeighbors(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::LocalRegions::NodalTriExp::GeneralMatrixOp_MatOp(), Nektar::LocalRegions::TetExp::GeneralMatrixOp_MatOp(), Nektar::MultiRegions::ExpList::GenerateElementVector(), GenerateNeighbourArrays(), Nektar::MultiRegions::ExpList2DHomogeneous1D::GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::GetCoords(), Nektar::Collections::CoalescedGeomData::GetDerivFactors(), Nektar::SolverUtils::Diffusion::GetDivCurl(), 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::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::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::InterpLocFacesToTrace(), 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::MultiRegions::GlobalMatrix::Multiply(), Nektar::CFSImplicit::MultiplyElmtInvMassPlusSource(), Nektar::ForcingMovingBody::Newmark_betaSolver(), Nektar::CFSImplicit::NumCalcRiemFluxJac(), Nektar::DiffusionLDGNS::NumericalFluxO2(), Nektar::SolverUtils::DiffusionLDG::NumFluxforScalar(), Nektar::SolverUtils::DiffusionLDG::NumFluxforVector(), Nektar::Collections::IProductWRTDerivBase_MatrixFree::operator()(), Nektar::Collections::BwdTrans_SumFac_Seg::operator()(), Nektar::Collections::BwdTrans_SumFac_Quad::operator()(), Nektar::Collections::BwdTrans_SumFac_Hex::operator()(), Nektar::Collections::IProductWRTBase_MatrixFree::operator()(), Nektar::Collections::BwdTrans_MatrixFree::operator()(), Nektar::Collections::Helmholtz_MatrixFree::operator()(), Nektar::Collections::PhysDeriv_MatrixFree::operator()(), Orderfunctionx(), Nektar::FieldUtils::OutputTecplot::OutputFromExp(), Nektar::Collections::PhysDeriv_StdMat::PhysDeriv_StdMat(), Nektar::LibUtilities::PhysGalerkinProject1D(), Nektar::LibUtilities::PhysGalerkinProject2D(), Nektar::StdRegions::StdExpansion2D::PhysTensorDeriv(), Nektar::StdRegions::StdExpansion3D::PhysTensorDeriv(), PolyFit(), PolyInterp(), Nektar::PressureInflowFileBC::PressureInflowFileBC(), Nektar::PressureMachTemperatureBC::PressureMachTemperatureBC(), Nektar::PressureOutflowBC::PressureOutflowBC(), Nektar::PressureOutflowNonReflectiveBC::PressureOutflowNonReflectiveBC(), Nektar::LinearSWE::PrimitiveToConservative(), Nektar::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::MMFMaxwell::Printout_SurfaceCurrent(), Nektar::FieldUtils::OutputFileBase::Process(), Nektar::FieldUtils::ProcessAddFld::Process(), Nektar::FieldUtils::ProcessC0Projection::Process(), Nektar::FieldUtils::ProcessGrad::Process(), Nektar::FieldUtils::ProcessHomogeneousStretch::Process(), Nektar::FieldUtils::ProcessJacobianEnergy::Process(), Nektar::FieldUtils::ProcessL2Criterion::Process(), Nektar::FieldUtils::ProcessMapping::Process(), Nektar::FieldUtils::ProcessNumModes::Process(), Nektar::FieldUtils::ProcessPointDataToFld::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessQualityMetric::Process(), Nektar::FieldUtils::ProcessVorticity::Process(), Nektar::FieldUtils::ProcessWSS::Process(), Nektar::Collections::QuadIProduct(), Nektar::GlobalMapping::Mapping::RaiseIndex(), Nektar::MultiRegions::AssemblyMapDG::RealignTraceElement(), Nektar::LibUtilities::NekFFTW::Reshuffle_FFTW2Nek(), Nektar::LibUtilities::NekFFTW::Reshuffle_Nek2FFTW(), Nektar::MultiRegions::LocTraceToTraceMap::RightIPTWLocEdgesToTraceInterpMat(), Nektar::MultiRegions::LocTraceToTraceMap::RightIPTWLocFacesToTraceInterpMat(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::LocalRegions::Expansion3D::SetFaceToGeomOrientation(), Nektar::FieldUtils::ProcessEquiSpacedOutput::SetHomogeneousConnectivity(), Nektar::MultiRegions::ExpList::SetPhys(), Nektar::LibUtilities::NekNonlinSys::SetRefResidual(), Nektar::LibUtilities::NekLinSysIter::setUniversalUniqueMap(), Nektar::MultiRegions::LocTraceToTraceMap::Setup(), Nektar::NavierStokesCFE::SpecialBndTreat(), Nektar::StagnationInflowBC::StagnationInflowBC(), Nektar::UnsteadyAdvectionDiffusion::SubStepProjection(), Nektar::SubSteppingExtrapolate::SubStepProjection(), Diffusion::TimeIntegrate(), Nektar::CellModel::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), 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::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::StagnationInflowBC::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::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::MultiRegions::ExpList::v_BwdTrans_IterPerExp(), Nektar::StdRegions::StdHexExp::v_BwdTrans_SumFacKernel(), Nektar::StdRegions::StdQuadExp::v_BwdTrans_SumFacKernel(), Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT(), 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::DiffusionLFR::v_DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_1D(), Nektar::SolverUtils::DiffusionLFRNS::v_Diffuse(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_1D(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D_Gauss(), Nektar::MultiRegions::PreconditionerNull::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::IsentropicVortex::v_EvaluateExactSolution(), 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::TetExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TriExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::SegExp::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::MultiRegions::DisContField::v_FillBwdWithBoundCond(), 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::TetExp::v_FwdTrans(), Nektar::StdRegions::StdHexExp::v_FwdTrans(), Nektar::StdRegions::StdPointExp::v_FwdTrans(), Nektar::StdRegions::StdQuadExp::v_FwdTrans(), Nektar::StdRegions::StdSegExp::v_FwdTrans(), Nektar::LocalRegions::SegExp::v_FwdTrans(), Nektar::LocalRegions::QuadExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdPointExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdQuadExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdSegExp::v_FwdTrans_BndConstrained(), Nektar::LocalRegions::SegExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdHexExp::v_GeneralMatrixOp_MatOp(), Nektar::StdRegions::StdQuadExp::v_GeneralMatrixOp_MatOp(), Nektar::StdRegions::StdTriExp::v_GeneralMatrixOp_MatOp(), Nektar::LocalRegions::HexExp::v_GeneralMatrixOp_MatOp(), Nektar::LocalRegions::PrismExp::v_GeneralMatrixOp_MatOp(), Nektar::LocalRegions::QuadExp::v_GeneralMatrixOp_MatOp(), Nektar::LocalRegions::TriExp::v_GeneralMatrixOp_MatOp(), 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::MultiRegions::DisContField::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_GetBndElmtExpansion(), Nektar::MultiRegions::DisContField3DHomogeneous1D::v_GetBoundaryNormals(), Nektar::MultiRegions::ExpList::v_GetBoundaryNormals(), Nektar::GlobalMapping::Mapping::v_GetCartesianCoordinates(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::GlobalMapping::Mapping::v_GetCoordVelocity(), Nektar::LocalRegions::QuadExp::v_GetEdgePhysVals(), 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::LocalRegions::Expansion::v_GetMF(), Nektar::MultiRegions::ExpList::v_GetMovingFrames(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetNormals(), Nektar::LocalRegions::QuadExp::v_GetTracePhysVals(), Nektar::LocalRegions::TriExp::v_GetTracePhysVals(), Nektar::LocalRegions::QuadExp::v_GetTraceQFactors(), Nektar::NavierStokesCFE::v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), Nektar::SolverUtils::FilterHistoryPoints::v_Initialise(), 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::MMFSWE::v_LinfError(), Nektar::GlobalMapping::MappingTranslation::v_LowerIndex(), Nektar::GlobalMapping::MappingXofXZ::v_LowerIndex(), Nektar::GlobalMapping::MappingXofZ::v_LowerIndex(), Nektar::LibUtilities::NekSys::v_NekSysInitialGuess(), Nektar::SolverUtils::DiffusionLFRNS::v_NumericalFluxO1(), Nektar::SolverUtils::DiffusionLFR::v_NumFluxforScalar(), Nektar::MultiRegions::ExpList::v_PhysDirectionalDeriv(), Nektar::SolverUtils::Forcing::v_PreApply(), Nektar::SolverUtils::ForcingMovingReferenceFrame::v_PreApply(), Nektar::SolverUtils::FilterFieldConvert::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::LinearisedAdvection::v_SetBaseFlow(), Nektar::IsentropicVortex::v_SetInitialConditions(), Nektar::LibUtilities::NekNonlinSysNewton::v_SetupNekNonlinSystem(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::MultiRegions::GlobalLinSysPETSc::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::MultiRegions::AssemblyMapCG::v_UniversalAssemble(), Nektar::GlobalMapping::Mapping::v_UpdateBCs(), Nektar::GlobalMapping::Mapping::v_UpdateMapping(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), Nektar::AcousticSystem::v_WallBC(), Nektar::SolverUtils::DiffusionLFR::v_WeakPenaltyforScalar(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Nektar::AcousticSystem::v_WhiteNoiseBC(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteVtkPieceHeader(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_WriteVtkPieceHeader(), Vcopy(), 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::FieldUtils::OutputTecplot::WriteTecplotConnectivity(), and Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotConnectivity().

◆ Vcopy() [6/6]

template void Vmath::Vcopy ( int  n,
const unsigned int *  x,
const int  incx,
unsigned int *  y,
const int  incy 
)

◆ Vdiv() [1/4]

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 104 of file VmathArray.hpp.

105  {
106  ASSERTL1(static_cast<unsigned int>(n*incx) <= x.size()+x.GetOffset(),"Array out of bounds");
107  ASSERTL1(static_cast<unsigned int>(n*incy) <= y.size()+y.GetOffset(),"Array out of bounds");
108  ASSERTL1(static_cast<unsigned int>(n*incz) <= z.size()+z.GetOffset(),"Array out of bounds");
109 
110  Vdiv(n,&x[0],incx,&y[0],incy,&z[0],incz);
111 
112  }
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:104

References ASSERTL1, and Vdiv().

◆ Vdiv() [2/4]

template void Vmath::Vdiv ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Vdiv() [3/4]

template void Vmath::Vdiv ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Vdiv() [4/4]

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 
)

Multiply vector z = x/y.

Definition at line 257 of file Vmath.cpp.

259  {
260  ++n;
261  if (incx == 1 && incy == 1)
262  {
263  while( --n )
264  {
265  *z = (*x) / (*y);
266  ++x;
267  ++y;
268  ++z;
269  }
270  }
271  else
272  {
273  while( --n )
274  {
275  *z = (*x) / (*y);
276  x += incx;
277  y += incy;
278  z += incz;
279  }
280  }
281  }

Referenced by Nektar::DiffusionLDGNS::ApplyBCsO1(), Nektar::NavierStokesCFE::C0Smooth(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SpatialDomains::GeomFactors::ComputeDerivFactors(), Nektar::MMFSWE::ComputeEnstrophy(), Nektar::SpatialDomains::GeomFactors::ComputeGmat(), Nektar::LinearSWE::ConservativeToPrimitive(), Nektar::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::NavierStokesCFE::Ducros(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::VariableConverter::GetEnthalpy(), Nektar::VariableConverter::GetInternalEnergy(), Nektar::VariableConverter::GetMach(), Nektar::FieldUtils::ProcessVorticity::GetVelocity(), Nektar::FieldUtils::ProcessWSS::GetVelocity(), Nektar::NonlinearPeregrine::GetVelocityVector(), Nektar::NonlinearSWE::GetVelocityVector(), Nektar::VariableConverter::GetVelocityVector(), Nektar::FieldUtils::ProcessWSS::GetViscosity(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), main(), Nektar::VCSMapping::MappingPressureCorrection(), Nektar::FieldUtils::ProcessMultiShear::Process(), Nektar::LEE::v_AddLinTerm(), Nektar::SolverUtils::AdvectionFR::v_Advect(), 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::DiffusionLFRNS::v_Diffuse(), Nektar::SolverUtils::DiffusionLFR::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::Diffusion::v_GetPrimVar(), Nektar::ForcingQuasi1D::v_InitObject(), Nektar::LocalRegions::SegExp::v_PhysDeriv_s(), 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(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Vdiv(), Nektar::SpatialDomains::GeomFactors::VectorNormalise(), and Nektar::MMFSWE::WallBoundary2D().

◆ 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 
)

Definition at line 201 of file VmathArray.hpp.

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

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 
)

Definition at line 116 of file Vmath.hpp.

118  {
119  while (n--)
120  {
121  *y = exp( *x );
122  x += incx;
123  y += incy;
124  }
125  }

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 
)

Definition at line 192 of file VmathArray.hpp.

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

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 
)

Definition at line 104 of file Vmath.hpp.

106  {
107  while (n--)
108  {
109  *y = log( *x );
110  x += incx;
111  y += incy;
112  }
113  }

References tinysimd::log().

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

◆ Vmax() [1/5]

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 415 of file VmathArray.hpp.

416  {
417  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
418 
419  return Vmax(n,&x[0],incx);
420  }
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:415

References ASSERTL1, and Vmax().

◆ Vmax() [2/5]

template int Vmath::Vmax ( int  n,
const int *  x,
const int  incx 
)

◆ Vmax() [3/5]

template Nektar::NekDouble Vmath::Vmax ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Vmax() [4/5]

template Nektar::NekSingle Vmath::Vmax ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Vmax() [5/5]

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

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

Definition at line 892 of file Vmath.cpp.

893  {
894 
895  T xmax = *x;
896 
897  while( n-- )
898  {
899  if (*x > xmax)
900  {
901  xmax = *x;
902  }
903  x += incx;
904  }
905 
906  return xmax;
907  }

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::Extrapolate::GetMaxStdVelocity(), Nektar::NavierStokesCFE::GetPhysicalAV(), Nektar::VortexWaveInteraction::GetReflectionIndex(), Nektar::MultiRegions::ExpList::Linf(), main(), MappingEVids(), MoveOutsidePointsNnormpos(), Orderfunctionx(), Nektar::MMFDiffusion::PlanePhiWave(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::FieldUtils::ProcessJacobianEnergy::Process(), Nektar::NonSmoothShockCapture::v_GetArtificialViscosity(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::MMFMaxwell::v_InitObject(), Nektar::FilterBenchmark::v_Update(), Vmax(), and Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotZone().

◆ Vmin() [1/5]

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 451 of file VmathArray.hpp.

452  {
453  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
454 
455  return Vmin(n,&x[0],incx);
456  }
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:451

References ASSERTL1, and Vmin().

◆ Vmin() [2/5]

template int Vmath::Vmin ( int  n,
const int *  x,
const int  incx 
)

◆ Vmin() [3/5]

template Nektar::NekDouble Vmath::Vmin ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Vmin() [4/5]

template Nektar::NekSingle Vmath::Vmin ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Vmin() [5/5]

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

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

Definition at line 992 of file Vmath.cpp.

993  {
994 
995  T xmin = *x;
996 
997  while( n-- )
998  {
999  if (*x < xmin)
1000  {
1001  xmin = *x;
1002  }
1003  x += incx;
1004  }
1005 
1006  return xmin;
1007  }

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::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::FieldUtils::ProcessJacobianEnergy::Process(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::CFLtester::v_GetTimeStep(), Nektar::MMFMaxwell::v_InitObject(), Vmin(), and Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotZone().

◆ Vmul() [1/5]

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 66 of file VmathArray.hpp.

67  {
68  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
69  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
70  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
71 
72 #ifdef NEKTAR_ENABLE_SIMD_VMATH
73  boost::ignore_unused(incx, incy, incz);
74  ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
75  ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
76  ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
77  SIMD::Vmul(n,&x[0],&y[0],&z[0]);
78 #else
79  Vmul(n,&x[0],incx,&y[0],incy,&z[0],incz);
80 #endif
81 
82  }
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:84

References ASSERTL1, Vmath::SIMD::Vmul(), and Vmul().

◆ Vmul() [2/5]

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 84 of file VmathArray.hpp.

85  {
86  ASSERTL1(n*incx <= x.size(),"Array out of bounds");
87  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
88  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
89 
90  Vmul(n,x.origin(),incx,&y[0],incy,&z[0],incz);
91  }

References ASSERTL1, and Vmul().

◆ Vmul() [3/5]

template void Vmath::Vmul ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Vmul() [4/5]

template void Vmath::Vmul ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Vmul() [5/5]

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 
)

Multiply vector z = x*y.

Definition at line 192 of file Vmath.cpp.

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

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::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::AddVariableDepth(), 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::BidomainRoth::DoOdeRhs(), Nektar::MMFDiffusion::DoOdeRhs(), Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::NavierStokesCFE::Ducros(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::SolverUtils::Diffusion::GetDivCurl(), Nektar::ArtificialDiffusion::GetFluxVector(), Nektar::CFLtester::GetFluxVector(), Nektar::EigenValuesAdvection::GetFluxVector(), Nektar::UnsteadyAdvection::GetFluxVector(), Nektar::UnsteadyInviscidBurger::GetFluxVector(), Nektar::ImageWarpingSystem::GetFluxVector(), Nektar::MMFAdvection::GetFluxVector(), Nektar::LinearSWE::GetFluxVector(), Nektar::NonlinearPeregrine::GetFluxVector(), Nektar::NonlinearSWE::GetFluxVector(), Nektar::UnsteadyAdvectionDiffusion::GetFluxVectorAdv(), Nektar::UnsteadyViscousBurgers::GetFluxVectorAdv(), Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias(), Nektar::VariableConverter::GetMach(), 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::LocalRegions::HexExp::IProductWRTDirectionalDerivBase_SumFac(), Nektar::StdRegions::StdExpansion::L2(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), main(), Nektar::StdRegions::StdExpansion::MassMatrixOp_MatFree(), MoveOutsidePointsNnormpos(), Nektar::NekMultiplyDiagonalMatrix(), Nektar::DiffusionLDGNS::NumericalFluxO1(), Nektar::DiffusionLDGNS::NumericalFluxO2(), Nektar::SolverUtils::DiffusionLDG::NumFluxforScalar(), 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::NonlinearPeregrine::PrimitiveToConservative(), Nektar::NonlinearSWE::PrimitiveToConservative(), Nektar::MMFSWE::PrimitiveToConservative(), Nektar::Collections::PrismIProduct(), Nektar::FieldUtils::ProcessCombineAvg::Process(), Nektar::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessWSS::Process(), 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::DiffusionLFRNS::v_Diffuse(), Nektar::SolverUtils::DiffusionLFR::v_Diffuse(), Nektar::GlobalMapping::Mapping::v_Divergence(), Nektar::MultiRegions::PreconditionerDiagonal::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::Geometry2D::v_GetLocCoords(), 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::MMFAdvection::v_InitObject(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::LocalRegions::HexExp::v_Integral(), Nektar::LocalRegions::PrismExp::v_Integral(), Nektar::LocalRegions::PyrExp::v_Integral(), Nektar::LocalRegions::QuadExp::v_Integral(), Nektar::LocalRegions::TetExp::v_Integral(), Nektar::LocalRegions::TriExp::v_Integral(), Nektar::StdRegions::StdSegExp::v_Integral(), Nektar::LocalRegions::SegExp::v_Integral(), Nektar::StdRegions::StdPointExp::v_IProductWRTBase(), Nektar::StdRegions::StdSegExp::v_IProductWRTBase(), Nektar::LocalRegions::SegExp::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::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::SolverUtils::DiffusionLFRNS::v_NumericalFluxO2(), Nektar::SolverUtils::DiffusionLFR::v_NumFluxforVector(), 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::SolverUtils::FilterReynoldsStresses::v_ProcessSample(), Nektar::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofZ::v_RaiseIndex(), Nektar::VCSMapping::v_SetUpPressureForcing(), 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::DiffusionLFR::v_WeakPenaltyforVector(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO2(), Nektar::SpatialDomains::GeomFactors::VectorCrossProd(), Nektar::SolverUtils::MMFSystem::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(), and Nektar::StdRegions::StdExpansion::WeakDirectionalDerivMatrixOp_MatFree().

◆ 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 
)

Definition at line 209 of file VmathArray.hpp.

210  {
211  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
212  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
213 
214  Vpow(n, &x[0], incx, f, &y[0], incy);
215  }
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)
Definition: VmathArray.hpp:209

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 
)

Definition at line 127 of file Vmath.hpp.

129  {
130  while (n--)
131  {
132  *y = pow( *x, f );
133  x += incx;
134  y += incy;
135  }
136  }

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

◆ Vsqrt() [1/4]

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 218 of file VmathArray.hpp.

219  {
220  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
221  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
222 
223  Vsqrt(n,&x[0],incx,&y[0],incy);
224  }
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:218

References ASSERTL1, and Vsqrt().

◆ Vsqrt() [2/4]

template void Vmath::Vsqrt ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
Nektar::NekDouble *  y,
const int  incy 
)

◆ Vsqrt() [3/4]

template void Vmath::Vsqrt ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
Nektar::NekSingle *  y,
const int  incy 
)

◆ Vsqrt() [4/4]

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

sqrt y = sqrt(x)

Definition at line 475 of file Vmath.cpp.

477  {
478  while (n--)
479  {
480  *y = sqrt( *x );
481  x += incx;
482  y += incy;
483  }
484  }

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::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessSurfDistance::Process(), Nektar::FieldUtils::ProcessWSS::Process(), 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::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() [1/3]

template void Vmath::Vstvpp ( int  n,
const Nektar::NekDouble  alpha,
const Nektar::NekDouble *  v,
int  incv,
const Nektar::NekDouble *  w,
int  incw,
const Nektar::NekDouble *  x,
int  incx,
Nektar::NekDouble *  z,
int  incz 
)

◆ Vstvpp() [2/3]

template void Vmath::Vstvpp ( int  n,
const Nektar::NekSingle  alpha,
const Nektar::NekSingle *  v,
int  incv,
const Nektar::NekSingle *  w,
int  incw,
const Nektar::NekSingle *  x,
int  incx,
Nektar::NekSingle *  z,
int  incz 
)

◆ Vstvpp() [3/3]

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 
)

Vstvpp (scalar times vector plus vector plus vector):

Definition at line 723 of file Vmath.cpp.

729  {
730  while( n-- )
731  {
732  *z = alpha * (*v) + (*w) + (*x);
733  v += incv;
734  w += incw;
735  x += incx;
736  z += incz;
737  }
738  }

◆ Vsub() [1/4]

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 152 of file VmathArray.hpp.

153  {
154  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
155  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
156  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
157 
158  Vsub(n,&x[0],incx,&y[0],incy,&z[0],incz);
159 
160  }
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:152

References ASSERTL1, and Vsub().

◆ Vsub() [2/4]

template void Vmath::Vsub ( int  n,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Vsub() [3/4]

template void Vmath::Vsub ( int  n,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Vsub() [4/4]

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 
)

Subtract vector z = x-y.

Definition at line 372 of file Vmath.cpp.

374  {
375  ++n;
376  if (incx == 1 && incy == 1 && incz == 1)
377  {
378  while( --n )
379  {
380  *z = (*x) - (*y);
381  ++x;
382  ++y;
383  ++z;
384  }
385  }
386  else
387  {
388  while( --n )
389  {
390  *z = (*x) - (*y);
391  x += incx;
392  y += incy;
393  z += incz;
394  }
395  }
396  }

Referenced by Nektar::UnsteadyAdvectionDiffusion::AddAdvectionPenaltyFlux(), Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), Nektar::MMFMaxwell::AddPML(), 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::MMFMaxwell::ComputeMaterialMicroWaveCloak(), Nektar::MMFMaxwell::ComputeRadCloak(), Nektar::LinearSWE::ConservativeToPrimitive(), Nektar::NonlinearPeregrine::ConservativeToPrimitive(), Nektar::NonlinearSWE::ConservativeToPrimitive(), Nektar::MMFSWE::ConservativeToPrimitive(), Nektar::MMFMaxwell::DoOdeRhs(), Nektar::MMFAdvection::EvaluateAdvectionVelocity(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::VariableConverter::GetInternalEnergy(), 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::FieldUtils::ProcessCombineAvg::Process(), Nektar::FieldUtils::ProcessDisplacement::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessStreamFunction::Process(), Nektar::FieldUtils::ProcessSurfDistance::Process(), Nektar::FieldUtils::ProcessVorticity::Process(), 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::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_CurlCurl(), Nektar::GlobalMapping::Mapping::v_CurlCurlField(), Nektar::SolverUtils::DiffusionLFR::v_DerCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DerCFlux_2D(), Nektar::SolverUtils::Diffusion3DHomogeneous1D::v_Diffuse(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFR::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DiffusionLFRNS::v_DivCFlux_2D_Gauss(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::LocalRegions::QuadExp::v_FwdTrans_BndConstrained(), Nektar::LocalRegions::TriExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdPointExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdQuadExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdSegExp::v_FwdTrans_BndConstrained(), Nektar::StdRegions::StdTriExp::v_FwdTrans_BndConstrained(), Nektar::LocalRegions::SegExp::v_FwdTrans_BndConstrained(), 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::GlobalMapping::MappingXofXZ::v_RaiseIndex(), Nektar::GlobalMapping::MappingXofZ::v_RaiseIndex(), 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::CourtemancheRamirezNattel98::v_Update(), Nektar::CellModelFitzHughNagumo::v_Update(), Nektar::SolverUtils::FilterEnergy::v_Update(), Nektar::SolverUtils::FilterModalEnergy::v_Update(), Nektar::GlobalMapping::Mapping::v_VelocityLaplacian(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge(), and Vsub().

◆ Vsum() [1/5]

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

Subtract return sum(x)

Definition at line 397 of file VmathArray.hpp.

398  {
399  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
400 
401  return Vsum(n,&x[0],incx);
402  }
Vmath::Vsum
T Vsum(int n, const Array< OneD, const T > &x, const int incx)
Subtract return sum(x)
Definition: VmathArray.hpp:397

References ASSERTL1, and Vsum().

◆ Vsum() [2/5]

template int Vmath::Vsum ( int  n,
const int *  x,
const int  incx 
)

◆ Vsum() [3/5]

template Nektar::NekDouble Vmath::Vsum ( int  n,
const Nektar::NekDouble *  x,
const int  incx 
)

◆ Vsum() [4/5]

template Nektar::NekSingle Vmath::Vsum ( int  n,
const Nektar::NekSingle *  x,
const int  incx 
)

◆ Vsum() [5/5]

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

Subtract return sum(x)

Definition at line 846 of file Vmath.cpp.

847  {
848 
849  T sum = 0;
850 
851  while( n-- )
852  {
853  sum += (*x);
854  x += incx;
855  }
856 
857  return sum;
858  }

Referenced by Nektar::MultiRegions::GlobalLinSysPETSc::CalculateReordering(), Nektar::SolverUtils::MMFSystem::ComputencdotMF(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), Nektar::NavierStokesCFE::Ducros(), Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Nektar::NavierStokesCFE::GetPhysicalAV(), Nektar::StdRegions::StdExpansion2D::Integral(), Nektar::SpatialDomains::Geometry2D::NewtonIterationForLocCoord(), Nektar::SpatialDomains::Geometry3D::NewtonIterationForLocCoord(), Nektar::FieldUtils::ProcessWallNormalData::NewtonIterForLocCoordOnBndElmt(), Nektar::SpatialDomains::MeshPartition::PartitionGraph(), 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(), Vsum(), Nektar::FieldUtils::OutputTecplot::WriteTecplotZone(), and Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotZone().

◆ Vvtvm() [1/4]

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 290 of file VmathArray.hpp.

291  {
292  ASSERTL1(n*incw <= w.size()+w.GetOffset(),"Array out of bounds");
293  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
294  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
295  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
296 
297 
298 
299 #ifdef NEKTAR_ENABLE_SIMD_VMATH
300  boost::ignore_unused(incw, incx, incy, incz);
301  ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
302  ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
303  ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
304  ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
305  SIMD::Vvtvm(n,&w[0],&x[0],&y[0],&z[0]);
306 #else
307  Vvtvm(n,&w[0],incw,&x[0],incx,&y[0],incy,&z[0],incz);
308 #endif
309 
310  }
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:290

References ASSERTL1, Vmath::SIMD::Vvtvm(), and Vvtvm().

◆ Vvtvm() [2/4]

template void Vmath::Vvtvm ( int  n,
const Nektar::NekDouble *  w,
const int  incw,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Vvtvm() [3/4]

template void Vmath::Vvtvm ( int  n,
const Nektar::NekSingle *  w,
const int  incw,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Vvtvm() [4/4]

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 
)

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

Definition at line 541 of file Vmath.cpp.

544  {
545  while( n-- )
546  {
547  *z = (*w) * (*x) - (*y);
548  w += incw;
549  x += incx;
550  y += incy;
551  z += incz;
552  }
553  }

Referenced by Nektar::MMFMaxwell::AddGreenDerivCompensate(), Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::MMFMaxwell::Checkpoint_EDFluxOutput(), Nektar::FieldUtils::ProcessMultiShear::Process(), 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::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo(), Nektar::SpatialDomains::GeomFactors::VectorCrossProd(), Nektar::SolverUtils::MMFSystem::VectorCrossProd(), Vvtvm(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::MMFSWE::WallBoundary2D(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

◆ Vvtvp() [1/5]

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 238 of file VmathArray.hpp.

239  {
240  ASSERTL1(n*incw <= w.size()+w.GetOffset(),"Array out of bounds");
241  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
242  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
243  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
244 
245 #ifdef NEKTAR_ENABLE_SIMD_VMATH
246  boost::ignore_unused(incw, incx, incy, incz);
247  ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
248  ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
249  ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
250  ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
251  SIMD::Vvtvp(n,&w[0],&x[0],&y[0],&z[0]);
252 #else
253  Vvtvp(n,&w[0],incw,&x[0],incx,&y[0],incy,&z[0],incz);
254 #endif
255  }
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)
Definition: VmathArray.hpp:257

References ASSERTL1, Vmath::SIMD::Vvtvp(), and Vvtvp().

◆ Vvtvp() [2/5]

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 
)

Definition at line 257 of file VmathArray.hpp.

258  {
259  ASSERTL1(n*incw <= w.size(),"Array out of bounds");
260  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
261  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
262  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
263 
264  Vvtvp(n,w.origin(),incw,&x[0],incx,&y[0],incy,&z[0],incz);
265  }

References ASSERTL1, and Vvtvp().

◆ Vvtvp() [3/5]

template void Vmath::Vvtvp ( int  n,
const Nektar::NekDouble *  w,
const int  incw,
const Nektar::NekDouble *  x,
const int  incx,
const Nektar::NekDouble *  y,
const int  incy,
Nektar::NekDouble *  z,
const int  incz 
)

◆ Vvtvp() [4/5]

template void Vmath::Vvtvp ( int  n,
const Nektar::NekSingle *  w,
const int  incw,
const Nektar::NekSingle *  x,
const int  incx,
const Nektar::NekSingle *  y,
const int  incy,
Nektar::NekSingle *  z,
const int  incz 
)

◆ Vvtvp() [5/5]

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 
)

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

Definition at line 513 of file Vmath.cpp.

518  {
519  while( n-- )
520  {
521  *z = (*w) * (*x) + (*y);
522  w += incw;
523  x += incx;
524  y += incy;
525  z += incz;
526  }
527  }

Referenced by Nektar::SubSteppingExtrapolate::AddAdvectionPenaltyFlux(), Nektar::SolverUtils::MMFSystem::AdddedtMaxwell(), Nektar::MMFMaxwell::AddPML(), Nektar::MMFSWE::AddRotation(), Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), 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::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::Extrapolate::GetMaxStdVelocity(), Nektar::UnsteadyAdvectionDiffusion::GetNormalVel(), Nektar::CFLtester::GetNormalVelocity(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), Nektar::UnsteadyViscousBurgers::GetNormalVelocity(), Nektar::SolverUtils::MMFSystem::GramSchumitz(), Nektar::StdRegions::StdExpansion::H1(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_MatFree(), main(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Nektar::PreconCfsBRJ::MinusOffDiag2Rhs(), 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::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessQCriterion::Process(), Nektar::FieldUtils::ProcessScalGrad::Process(), Nektar::FieldUtils::ProcessSurfDistance::Process(), Nektar::FieldUtils::ProcessWSS::Process(), 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::TetExp::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::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::Geometry2D::v_GetLocCoords(), Nektar::SpatialDomains::Geometry3D::v_GetLocCoords(), Nektar::AcousticSystem::v_GetMaxStdVelocity(), Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity(), Nektar::LocalRegions::Expansion2D::v_GetnEdgecdotMF(), Nektar::LocalRegions::Expansion3D::v_GetnFacecdotMF(), 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::LocalRegions::PyrExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::TetExp::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::SolverUtils::DiffusionLFRNS::v_NumericalFluxO1(), Nektar::SolverUtils::DiffusionLFRNS::v_NumericalFluxO2(), 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::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::AcousticSystem::v_WallBC(), Nektar::SolverUtils::MMFSystem::VectorAvgMagnitude(), Nektar::SolverUtils::MMFSystem::VectorDotProd(), Nektar::SpatialDomains::GeomFactors::VectorNormalise(), Vvtvp(), 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/3]

template void Vmath::Vvtvvtm ( int  n,
const Nektar::NekDouble *  v,
int  incv,
const Nektar::NekDouble *  w,
int  incw,
const Nektar::NekDouble *  x,
int  incx,
const Nektar::NekDouble *  y,
int  incy,
Nektar::NekDouble *  z,
int  incz 
)

◆ Vvtvvtm() [2/3]

template void Vmath::Vvtvvtm ( int  n,
const Nektar::NekSingle *  v,
int  incv,
const Nektar::NekSingle *  w,
int  incw,
const Nektar::NekSingle *  x,
int  incx,
const Nektar::NekSingle *  y,
int  incy,
Nektar::NekSingle *  z,
int  incz 
)

◆ Vvtvvtm() [3/3]

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 
)

vvtvvtm (vector times vector minus vector times vector):

Definition at line 658 of file Vmath.cpp.

664  {
665  while( n-- )
666  {
667  *z = (*v) * (*w) - (*x) * (*y);
668  v += incv;
669  w += incw;
670  x += incx;
671  y += incy;
672  z += incz;
673  }
674  }

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

◆ Vvtvvtp() [1/4]

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 + y*z

Definition at line 313 of file VmathArray.hpp.

320  {
321  ASSERTL1(n*incv <= v.size()+v.GetOffset(),"Array out of bounds");
322  ASSERTL1(n*incw <= w.size()+w.GetOffset(),"Array out of bounds");
323  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
324  ASSERTL1(n*incy <= y.size()+y.GetOffset(),"Array out of bounds");
325  ASSERTL1(n*incz <= z.size()+z.GetOffset(),"Array out of bounds");
326 
327 #ifdef NEKTAR_ENABLE_SIMD_VMATH
328  boost::ignore_unused(incv, incw, incx, incy, incz);
329  ASSERTL1(incw == 1, "Simd vmath requires inc = 1");
330  ASSERTL1(incx == 1, "Simd vmath requires inc = 1");
331  ASSERTL1(incy == 1, "Simd vmath requires inc = 1");
332  ASSERTL1(incz == 1, "Simd vmath requires inc = 1");
333  SIMD::Vvtvvtp(n,&v[0],&w[0],&x[0],&y[0],&z[0]);
334 #else
335  Vvtvvtp(n,&v[0],incv,&w[0],incw,&x[0],incx,&y[0],incy,&z[0],incz);
336 #endif
337  }
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 + y*z
Definition: VmathArray.hpp:313

References ASSERTL1, Vmath::SIMD::Vvtvvtp(), and Vvtvvtp().

◆ Vvtvvtp() [2/4]

template void Vmath::Vvtvvtp ( int  n,
const Nektar::NekDouble *  v,
int  incv,
const Nektar::NekDouble *  w,
int  incw,
const Nektar::NekDouble *  x,
int  incx,
const Nektar::NekDouble *  y,
int  incy,
Nektar::NekDouble *  z,
int  incz 
)

◆ Vvtvvtp() [3/4]

template void Vmath::Vvtvvtp ( int  n,
const Nektar::NekSingle *  v,
int  incv,
const Nektar::NekSingle *  w,
int  incw,
const Nektar::NekSingle *  x,
int  incx,
const Nektar::NekSingle *  y,
int  incy,
Nektar::NekSingle *  z,
int  incz 
)

◆ Vvtvvtp() [4/4]

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 
)

vvtvvtp (vector times vector plus vector times vector):

Definition at line 625 of file Vmath.cpp.

631  {
632  while( n-- )
633  {
634  *z = (*v) * (*w) + (*x) * (*y);
635  v += incv;
636  w += incw;
637  x += incx;
638  y += incy;
639  z += incz;
640  }
641  }

Referenced by Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::SolverUtils::RiemannSolver::rotateFromNormal(), Nektar::SolverUtils::RiemannSolver::rotateToNormal(), Nektar::SolverUtils::AdvectionFR::v_Advect(), Nektar::LocalRegions::PyrExp::v_ComputeLaplacianMetric(), Nektar::LocalRegions::TetExp::v_ComputeLaplacianMetric(), Nektar::SolverUtils::AdvectionFR::v_DivCFlux_2D(), Nektar::LEE::v_GetFluxVector(), Nektar::FilterElectrogram::v_Initialise(), Nektar::LocalRegions::HexExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::PyrExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::QuadExp::v_LaplacianMatrixOp_MatFree_Kernel(), Nektar::LocalRegions::TetExp::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/6]

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

Zero vector.

Definition at line 175 of file VmathArray.hpp.

176  {
177  ASSERTL1(n*incx <= x.size()+x.GetOffset(),"Array out of bounds");
178 
179  Zero(n,&x[0],incx);
180 
181  }
Vmath::Zero
void Zero(int n, Array< OneD, T > &x, const int incx)
Zero vector.
Definition: VmathArray.hpp:175

References ASSERTL1, and Zero().

◆ Zero() [2/6]

template void Vmath::Zero ( int  n,
int *  x,
const int  incx 
)

◆ Zero() [3/6]

template void Vmath::Zero ( int  n,
long *  x,
const int  incx 
)

◆ Zero() [4/6]

template void Vmath::Zero ( int  n,
Nektar::NekDouble *  x,
const int  incx 
)

◆ Zero() [5/6]

template void Vmath::Zero ( int  n,
Nektar::NekSingle *  x,
const int  incx 
)

◆ Zero() [6/6]

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

Zero vector.

Definition at line 436 of file Vmath.cpp.

437  {
438  if(incx == 1)
439  {
440  std::memset(x,'\0', n*sizeof(T));
441  }
442  else
443  {
444  T zero = 0;
445  ++n;
446  while(--n)
447  {
448  *x = zero;
449  x+=incx;
450  }
451  }
452  }

Referenced by Nektar::CFSImplicit::AddMatNSBlkDiagVol(), Nektar::SolverUtils::DiffusionIP::AddSecondDerivToTrace(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToCoeff(), Nektar::SolverUtils::Diffusion::AddSymmFluxIntegralToOffDiag(), Nektar::SolverUtils::DiffusionIP::AddSymmFluxIntegralToPhys(), Nektar::MultiRegions::ExpList::AddTraceJacToElmtJac(), 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::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LinearisedAdvection::DFT(), Nektar::LibUtilities::NekLinSysIterCG::DoConjugateGradient(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGMRES(), Nektar::UnsteadyReactionDiffusion::DoOdeRhs(), Nektar::Dummy::DoOdeRhs(), Nektar::MultiRegions::GlobalLinSysIterative::DoProjection(), Nektar::NekMatrix< DataType, StandardMatrixTag >::EigenSolve(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_big(), Nektar::GlobalMapping::Mapping::EvaluateFunction(), Nektar::IsentropicVortexBC::EvaluateIsentropicVortex(), Nektar::IsentropicVortex::EvaluateIsentropicVortex(), Nektar::MMFSWE::EvaluateWaterDepth(), ExpList_LoadField(), Nektar::SolverUtils::CouplingCwipi::ExtrapolateFields(), Nektar::VariableConverter::GetAbsoluteVelocity(), Nektar::SolverUtils::Diffusion::GetDivCurl(), Nektar::VariableConverter::GetDynamicEnergy(), Nektar::MultiRegions::ExpList::GetElmtNormalLength(), Nektar::LinearSWE::GetFluxVector(), Nektar::SolverUtils::MMFSystem::GetIncidentField(), Nektar::MultiRegions::ExpList::GetMatIpwrtDeriveBase(), Nektar::Extrapolate::GetMaxStdVelocity(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux1D(), Nektar::SolverUtils::MMFSystem::GetMaxwellFlux2D(), Nektar::UnsteadyAdvectionDiffusion::GetNormalVel(), Nektar::CFLtester::GetNormalVelocity(), Nektar::EigenValuesAdvection::GetNormalVelocity(), Nektar::MMFAdvection::GetNormalVelocity(), Nektar::UnsteadyAdvection::GetNormalVelocity(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::ImageWarpingSystem::GetNormalVelocity(), Nektar::UnsteadyViscousBurgers::GetNormalVelocity(), Nektar::SolverUtils::EquationSystem::ImportFld(), Nektar::SolverUtils::EquationSystem::ImportFldToMultiDomains(), Nektar::Collections::IProductWRTDerivBase_StdMat::IProductWRTDerivBase_StdMat(), Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree(), Nektar::StdRegions::StdExpansion::LinearAdvectionDiffusionReactionMatrixOp_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::ProcessC0Projection::Process(), Nektar::FieldUtils::ProcessHomogeneousStretch::Process(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::FieldUtils::ProcessMultiShear::Process(), Nektar::FieldUtils::ProcessScalGrad::Process(), Nektar::FieldUtils::ProcessSurfDistance::Process(), Nektar::FieldUtils::ProcessWSS::Process(), Nektar::FieldUtils::Iso::SeparateRegions(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::VelocityCorrectionScheme::SetupFlowrate(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::NavierStokesCFE::SpecialBndTreat(), Diffusion::TimeIntegrate(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::TimeIntegrate(), Nektar::LinearisedAdvection::UpdateBase(), Nektar::FilterMovingBody::UpdateForce(), Nektar::LEE::v_AddLinTerm(), Nektar::NoAdvection::v_Advect(), Nektar::StagnationInflowBC::v_Apply(), 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::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::SolverUtils::EquationSystem::v_EvaluateExactSolution(), Nektar::LocalRegions::HexExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::PrismExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::QuadExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TetExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::TriExp::v_ExtractDataToCoeffs(), Nektar::LocalRegions::SegExp::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::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::MMFDiffusion::v_SetInitialConditions(), Nektar::SolverUtils::EquationSystem::v_SetInitialConditions(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::SolverUtils::FilterEnergy::v_Update(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO1(), Nektar::SolverUtils::DiffusionLFRNS::v_WeakPenaltyO2(), Zero(), and Nektar::SolverUtils::EquationSystem::ZeroPhysFields().

Generated on Wed Nov 24 2021 10:33:38 for Nektar++ by doxygen 1.9.1