Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

TET::Func Namespace Reference

Namespace for "classical" mathematical functions. More...

Functions

Detailed Description

Namespace for "classical" mathematical functions.

This namespace groups all routines for the computation of mathematical functions. The functions are non-O-O style, i.e. are controlled by arguments rather than attributes for parameters like accuracy, etc..

These functions usually are utilized by the objects from the TET::Math namespace.

Function Documentation

double Bin (  const int  i,
const int  n,
const double  t
)  [inline]
 

Bernstein Polynomial.

This is a wrapper function for convenience so that the result vector need not be specified. Please note that this means a significant runtime penalty for most applications since for the most common case of the evaluation of a Bezier curve, the whole set of function values for 0<=i<=n is needed anyway.

Parameters:
i number of Polynomial (0<=i<=n)
n degree of Polynomial (n>=0)
t parameter value (point on Bezier curve, 0<=t<=1)
Precondition:
non-negative i: i>=0

maximum i is n: i<=n

Postcondition:
minimum function value is 0: result>=0

maximum function value is 1: result<=1

Returns:
Bernstein Polynomial value at t

Definition at line 1084 of file tetfunc.h.

References Bin().

void TET::Func::Bin (  const int  n,
const double  t,
std::vector< double > *  b
) 
 

Bernstein Polynomials.

Bernstein Polynomials $\mathrm{B}_i^n(t)$ are the basis functions for Bezier curves and surfaces and defined as

\[\mathrm{B}_i^n(t)={n \choose i}t^i\left(1-t\right)^{n-i}\;,\]

or recursively, as used in this function, as

\[\mathrm{B}_i^n(t)=\left(1-t\right)\mathrm{B}_i^{n-1}(t) \mathrm{B}_{i-1}^{n-1}(t)\;.\]

The function values $\mathrm{B}_i^n(t)$ are stored in a linear vector to save space. Since it holds that 0 <= i <= n, there are 1+n*(n+1)/2 elements of the vector (beginning with index 0). To access $\mathrm{B}_i^n(t)$, the index into the vector is [n*(n+1)/2+i]: Bin = b[n*(n+1)/2+i].

Parameters:
n maximum degree of the Bernstein Polynomials
t real argument
b pointer to a vector that will hold all the intermediate function values to lower orders computed during the recurrence. The vector will be cleared and resized during the computation.
Precondition:
non-negative degree: n>=0

argument in unit interval: t>=0.0 && t<=1.0

Definition at line 816 of file tetfunc.cpp.

Referenced by Bin().

std::complex<double> dhn1 (  const int  n,
const double  x
)  [inline]
 

Derivative of the spherical Hankel function of the first kind to integer order and real argument.

This function utilizes the wrapper functions for the Bessel and Neumann functions, so the same runtime considerations apply. For maximum performance, compute the function using the basic routines jn() and yn(), respectively.

Parameters:
n integer order (n = 0,1,2,...)
x real argument (x > 0)
Precondition:
non-negative order: n>=0

non-negative argument: x>=0.0

Returns:
complex function value
See also:
jn(), yn()

Definition at line 846 of file tetfunc.h.

References djn(), and dyn().

std::complex<double> dhn2 (  const int  n,
const double  x
)  [inline]
 

Derivative of the spherical Hankel function of the second kind to integer order and real argument.

This function utilizes the wrapper functions for the Bessel and Neumann functions, so the same runtime considerations apply. For maximum performance, compute the function using the basic routines jn() and yn(), respectively.

Parameters:
n integer order (n = 0,1,2,...)
x real argument (x > 0)
Returns:
complex function value

Definition at line 891 of file tetfunc.h.

References djn(), and dyn().

std::complex<double> dhv1 (  const double  v,
const double  x
)  [inline]
 

Derivative of the Spherical Hankel Function of the first kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
real function value

Definition at line 571 of file tetfunc.h.

References jyv().

std::complex<double> dHv1 (  const double  v,
const double  x
)  [inline]
 

Derivative of the Hankel Function of the first kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
complex function value

Definition at line 257 of file tetfunc.h.

References JYv().

std::complex<double> dhv2 (  const double  v,
const double  x
)  [inline]
 

Derivative of the Spherical Hankel Function of the second kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
real function value

Definition at line 633 of file tetfunc.h.

References jyv().

std::complex<double> dHv2 (  const double  v,
const double  x
)  [inline]
 

Derivative of the Hankel Function of the second kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
complex function value

Definition at line 319 of file tetfunc.h.

References JYv().

double djn (  const int  n,
const double  x
)  [inline]
 

Derivative of the spherical Bessel Function to integer order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since two vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function jn() and reuse the vectors.

Parameters:
n integer order
x real argument
Precondition:
non-negative order: n>=0
Returns:
real function value

Definition at line 737 of file tetfunc.h.

References jn().

Referenced by dhn1(), dhn2(), and jn().

double djv (  const double  v,
const double  x
)  [inline]
 

Derivative of the Spherical Bessel Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
real function value

Definition at line 447 of file tetfunc.h.

References jyv().

Referenced by jyv().

double dJv (  const double  v,
const double  x
)  [inline]
 

Derivative of Bessel Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
real function value

Definition at line 134 of file tetfunc.h.

References JYv().

Referenced by JYv().

double dPnm (  const int  n,
const int  m,
const double  x
)  [inline]
 

Derivative of Associated Legendre Function to integer order and degree and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since two vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function Pnm()and reuse the vectors.

Parameters:
n integer degree
m integer order
x real argument
Precondition:
non-negative degree: n>=0

order between -n and +n: m<=n && m>=-n

argument in [-1,1]: abs(x)<=1.0

Returns:
real function value of derivative

Definition at line 980 of file tetfunc.h.

References Pnm().

double dyn (  const int  n,
const double  x
)  [inline]
 

Derivative of the spherical Neumann Function to integer order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since two vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function yn() and reuse the vectors.

Parameters:
n integer order
x real argument
Precondition:
non-negative order: n>=0

non-negative argument: x>=0.0

Returns:
real function value

Definition at line 794 of file tetfunc.h.

References yn().

Referenced by dhn1(), dhn2(), and yn().

double dyv (  const double  v,
const double  x
)  [inline]
 

Derivative of the Spherical Neumann Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order (v >= 0)
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
real function value

Definition at line 509 of file tetfunc.h.

References jyv().

Referenced by jyv().

double dYv (  const double  v,
const double  x
)  [inline]
 

Derivative of Neumann Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
real function value

Definition at line 195 of file tetfunc.h.

References JYv().

Referenced by JYv().

double envj (  const double  n,
const double  x
)  [inline]
 

Definition at line 44 of file tetfunc.cpp.

Referenced by mStart1(), and mStart2().

unsigned int epsilon_n (  const unsigned long &  n  )  [inline]
 

Neumann numbers.

The neumann numbers $\varepsilon_n$ are defined as

\[\varepsilon_n=\left\{ \begin{array}{c@{\,,\,}c} 1 & n=0 \\ 2 & n>0 \end{array}\right.\,.\]

The main use is with fourier series where they allow for a unified notation of the sum including the mean value belonging to the coefficient with n=0.

Parameters:
n coefficient index
Returns:
1, if n is zero, 2 otherwise

Definition at line 1143 of file tetfunc.h.

double TET::Func::gamma (  const double  x  ) 
 

Gamma function.

Argument must not be zero or a negative integer. It holds that $\Gamma(n+1) = n!$, i.e. the gamma function interpolates the faculties of integers.

Parameters:
x real argument
Precondition:
argument not zero or a negative integer: !(x==static_cast(x) && x<=0.0)
Returns:
gamma function of argument

Definition at line 851 of file tetfunc.cpp.

References TET::abs().

Referenced by JYv(), and Pvm().

std::complex<double> hn1 (  const int  n,
const double  x
)  [inline]
 

Spherical Hankel function of the first kind to integer order and real argument.

This function utilizes the wrapper functions for the Bessel and Neumann functions, so the same runtime considerations apply. For maximum performance, compute the function using the basic routines jn() and yn(), respectively.

Parameters:
n integer order
x real argument
Precondition:
non-negative order: n>=0

non-negative argument: x>=0.0

Returns:
complex function value

Definition at line 821 of file tetfunc.h.

References jn(), and yn().

std::complex<double> hn2 (  const int  n,
const double  x
)  [inline]
 

Spherical Hankel function of the second kind to integer order and real argument.

This function utilizes the wrapper functions for the Bessel and Neumann functions, so the same runtime considerations apply. For maximum performance, compute the function using the basic routines jn() and yn(), respectively().

Parameters:
n integer order
x real argument
Precondition:
non-negative order: n>=0

non-negative argument: x>=0.0

Returns:
complex function value

Definition at line 871 of file tetfunc.h.

References jn(), and yn().

std::complex<double> hv1 (  const double  v,
const double  x
)  [inline]
 

Spherical Hankel Function of the first kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
complex function value

Definition at line 540 of file tetfunc.h.

References jyv().

std::complex<double> Hv1 (  const double  v,
const double  x
)  [inline]
 

Hankel Function of the first kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
complex function value

Definition at line 226 of file tetfunc.h.

References JYv().

std::complex<double> hv2 (  const double  v,
const double  x
)  [inline]
 

Spherical Hankel Function of the second kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
complex function value

Definition at line 602 of file tetfunc.h.

References jyv().

std::complex<double> Hv2 (  const double  v,
const double  x
)  [inline]
 

Hankel Function of the second kind to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
complex function value

Definition at line 288 of file tetfunc.h.

References JYv().

double jn (  const int  n,
const double  x
)  [inline]
 

Spherical Bessel Function to integer order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since two vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function jn() and reuse the vectors.

Parameters:
n integer order
x real argument
Precondition:
non-negative order: n>=0
Returns:
real function value

Definition at line 709 of file tetfunc.h.

References jn().

int TET::Func::jn (  const int  n,
const double  x,
std::vector< double > *  jn,
std::vector< double > *  djn
) 
 

Spherical Bessel Function to integer order and real argument.

Parameters:
n order
x real argument
jn pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
djn pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
Precondition:
non-negative order: n>=0
Returns:
The maximum order computed

Definition at line 355 of file tetfunc.cpp.

References TET::abs(), djn(), jn(), mStart1(), and mStart2().

Referenced by djn(), hn1(), hn2(), and jn().

double jv (  const double  v,
const double  x
)  [inline]
 

Spherical Bessel Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>=0.0

Returns:
real function value

Definition at line 416 of file tetfunc.h.

References jyv().

Referenced by jyv().

double Jv (  const double  v,
const double  x
)  [inline]
 

Bessel Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
real function value

Definition at line 103 of file tetfunc.h.

References JYv().

Referenced by JYv().

double jyv (  const double  v,
const double  x,
std::vector< double > *  jv,
std::vector< double > *  djv,
std::vector< double > *  yv,
std::vector< double > *  dyv
)  [inline]
 

Spherical Bessel (jv) and Neumann (yv) Functions to arbitrary real order and real argument.

The function values are computed using the relation to ordinary Bessel and Neumann functions computed by JYv() . The real order v is split into an integer part n and a real part v0 with n=0,1,2,... and 0<=v0<1. The return vectors are organized like: Jv[n]=$\mathrm{J}_{n+\nu_0}$ with n=0,1,2,... .

The runtime overhead due to the computation using the ordinary cylinder functions should be negligible compared to any user code doing the transformation, so there's no need for optimization here.

If the order to be computed is integer, use the faster specialized algorithms of jn() and yn().

Parameters:
x real argument
v order of jv and yv (v=n+v0, n=0,1,2,... , 0<=v0<1)
jv pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
djv pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
yv pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
dyv pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
Precondition:
positive argument: x>0.0

non-negative index: v>=0.0

Returns:
The maximum order computed
See also:
JYv

jn

yn

Definition at line 378 of file tetfunc.h.

References djv(), dyv(), jv(), JYv(), and yv().

Referenced by dhv1(), dhv2(), djv(), dyv(), hv1(), hv2(), jv(), and yv().

double TET::Func::JYv (  const double &  v,
const double &  x,
std::vector< double > *  Jv,
std::vector< double > *  dJv,
std::vector< double > *  Yv,
std::vector< double > *  dYv
) 
 

Bessel (Jv) and Neumann (Yv) Functions to arbitrary real order and real argument.

The function values are computed using recurrence relations. For this reason, the real order v is split into an integer part n and a real part v0 with n = 0,1,2,... and 0 <= v0 < 1. The return vectors are organized like: Jv[n]=$\mathrm{J}_{n+\nu_0}$ with n=0,1,2,... .

Parameters:
x real argument
v order of Jv and Yv (v=n+v0, n=0,1,2,... , 0<=v0<1)
Jv pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
dJv pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
Yv pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
dYv pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
The maximum order computed

Definition at line 105 of file tetfunc.cpp.

References TET::abs(), dJv(), dYv(), gamma(), Jv(), mStart1(), mStart2(), and Yv().

Referenced by dHv1(), dHv2(), dJv(), dYv(), TET::Math::Cylinder_Function::find_or_create(), Hv1(), Hv2(), Jv(), jyv(), and Yv().

int mStart1 (  double  x,
int  magnitude
) 
 

Definition at line 50 of file tetfunc.cpp.

References TET::abs(), and envj().

Referenced by jn(), and JYv().

int mStart2 (  double  x,
int  n,
int  sigDigits
) 
 

Definition at line 72 of file tetfunc.cpp.

References TET::abs(), and envj().

Referenced by jn(), and JYv().

double Pnm (  const int  n,
const int  m,
const double  x
)  [inline]
 

Associated Legendre Function to integer order and degree and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since two vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function Pnm() and reuse the vectors.

Parameters:
n integer degree
m integer order
x real argument
Precondition:
non-negative degree: n>=0

order between -n and +n: m<=n && m>=-n

argument in [-1,1]: abs(x)<=1.0

Returns:
real function value

Definition at line 949 of file tetfunc.h.

References Pnm().

void TET::Func::Pnm (  const int  n,
const int  m,
const double  x,
std::vector< double > *  p,
std::vector< double > *  dp
) 
 

Associated Legendre function of integer degree n and integer order m to real argument x.

The function values $\mathrm{P}_n^m(x)$ are stored in a linear vector to save space. Since it holds that -n <= m <= +n, there are n*n+n+m+1 elements of the vector (beginning with index 0). To access $\mathrm{P}_i^j(x)$, the index into the vector is [i*i+i+j]: Pij = p[i*i+i+j].

Parameters:
n integer degree of associated Legendre function
m integer order of associated Legendre function
x real argument
p pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
dp pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
Precondition:
non-negative degree: n>=0

order between -n and +n: m<=n && m>=-n

argument in [-1,1]: abs(x)<=1.0

Definition at line 469 of file tetfunc.cpp.

References TET::abs().

Referenced by dPnm(), and Pnm().

double TET::Func::psi (  const double  x  ) 
 

Psi or Digamma function.

The psi function is defined by $\psi(x) = \frac{d}{dx}\ln\Gamma(x)$.

Parameters:
x real argument
Returns:
psi function of argument

Definition at line 917 of file tetfunc.cpp.

Referenced by Pvm().

void TET::Func::Pvm (  const double  v,
const int  m,
const double  x,
std::vector< double > *  p
) 
 

Associated Legendre function of arbitrary degree v and integer order m to real, non-negative argument x.

This function provides the values of Associated Legendre functions of arbitary, non-negative degree to subsequent integer orders m = 0,1,2,... by using a very efficient and stable recurrence algorithm. Note, however, that this algorithm converges slowly in the vicinity of zero.

Parameters:
v arbitrary degree of associated Legendre function
m maximum integer order of associated Legendre function to be computed
x real argument
p pointer to a vector that will hold all the intermediate function values to higher orders computed using reccurence relations. The vector will be cleared and resized during the computation.
Precondition:
non-negative degree: v>=0.0

non-negative order: m>=0

positive argument in unit interval: x>0.0 && x<=1.0

Definition at line 686 of file tetfunc.cpp.

References TET::abs(), and gamma().

double TET::Func::Pvm (  const double  v,
const int  m,
const double  x
) 
 

Associated Legendre function of arbitrary degree v and integer order m to real argument x.

Parameters:
v degree
m integer order
x real argument
Precondition:
non-negative degree: v>=0.0

argument in [-1,1]: abs(x)<=1.0

non-negative order: m>=0

Returns:
real function value

Definition at line 575 of file tetfunc.cpp.

References TET::abs(), and psi().

double yn (  const int  n,
const double  x
)  [inline]
 

Spherical Neumann Function to integer order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since two vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function yn() and reuse the vectors.

Parameters:
n integer order
x real argument
Precondition:
non-negative order: n>=0

non-negative argument: x>=0

Returns:
real function value

Definition at line 765 of file tetfunc.h.

References yn().

int TET::Func::yn (  const int  n,
const double  x,
std::vector< double > *  yn,
std::vector< double > *  dyn
) 
 

Spherical Neumann Function to integer order and real argument.

Parameters:
n integer order
x real argument
yn pointer to a vector that will hold all the intermediate function values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
dyn pointer to a vector that will hold all the intermediate derivative values to lower orders computed during the reccurence. The vector will be cleared and resized during the computation.
Precondition:
non-negative order: n>=0

non-negative argument: x>=0.0

Returns:
The maximum order computed

Definition at line 429 of file tetfunc.cpp.

References TET::abs(), dyn(), and yn().

Referenced by dyn(), hn1(), hn2(), and yn().

double yv (  const double  v,
const double  x
)  [inline]
 

Spherical Neumann Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes some runtime overhead. If maximum performance is needed, stick to the original function jyv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative order: v>=0.0

positive argument: x>0.0

Returns:
real function value

Definition at line 478 of file tetfunc.h.

References jyv().

Referenced by jyv().

double Yv (  const double  v,
const double  x
)  [inline]
 

Neumann Function to arbitrary order and real argument.

This is a wrapper for convenience so that the user doesn't have to specify the result vectors first. However, since four vectors are to be instantiated, this function imposes a little runtime overhead. If maximum performance is needed, stick to the original function JYv() and reuse the vectors.

Parameters:
v real order
x real argument
Precondition:
non-negative argument: x>=0.0

non-negative index: v>=0.0

Returns:
real function value

Definition at line 164 of file tetfunc.h.

References JYv().

Referenced by JYv().

Generated on Sun Apr 25 11:57:36 2004 for TETlib by doxygen 1.3.6