ACCELERATOR PHYSICS GROUP

Other Documented Items

Typedefs

typedef OscillatingField<ConstEzField> AcceleratingField;
The electromagnetic field of an RF cavity.

A homogeneous field in z-direction, oscillating in time. An instance of the template class OscillatingField.

typedef TBeamline<FlaggedElmPtr> FlaggedBeamline;
A beam line with flagged elements.

An example of a beamline sequence constructed from FlaggedElmPtr objects. Such a sequence could be used to build a design model with possible flagging of the contained objects.

typedef SingleMultipole<4> Octupole;
Representation for a straight (normal) Octupole.

An instantiation of template SingleMultipole<int>.

typedef SingleMultipole<2> Quadrupole;
Representation for a straight (normal) quadrupole.

An instantiation of template SingleMultipole<int>.

typedef SingleMultipole<3> Sextupole;
Representation for a straight (normal) Sextupole.

An instantiation of template SingleMultipole<int>.

typedef TBeamline<ElmPtr> SimpleBeamline;
A beam line representation.

An example of a beamline sequence constructed from ElmPtr objects. Such a sequence could be used to build a simple design model of a beamline.

typedef SingleMultipole<-4> SkewOctupole;
Representation for a skewed octupole.

An instantiation of template SingleMultipole<int>.

typedef SingleMultipole<-2> SkewQuadrupole;
Representation for a skewed quadrupole.

An instantiation of template SingleMultipole<int>.

typedef SingleMultipole<-3> SkewSextupole;
Representation for a skewed sextupole.

An instantiation of template SingleMultipole<int>.

Functions

FVps<T,N> ExpMap(const FTps<T,N>&) ;
Build the exponential series.

Return the series exp(:H:) Z, the Lie transform exp(:H:) acting on the identity map.

FTps<T,N> ExpMap(const FTps<T,N>&,const FTps<T,N>&) ;
Build the exponential series.

Return the series exp(:H:)M from the FTps<T,N> H, acting on the function f.

FVps<T,N> ExpMap(const FTps<T,N>&,const FVps<T,N>&) ;
Build the exponential series.

Return the series exp(:H:) M, the Lie transform exp(:H:) acting on the map M.

extern double Gauss(double,double,double,double) ;
Gaussian density function.

Arguments:

sigx
the standard deviation in x-direction.
sigy
the standard deviation in y-direction.
x
the bias in x-direction.
y
the bias in y-direction.
Return value: Gaussian density

exp(-(x/sigx)^2 - (y/sigy)^2) / (2 pi * sigx * sigy)

inline Euclid3D Inverse(const Euclid3D&) ;
Euclidian inverse.

extern double InverseGauss(double) ;
Inverse Gaussian density function.

The inverse function of <br> y = Phi(x) = 2 * integral exp(-x^2) * dx / sqrt(pi) <br>
Argument: A value y between -1 and +1.
Return value: the value x .

Tps<T> PoissonBracket(const Tps<T>&,const Tps<T>&) ;
Poisson bracket.

Vps<T> PoissonBracket(const Tps<T>&,const Vps<T>&) ;
Poisson bracket.

FTps<T,N> PoissonBracket(const FTps<T,N>&,const FTps<T,N>&) ;
Poisson bracket.

FVps<T,N> PoissonBracket(const FTps<T,N>&,const FVps<T,N>&) ;
Poisson bracket.

Taylor<T> PoissonBracket(const Taylor<T>&,const Taylor<T>&) ;
Poisson bracket of two Taylor seriess.

For this function the coefficients must have a Poisson bracket operation.

FLieGenerator<T,N> PoissonBracket(const FLieGenerator<T,N>&,const FLieGenerator<T,N>&) ;
Poisson bracket of two Lie generators.

extern std::complex<double> Werrf(std::complex<double>) ;
Complex error function.

The algorithms is based on: Walter Gautschi, Efficient Computation of the Complex Error Function,

SIAM J. Numer. Anal., Vol 7, No. 1, March 1970, pp. 187-198.
Argument: the complex argument, Return value: the complex value of the error function.

inline double abssum(complex<double>) ;

void cdiv(double,double,double,double,double&,double&) ;

Tps<T> cos(const Tps<T>&) ;
Cosine.

FTps<T,N> cos(const FTps<T,N>&) ;
Cosine.

LinearFun<T,N> cos(const LinearFun<T,N>&) ;
Cosine.

TransportFun<T,N> cos(const TransportFun<T,N>&) ;
Cosine.

Tps<T> cosh(const Tps<T>&) ;
Hyperbolic cosine.

FTps<T,N> cosh(const FTps<T,N>&) ;
Hyperbolic cosine.

LinearFun<T,N> cosh(const LinearFun<T,N>&) ;
Hyperbolic cosine.

TransportFun<T,N> cosh(const TransportFun<T,N>&) ;
Hyperbolic cosine.

Tps<T> cot(const Tps<T>&) ;
Cotangent.

FTps<T,N> cot(const FTps<T,N>&) ;
Cotangent.

LinearFun<T,N> cot(const LinearFun<T,N>&) ;
Cotangent.

TransportFun<T,N> cot(const TransportFun<T,N>&) ;
Cotangent.

extern Vector3D cross(const Vector3D&,const Vector3D&) ;
Vector cross product.

Tps<T> csc(const Tps<T>&) ;
Cosecant.

FTps<T,N> csc(const FTps<T,N>&) ;
Cosecant.

LinearFun<T,N> csc(const LinearFun<T,N>&) ;
Cosecant.

TransportFun<T,N> csc(const TransportFun<T,N>&) ;
Cosecant.

extern double dot(const Vector3D&,const Vector3D&) ;
Vector dot product.

T euclidian_norm(const Vector<T>&) ;
Euclidian norm.

T euclidian_norm(const FVector<T,N>&) ;
Euclidian norm.

Tps<T> exp(const Tps<T>&) ;
Exponential.

FTps<T,N> exp(const FTps<T,N>&) ;
Exponential.

LinearFun<T,N> exp(const LinearFun<T,N>&) ;
Exponential.

TransportFun<T,N> exp(const TransportFun<T,N>&) ;
Exponential.

FLieGenerator<T,N> imag(const FLieGenerator<complex<T>,N>&) ;
Take imaginary part of a complex generator.

inline std::random_access_iterator_tag iterator_category(const SliceIterator<T>&) ;

inline std::random_access_iterator_tag iterator_category(const ConstSliceIterator<T>&) ;

inline std::random_access_iterator_tag iterator_category(const FSlice<T,S>&) ;

inline std::random_access_iterator_tag iterator_category(const FConstSlice<T,S>&) ;

Tps<T> log(const Tps<T>&) ;
Natural logarithm.

FTps<T,N> log(const FTps<T,N>&) ;
Natural logarithm.

LinearFun<T,N> log(const LinearFun<T,N>&) ;
Natural logarithm.

TransportFun<T,N> log(const TransportFun<T,N>&) ;
Natural logarithm.

bool operator!=(const T&,const FTps<T,N>&) ;
Inequality.

bool operator!=(const T&,const LinearFun<T,N>&) ;
Inequality.

bool operator!=(const T&,const TransportFun<T,N>&) ;
Inequality.

Matrix<T> operator*(const Matrix<T>&,const Matrix<T>&) ;
Matrix multiply.

Vector<T> operator*(const Matrix<T>&,const Vector<T>&) ;
Matrix times column vector.

Vector<T> operator*(const Vector<T>&,const Matrix<T>&) ;
Row vector times matrix.

Matrix<T> operator*(const Matrix<T>&,const T&) ;
Matrix times scalar.

Matrix<T> operator*(const T&,const Matrix<T>&) ;
Scalar times matrix.

Tps<T> operator*(const Tps<T>&,const Tps<T>&) ;
Multiply.

Tps<T> operator*(const Tps<T>&,const T&) ;
Multiply.

Tps<T> operator*(const T&,const Tps<T>&) ;
Multiply.

T operator*(const Vector<T>&,const Vector<T>&) ;
Vector dot product.

Vector<T> operator*(const Vector<T>&,const T&) ;
Vector multiplied by scalar.

Vector<T> operator*(const T&,const Vector<T>&) ;
Scalar multiplied by vector.

Vps<T> operator*(const Vps<T>&,const Tps<T>&) ;

Vps<T> operator*(const Tps<T>&,const Vps<T>&) ;
Multiply.

Vps<T> operator*(const Vps<T>&,const T&) ;
Multiply.

Vps<T> operator*(const T&,const Vps<T>&) ;
Multiply.

VpsInvMap<T> operator*(const VpsInvMap<T>&,const Tps<T>&) ;
{ Global Operators on VpsInvMap<T> Multiply.

VpsInvMap<T> operator*(const Tps<T>&,const VpsInvMap<T>&) ;
Multiply.

VpsInvMap<T> operator*(const VpsInvMap<T>&,const T&) ;
Multiply.

VpsInvMap<T> operator*(const T&,const VpsInvMap<T>&) ;
Multiply.

VpsInvMap<T> operator*(const Matrix<T>&,const VpsInvMap<T>&) ;
Multiply.

VpsMap<T> operator*(const VpsMap<T>&,const Tps<T>&) ;
Multiply.

VpsMap<T> operator*(const Tps<T>&,const VpsMap<T>&) ;
Multiply.

VpsMap<T> operator*(const VpsMap<T>&,const T&) ;
Multiply.

VpsMap<T> operator*(const T&,const VpsMap<T>&) ;
Multiply.

inline VpsMap<T> operator*(const Matrix<T>&,const VpsMap<T>&) ;
Substitute.

Matrix3D operator*(const Matrix3D&,const Matrix3D&) ;
Multiply.

Vector3D operator*(const Matrix3D&,const Vector3D&) ;
Multiply.

extern Vector3D operator*(const Vector3D&,double) ;
Multiply.

extern Vector3D operator*(double,const Vector3D&) ;
Multiply.

FVector<T,R> operator*(const FMatrix<T,R,C>&,const FVector<T,C>&) ;
Multiply by column vector.

FVector<T,C> operator*(const FVector<T,R>&,const FMatrix<T,R,C>&) ;
Row vector times Matrix.

FMatrix<T,R,C> operator*(const FMatrix<T,R,C>&,const T&) ;
Matrix times scalar.

FMatrix<T,R,C> operator*(const T&,const FMatrix<T,R,C>&) ;
Scalar times Matrix.

FMatrix<T,R,C> operator*(const FMatrix<T,R,I>&,const FMatrix<T,I,C>&) ;

FTps<T,N> operator*(const FTps<T,N>&,const FTps<T,N>&) ;
Multiply.

FTps<T,N> operator*(const FTps<T,N>&,const T&) ;
Multiply.

FTps<T,N> operator*(const T&,const FTps<T,N>&) ;
Multiply.

T operator*(const FVector<T,N>&,const FVector<T,N>&) ;
Dot product.

FVector<T,N> operator*(const FVector<T,N>&,const T&) ;
Multiply.

FVector<T,N> operator*(const T&,const FVector<T,N>&) ;
Multiply.

FVps<T,N> operator*(const FVps<T,N>&,const FTps<T,N>&) ;
Multiply.

FVps<T,N> operator*(const FTps<T,N>&,const FVps<T,N>&) ;
Multiply.

FVps<T,N> operator*(const FVps<T,N>&,const T&) ;
Multiply.

FVps<T,N> operator*(const T&,const FVps<T,N>&) ;
Multiply.

FVps<T,N> operator*(const FMatrix<T,N,N>&,const FVps<T,N>&) ;
Multiply.

LinearFun<T,N> operator*(const LinearFun<T,N>&,const LinearFun<T,N>&) ;
Multiply.

LinearFun<T,N> operator*(const LinearFun<T,N>&,const T&) ;
Multiply.

LinearFun<T,N> operator*(const T&,const LinearFun<T,N>&) ;
Multiply.

LinearMap<T,N> operator*(const LinearMap<T,N>&,const LinearFun<T,N>&) ;
Multiply.

LinearMap<T,N> operator*(const LinearFun<T,N>&,const LinearMap<T,N>&) ;
Multiply.

LinearMap<T,N> operator*(const LinearMap<T,N>&,const T&) ;
Multiply.

LinearMap<T,N> operator*(const T&,const LinearMap<T,N>&) ;
Multiply.

LinearMap<T,N> operator*(const FMatrix<T,N,N>&,const LinearMap<T,N>&) ;
Multiply.

TransportFun<T,N> operator*(const TransportFun<T,N>&,const TransportFun<T,N>&) ;
Multiply.

TransportFun<T,N> operator*(const TransportFun<T,N>&,const T&) ;
Multiply.

TransportFun<T,N> operator*(const T&,const TransportFun<T,N>&) ;
Multiply.

TransportMap<T,N> operator*(const TransportMap<T,N>&,const TransportFun<T,N>&) ;
Multiply.

TransportMap<T,N> operator*(const TransportFun<T,N>&,const TransportMap<T,N>&) ;
Multiply.

TransportMap<T,N> operator*(const TransportMap<T,N>&,const T&) ;
Multiply.

TransportMap<T,N> operator*(const T&,const TransportMap<T,N>&) ;
Multiply.

TransportMap<T,N> operator*(const FMatrix<T,N,N>&,const TransportMap<T,N>&) ;
Multiply.

Taylor<T> operator*(const Taylor<T>&,double) ;
Multiply by scalar.

Taylor<T> operator*(double,const Taylor<T>&) ;
Multiply by scalar.

FLieGenerator<T,N> operator*(const FLieGenerator<T,N>&,const T&) ;
Multiply by scalar.

FLieGenerator<T,N> operator*(const T&,const FLieGenerator<T,N>&) ;
Multiply by scalar.

FLieGenerator<T,N> operator*(const FLieGenerator<T,N>&,const FLieGenerator<T,N>&) ;
Multiply by Lie generator.

Matrix<T> operator+(const Matrix<T>&,const Matrix<T>&) ;
Matrix addition.

Tps<T> operator+(const Tps<T>&,const Tps<T>&) ;
Add.

Tps<T> operator+(const Tps<T>&,const T&) ;
Add.

Tps<T> operator+(const T&,const Tps<T>&) ;
Add.

Vector<T> operator+(const Vector<T>&,const Vector<T>&) ;
Vector addition.

Vps<T> operator+(const Vps<T>&,const Vps<T>&) ;
Add.

Vps<T> operator+(const Vps<T>&,const Vector<T>&) ;
Add.

Vps<T> operator+(const Vector<T>&,const Vps<T>&) ;
Add.

VpsInvMap<T> operator+(const VpsInvMap<T>&,const VpsInvMap<T>&) ;
Add.

VpsInvMap<T> operator+(const VpsInvMap<T>&,const Vector<T>&) ;
Add.

VpsInvMap<T> operator+(const Vector<T>&,const VpsInvMap<T>&) ;
Add.

VpsMap<T> operator+(const VpsMap<T>&,const VpsMap<T>&) ;
Add.

VpsMap<T> operator+(const VpsMap<T>&,const Vector<T>&) ;
Add.

VpsMap<T> operator+(const Vector<T>&,const VpsMap<T>&) ;
Add.

Matrix3D operator+(const Matrix3D&,const Matrix3D&) ;
Add.

extern Vector3D operator+(const Vector3D&,const Vector3D&) ;
Add.

FMatrix<T,R,C> operator+(const FMatrix<T,R,C>&,const FMatrix<T,R,C>&) ;
Add.

FMatrix<T,C,C> operator+(const FMatrix<T,C,C>&,const T&) ;
Add unit matrix times t to matrix.

FTps<T,N> operator+(const FTps<T,N>&,const FTps<T,N>&) ;
Add.

FTps<T,N> operator+(const FTps<T,N>&,const T&) ;
Add.

FTps<T,N> operator+(const T&,const FTps<T,N>&) ;
Add.

FVector<T,N> operator+(const FVector<T,N>&,const FVector<T,N>&) ;
Add.

FVps<T,N> operator+(const FVps<T,N>&,const FVps<T,N>&) ;
Add.

FVps<T,N> operator+(const FVps<T,N>&,const FVector<T,N>&) ;
Add.

FVps<T,N> operator+(const FVector<T,N>&,const FVps<T,N>&) ;
Add.

LinearFun<T,N> operator+(const LinearFun<T,N>&,const LinearFun<T,N>&) ;
Add.

LinearFun<T,N> operator+(const LinearFun<T,N>&,const T&) ;
Add.

LinearFun<T,N> operator+(const T&,const LinearFun<T,N>&) ;
Add.

LinearMap<T,N> operator+(const LinearMap<T,N>&,const LinearMap<T,N>&) ;
Add.

LinearMap<T,N> operator+(const LinearMap<T,N>&,const FVector<T,N>&) ;
Add.

LinearMap<T,N> operator+(const FVector<T,N>&,const LinearMap<T,N>&) ;
Add.

TransportFun<T,N> operator+(const TransportFun<T,N>&,const TransportFun<T,N>&) ;
Add.

TransportFun<T,N> operator+(const TransportFun<T,N>&,const T&) ;
Add.

TransportFun<T,N> operator+(const T&,const TransportFun<T,N>&) ;
Add.

TransportMap<T,N> operator+(const TransportMap<T,N>&,const TransportMap<T,N>&) ;
Add.

TransportMap<T,N> operator+(const TransportMap<T,N>&,const FVector<T,N>&) ;
Add.

TransportMap<T,N> operator+(const FVector<T,N>&,const TransportMap<T,N>&) ;
Add.

Taylor<T> operator+(const Taylor<T>&,const Taylor<T>&) ;
Add.

FLieGenerator<T,N> operator+(const FLieGenerator<T,N>&,const FLieGenerator<T,N>&) ;
Add.

Matrix<T> operator-(const Matrix<T>&,const Matrix<T>&) ;
Matrix subtraction.

Matrix<T> operator-(const Matrix<T>&) ;
Matrix unary minus.

Matrix<T> operator-(const Matrix<T>) ;

Tps<T> operator-(const Tps<T>&,const Tps<T>&) ;
Subtract.

Tps<T> operator-(const Tps<T>&,const T&) ;
Subtract.

Tps<T> operator-(const T&,const Tps<T>&) ;
Subtract.

Vector<T> operator-(const Vector<T>&,const Vector<T>&) ;
Vector subtraction.

Vps<T> operator-(const Vps<T>&,const Vps<T>&) ;
Subtract.

Vps<T> operator-(const Vps<T>&,const Vector<T>&) ;
Subtract.

Vps<T> operator-(const Vector<T>&,const Vps<T>&) ;
Subtract.

VpsInvMap<T> operator-(const VpsInvMap<T>&,const VpsInvMap<T>&) ;
Subtract.

VpsInvMap<T> operator-(const VpsInvMap<T>&,const Vector<T>&) ;
Subtract.

VpsInvMap<T> operator-(const Vector<T>&,const VpsInvMap<T>&) ;
Subtract.

VpsMap<T> operator-(const VpsMap<T>&,const VpsMap<T>&) ;
Subtract.

VpsMap<T> operator-(const VpsMap<T>&,const Vector<T>&) ;
Subtract.

VpsMap<T> operator-(const Vector<T>&,const VpsMap<T>&) ;
Subtract.

Matrix3D operator-(const Matrix3D&,const Matrix3D&) ;
Subtract.

extern Vector3D operator-(const Vector3D&,const Vector3D&) ;
Subtract.

FMatrix<T,R,C> operator-(const FMatrix<T,R,C>&) ;
Unary minus.

FMatrix<T,R,C> operator-(const FMatrix<T,R,C>&,const FMatrix<T,R,C>&) ;
Subtract.

FMatrix<T,C,C> operator-(const FMatrix<T,C,C>&,const T&) ;
Subtract unit matrix times t from matrix.

FTps<T,N> operator-(const FTps<T,N>&,const FTps<T,N>&) ;
Subtract.

FTps<T,N> operator-(const FTps<T,N>&,const T&) ;
Subtract.

FTps<T,N> operator-(const T&,const FTps<T,N>&) ;
Subtract.

FVector<T,N> operator-(const FVector<T,N>&,const FVector<T,N>&) ;
Subtract.

FVps<T,N> operator-(const FVps<T,N>&,const FVps<T,N>&) ;
Subtract.

FVps<T,N> operator-(const FVps<T,N>&,const FVector<T,N>&) ;
Subtract.

FVps<T,N> operator-(const FVector<T,N>&,const FVps<T,N>&) ;
Subtract.

LinearFun<T,N> operator-(const LinearFun<T,N>&,const LinearFun<T,N>&) ;
Subtract.

LinearFun<T,N> operator-(const LinearFun<T,N>&,const T&) ;
Subtract.

LinearFun<T,N> operator-(const T&,const LinearFun<T,N>&) ;
Subtract.

LinearMap<T,N> operator-(const LinearMap<T,N>&,const LinearMap<T,N>&) ;
Subtract.

LinearMap<T,N> operator-(const LinearMap<T,N>&,const FVector<T,N>&) ;
Subtract.

LinearMap<T,N> operator-(const FVector<T,N>&,const LinearMap<T,N>&) ;
Subtract.

TransportFun<T,N> operator-(const TransportFun<T,N>&,const TransportFun<T,N>&) ;
Subtract.

TransportFun<T,N> operator-(const TransportFun<T,N>&,const T&) ;
Subtract.

TransportFun<T,N> operator-(const T&,const TransportFun<T,N>&) ;
Subtract.

TransportMap<T,N> operator-(const TransportMap<T,N>&,const TransportMap<T,N>&) ;
Subtract.

TransportMap<T,N> operator-(const TransportMap<T,N>&,const FVector<T,N>&) ;
Subtract.

TransportMap<T,N> operator-(const FVector<T,N>&,const TransportMap<T,N>&) ;
Subtract.

Taylor<T> operator-(const Taylor<T>&,const Taylor<T>&) ;
Subtract.

FLieGenerator<T,N> operator-(const FLieGenerator<T,N>&,const FLieGenerator<T,N>&) ;
Subtract.

Matrix<T> operator/(const Matrix<T>&,const T&) ;
Matrix divided by scalar.

Tps<T> operator/(const Tps<T>&,const Tps<T>&) ;
Divide.

Tps<T> operator/(const Tps<T>&,const T&) ;
Divide.

Tps<T> operator/(const T&,const Tps<T>&) ;
Divide.

Vector<T> operator/(const Vector<T>&,const T&) ;
Vector divided by scalar.

Vps<T> operator/(const Vps<T>&,const Tps<T>&) ;
Divide.

Throw DivideError, if constant part of y is zero.

Vps<T> operator/(const Vps<T>&,const T&) ;
Divide.

Throw DivideError, if y is zero.

VpsInvMap<T> operator/(const VpsInvMap<T>&,const Tps<T>&) ;
Divide.

Throw DivideError, if constant part of y is zero.

VpsInvMap<T> operator/(const VpsInvMap<T>&,const T&) ;
Divide.

Throw DivideError, if y is zero.

VpsMap<T> operator/(const VpsMap<T>&,const Tps<T>&) ;
Divide.

Throw DivideError if constant part of y is zero.

VpsMap<T> operator/(const VpsMap<T>&,const T&) ;
Divide.

Throw DivideError if y is zero.

FMatrix<T,R,C> operator/(const FMatrix<T,R,C>&,const T&) ;
Matrix divided by scalar.

FTps<T,N> operator/(const FTps<T,N>&,const FTps<T,N>&) ;
Divide.

FTps<T,N> operator/(const FTps<T,N>&,const T&) ;
Divide.

FTps<T,N> operator/(const T&,const FTps<T,N>&) ;
Divide 1 / FTps.

FVector<T,N> operator/(const FVector<T,N>&,const T&) ;
Divide.

FVps<T,N> operator/(const FVps<T,N>&,const FTps<T,N>&) ;
Divide.

Throw DivideError, if constant part of rhs is zero.

FVps<T,N> operator/(const FVps<T,N>&,const T&) ;
Divide.

Throw DivideError, if rhs is zero.

LinearFun<T,N> operator/(const LinearFun<T,N>&,const LinearFun<T,N>&) ;
Divide.

LinearFun<T,N> operator/(const LinearFun<T,N>&,const T&) ;
Divide.

LinearFun<T,N> operator/(const T&,const LinearFun<T,N>&) ;
Divide 1 / LinearFun.

LinearMap<T,N> operator/(const LinearMap<T,N>&,const LinearFun<T,N>&) ;
Divide.

Throw DivideError, if constant part of rhs is zero.

LinearMap<T,N> operator/(const LinearMap<T,N>&,const T&) ;
Divide.

Throw DivideError, if rhs is zero.

TransportFun<T,N> operator/(const TransportFun<T,N>&,const TransportFun<T,N>&) ;
Divide.

TransportFun<T,N> operator/(const TransportFun<T,N>&,const T&) ;
Divide.

TransportFun<T,N> operator/(const T&,const TransportFun<T,N>&) ;
Divide 1 / TransportFun.

TransportMap<T,N> operator/(const TransportMap<T,N>&,const TransportFun<T,N>&) ;
Divide.

Throw DivideError, if constant part of rhs is zero.

TransportMap<T,N> operator/(const TransportMap<T,N>&,const T&) ;
Divide.

Throw DivideError, if rhs is zero.

Taylor<T> operator/(const Taylor<T>&,double) ;
Divide by scalar.

FLieGenerator<T,N> operator/(const FLieGenerator<T,N>&,const T&) ;
Divide by scalar.

std::ostream& operator<<(std::ostream&,const Array2D<T>&) ;

std::ostream& operator<<(std::ostream&,const Array1D<T>&) ;

std::ostream& operator<<(std::ostream&,const LieMap<T>&) ;
Insert LieMap<T> to stream.

std::ostream& operator<<(std::ostream&,const Tps<T>&) ;
Insert to stream.

std::ostream& operator<<(std::ostream&,const Vps<T>&) ;
Insert to stream.

std::ostream& operator<<(std::ostream&,const VpsInvMap<T>&) ;
Insert to stream.

std::ostream& operator<<(std::ostream&,const VpsMap<T>&) ;
Insert to stream.

std::ostream& operator<<(std::ostream&,const PartBunch&) ;

std::ostream& operator<<(std::ostream&,const FArray2D<T,M,N>&) ;

std::ostream& operator<<(std::ostream&,const FArray1D<T,N>&) ;

std::ostream& operator<<(std::ostream&,const FTps<T,N>&) ;
Insert FTps to stream os.

std::ostream& operator<<(std::ostream&,const FVps<T,N>&) ;
Insert FVps to stream os.

std::ostream& operator<<(std::ostream&,const LinearFun<T,N>&) ;
Insert LinearFun to stream os.

std::ostream& operator<<(std::ostream&,const LinearMap<T,N>&) ;
Insert LinearMap to stream os.

std::ostream& operator<<(std::ostream&,const TransportFun<T,N>&) ;
Insert TransportFun to stream os.

ostream& operator<<(ostream&,const DragtFinnMap<N>&) ;

ostream& operator<<(ostream&,const Taylor<T>&) ;
Output.

ostream& operator<<(ostream&,const FLieGenerator<T,N>&) ;
Output.

inline std::ostream& operator<<(std::ostream&,const Statement&) ;

std::ostream& operator<<(std::ostream&,const Token&) ;

bool operator==(const T&,const Tps<T>&) ;
Test for equality.

bool operator==(const T&,const FTps<T,N>&) ;
Equality.

bool operator==(const T&,const LinearFun<T,N>&) ;
Equality.

bool operator==(const T&,const TransportFun<T,N>&) ;
Equality.

std::istream& operator>>(std::istream&,LieMap<T>&) ;
Extract LieMap<T> from stream.

std::istream& operator>>(std::istream&,Tps<T>&) ;
Extract from stream.

std::istream& operator>>(std::istream&,Vps<T>&) ;
Extract from stream.

std::istream& operator>>(std::istream&,VpsInvMap<T>&) ;
Extract from stream.

std::istream& operator>>(std::istream&,VpsMap<T>&) ;
Extract from stream.

std::istream& operator>>(std::istream&,FTps<T,N>&) ;
Extract FTps from stream is.

std::istream& operator>>(std::istream&,FVps<T,N>&) ;
Extract FVps from stream is.

std::istream& operator>>(std::istream&,LinearFun<T,N>&) ;
Extract LinearFun from stream is.

std::istream& operator>>(std::istream&,LinearMap<T,N>&) ;
Extract LinearMap from stream is.

std::istream& operator>>(std::istream&,TransportFun<T,N>&) ;
Extract TransportFun from stream is.

Tps<T> pow(const Tps<T>&,int) ;
Integer power.

FTps<T,N> pow(const FTps<T,N>&,int) ;
Tps x to the power (int y).

LinearFun<T,N> pow(const LinearFun<T,N>&,int) ;
Power (int y).

TransportFun<T,N> pow(const TransportFun<T,N>&,int) ;
Power (int y).

FLieGenerator<T,N> real(const FLieGenerator<complex<T>,N>&) ;
Take real part of a complex generator.

T scaled_norm(const Array1D<T>,const Vector<T>&) ;
Euclidian norm of diagonal matrix D times vector V.

T scaled_norm(const FArray1D<T,N>,const FVector<T,N>&) ;
Euclidian norm of diagonal matrix D times FVector V.

Tps<T> sec(const Tps<T>&) ;
Secant.

FTps<T,N> sec(const FTps<T,N>&) ;
Secant.

LinearFun<T,N> sec(const LinearFun<T,N>&) ;
Secant.

TransportFun<T,N> sec(const TransportFun<T,N>&) ;
Secant.

Tps<T> sin(const Tps<T>&) ;
Sine.

FTps<T,N> sin(const FTps<T,N>&) ;
Sine.

LinearFun<T,N> sin(const LinearFun<T,N>&) ;
Sine.

TransportFun<T,N> sin(const TransportFun<T,N>&) ;
Sine.

Tps<T> sinh(const Tps<T>&) ;
Hyperbolic sine.

FTps<T,N> sinh(const FTps<T,N>&) ;
Hyperbolic sine.

LinearFun<T,N> sinh(const LinearFun<T,N>&) ;
Hyperbolic sine.

TransportFun<T,N> sinh(const TransportFun<T,N>&) ;
Hyperbolic sine.

Tps<T> sqrt(const Tps<T>&) ;
Square root.

FTps<T,N> sqrt(const FTps<T,N>&) ;
Square root.

LinearFun<T,N> sqrt(const LinearFun<T,N>&) ;
Square root.

TransportFun<T,N> sqrt(const TransportFun<T,N>&) ;
Square root.

Tps<T> tan(const Tps<T>&) ;
Tangent.

FTps<T,N> tan(const FTps<T,N>&) ;
Tangent.

LinearFun<T,N> tan(const LinearFun<T,N>&) ;
Tangent.

TransportFun<T,N> tan(const TransportFun<T,N>&) ;
Tangent.

Tps<T> tanh(const Tps<T>&) ;
Hyperbolic tangent.

FTps<T,N> tanh(const FTps<T,N>&) ;
Hyperbolic tangent.

LinearFun<T,N> tanh(const LinearFun<T,N>&) ;
Hyperbolic tangent.

TransportFun<T,N> tanh(const TransportFun<T,N>&) ;
Hyperbolic tangent.

FLieGenerator<complex<T>,N> toComplex(const FLieGenerator<T,N>&) ;
Convert real generator to complex.

inline T* value_type(const SliceIterator<T>&) ;

inline T* value_type(const ConstSliceIterator<T>&) ;

inline T* value_type(const FSlice<T,S>&) ;

inline T* value_type(const FConstSlice<T,S>&) ;

Globals

static const int maxran;

const int nr;

const double tol;

Documentation generated by fci on Mon Feb 7 11:41:59 2000