Namespaces
	tmpl

Classes
struct	Abs

struct	AbsExpression

struct	AbsFunctExpression

struct	AbsStruct

struct	AuxProduct

struct	AuxProduct< Prod, false >

struct	AuxProductRatio

struct	AuxProductRatio2

struct	AuxProductRatio2< Prod, false >

struct	AuxProductRatio< Prod, false >

struct	AuxSum

struct	AuxSum< Prod, false >

struct	AuxSumRatio

struct	AuxSumRatio< A, B, C, true >

struct	BreitWigner

struct	Composition

struct	CompositionStruct

struct	ConstPrimitive

struct	ConstPrimitive< X, F, true >

struct	Convolution

class	ConvolutionStruct

struct	Cos

struct	Cos2

struct	Cos< MinusStruct< A > >

struct	CosStruct

struct	DecomposePower

struct	DecomposePower< A, Numerical< 1 > >

struct	DecomposeProduct

struct	DecomposeProduct< A, A >

struct	DecomposeProduct< ProductStruct< A, B >, A >

struct	DecomposeProduct< ProductStruct< A, B >, B >

struct	DefaultVariable

struct	DefIntegral

struct	DefIntegral< F, MIN, MAX, Integrator, no_var >

struct	DefIntegral< F, MIN, MAX, no_var, no_var >

struct	DefIntegral< F, MIN, MAX, no_var, X >

struct	Derivative

struct	Derivative< X, AbsStruct< A > >

struct	Derivative< X, CosStruct< A > >

struct	Derivative< X, ExpStruct< A > >

struct	Derivative< X, LogStruct< A > >

struct	Derivative< X, MinusStruct< A > >

struct	Derivative< X, PowerStruct< A, FractionStruct< n, m > > >

struct	Derivative< X, PowerStruct< A, Numerical< n > > >

struct	Derivative< X, ProductStruct< A, B > >

struct	Derivative< X, RatioStruct< A, B > >

struct	Derivative< X, SinStruct< A > >

struct	Derivative< X, SqrtStruct< A > >

struct	Derivative< X, SumStruct< A, B > >

struct	Derivative< X, TanStruct< A > >

struct	Derivative< X, X >

struct	Difference

struct	Difference< A, MinusStruct< B > >

struct	Difference< FractionStruct< a, b >, FractionStruct< c, d > >

struct	Difference< Numerical< a >, FractionStruct< b, c > >

struct	Difference< Numerical< n >, Numerical< m > >

struct	Exp

struct	Exp< LogStruct< A > >

struct	Exponential

struct	Expression

struct	ExpressionT

struct	ExpStruct

struct	FactorizeSum

struct	Fraction

struct	Fraction< n, m, false, false >

struct	Fraction< n, m, false, true >

struct	Fraction< n, m, true, false >

struct	FractionStruct

struct	FunctExpression

struct	FunctExpressionT

struct	Function

struct	Function< X1, null_var, null_var >

struct	Function< X1, X2, null_var >

struct	GammaPropagator

struct	GammaZInterference

struct	Gaussian

class	GaussIntegrator

class	GaussLegendreIntegrator

class	HistoPdf

struct	Identity

struct	Independent

struct	Integral

struct	IntegralStruct

struct	IntegralStruct< F >

struct	Log

struct	Log< ExpStruct< A > >

struct	Log< PowerStruct< A, B > >

struct	Log< ProductStruct< A, B > >

struct	Log< RatioStruct< A, B > >

struct	LogStruct

struct	Master

struct	Minus

struct	Minus< MinusStruct< A > >

struct	Minus< Numerical< n > >

struct	Minus< SumStruct< A, B > >

struct	MinusStruct

struct	NthDerivative

struct	NthDerivative< 0, X, F >

struct	NthDerivative< 1, X, F >

struct	Number

struct	Numerical

struct	NumericalIntegral

struct	NumericalIntegral< Integrator, F, no_var >

struct	NumPower

struct	NumPower< 1, m, posM >

struct	NumPower< n, 0, true >

struct	NumPower< n, 1, true >

struct	NumPower< n, m, false >

class	Parameter

struct	Parametric

struct	Parametric< AbsStruct< A > >

struct	Parametric< CosStruct< A > >

struct	Parametric< DefaultVariable >

struct	Parametric< ExpStruct< A > >

struct	Parametric< FractionStruct< n, m > >

struct	Parametric< LogStruct< A > >

struct	Parametric< MinusStruct< A > >

struct	Parametric< Numerical< n > >

struct	Parametric< PowerStruct< A, B > >

struct	Parametric< ProductStruct< A, B > >

struct	Parametric< RatioStruct< A, B > >

struct	Parametric< SgnStruct< A > >

struct	Parametric< SinStruct< A > >

struct	Parametric< SumStruct< A, B > >

struct	Parametric< TanStruct< A > >

struct	Parametric< X >

struct	Parametric< Y >

struct	Parametric< Z >

struct	ParametricDiv1

struct	ParametricDivN

struct	ParametricSimplifiedSum

struct	ParametricSimplifiedSum< 1, 1, A, false >

struct	ParametricSimplifiedSum< 1, 1, A, true >

struct	ParametricSimplifiedSum< n, m, A, false >

struct	PartIntegral

struct	PartIntegral2

class	Polynomial

class	Polynomial< 0 >

class	Polynomial< 1 >

class	Polynomial< 2 >

struct	PositiveFraction

struct	PositiveFraction< n, m, gcd, num, 1 >

struct	Power

struct	Power< A, FractionStruct< 1, 2 > >

struct	Power< A, Numerical< -1 > >

struct	Power< A, Numerical< 0 > >

struct	Power< A, Numerical< 1 > >

struct	Power< A, Numerical< n > >

struct	Power< Numerical< n >, Numerical< m > >

struct	Power< PowerStruct< A, B >, C >

struct	Power< PowerStruct< A, B >, Numerical< n > >

struct	Power< ProductStruct< A, B >, Numerical< 0 > >

struct	PowerStruct

struct	Primitive

struct	Primitive< F >

struct	Primitive< Parameter >

struct	Product

struct	Product< A, A >

struct	Product< A, MinusStruct< B > >

struct	Product< A, Numerical< n > >

struct	Product< A, PowerStruct< A, B > >

struct	Product< A, PowerStruct< A, Numerical< n > > >

struct	Product< A, ProductStruct< B, C > >

struct	Product< A, RatioStruct< B, C > >

struct	Product< CosStruct< A >, A >

struct	Product< CosStruct< A >, SinStruct< A > >

struct	Product< CosStruct< A >, TanStruct< A > >

struct	Product< ExpStruct< A >, A >

struct	Product< ExpStruct< A >, ExpStruct< B > >

struct	Product< FractionStruct< a, b >, FractionStruct< c, d > >

struct	Product< FractionStruct< b, c >, Numerical< a > >

struct	Product< FractionStruct< n, m >, RatioStruct< A, Numerical< k > > >

struct	Product< LogStruct< A >, A >

struct	Product< MinusStruct< A >, B >

struct	Product< MinusStruct< A >, MinusStruct< A > >

struct	Product< MinusStruct< A >, MinusStruct< B > >

struct	Product< Numerical< -1 >, A >

struct	Product< Numerical< -1 >, Numerical< n > >

struct	Product< Numerical< 0 >, A >

struct	Product< Numerical< 0 >, Numerical< 1 > >

struct	Product< Numerical< 0 >, Numerical< n > >

struct	Product< Numerical< 0 >, ProductStruct< A, B > >

struct	Product< Numerical< 0 >, RatioStruct< A, B > >

struct	Product< Numerical< 1 >, A >

struct	Product< Numerical< 1 >, FractionStruct< n, m > >

struct	Product< Numerical< 1 >, MinusStruct< A > >

struct	Product< Numerical< 1 >, Numerical< 1 > >

struct	Product< Numerical< 1 >, Numerical< n > >

struct	Product< Numerical< 1 >, ProductStruct< A, B > >

struct	Product< Numerical< 1 >, RatioStruct< A, B > >

struct	Product< Numerical< a >, FractionStruct< b, c > >

struct	Product< Numerical< n >, MinusStruct< A > >

struct	Product< Numerical< n >, Numerical< m > >

struct	Product< Numerical< n >, Numerical< n > >

struct	Product< Numerical< n >, RatioStruct< A, B > >

struct	Product< PowerStruct< A, B >, A >

struct	Product< PowerStruct< A, B >, PowerStruct< A, B > >

struct	Product< PowerStruct< A, B >, PowerStruct< A, C > >

struct	Product< PowerStruct< A, Numerical< n > >, A >

struct	Product< PowerStruct< CosStruct< A >, B >, PowerStruct< TanStruct< A >, B > >

struct	Product< PowerStruct< CosStruct< A >, Numerical< n > >, PowerStruct< TanStruct< A >, Numerical< n > > >

struct	Product< ProductStruct< A, B >, MinusStruct< C > >

struct	Product< ProductStruct< A, B >, Numerical< n > >

struct	Product< ProductStruct< A, B >, ProductStruct< A, B > >

struct	Product< ProductStruct< A, B >, ProductStruct< C, D > >

struct	Product< ProductStruct< F, G >, H >

struct	Product< RatioStruct< A, B >, C >

struct	Product< RatioStruct< A, B >, Numerical< n > >

struct	Product< RatioStruct< A, B >, ProductStruct< C, D > >

struct	Product< RatioStruct< A, B >, RatioStruct< C, D > >

struct	Product< SinStruct< A >, A >

struct	Product< TanStruct< A >, A >

struct	ProductPrimitive

struct	ProductStruct

struct	Ratio

struct	Ratio< A, A >

struct	Ratio< A, Numerical< 1 > >

struct	Ratio< A, Numerical< n > >

struct	Ratio< A, PowerStruct< A, B > >

struct	Ratio< A, PowerStruct< A, Numerical< n > > >

struct	Ratio< A, RatioStruct< B, C > >

struct	Ratio< C, ProductStruct< A, B > >

struct	Ratio< FractionStruct< a, b >, FractionStruct< c, d > >

struct	Ratio< FractionStruct< b, c >, Numerical< a > >

struct	Ratio< MinusStruct< A >, B >

struct	Ratio< MinusStruct< A >, Numerical< n > >

struct	Ratio< Numerical< 0 >, A >

struct	Ratio< Numerical< a >, FractionStruct< b, c > >

struct	Ratio< Numerical< n >, Numerical< 1 > >

struct	Ratio< Numerical< n >, Numerical< m > >

struct	Ratio< Numerical< n >, Numerical< n > >

struct	Ratio< PowerStruct< A, B >, A >

struct	Ratio< PowerStruct< A, B >, PowerStruct< A, B > >

struct	Ratio< PowerStruct< A, B >, PowerStruct< A, C > >

struct	Ratio< PowerStruct< A, Numerical< n > >, A >

struct	Ratio< ProductStruct< A, B >, C >

struct	Ratio< ProductStruct< A, B >, Numerical< 1 > >

struct	Ratio< ProductStruct< A, B >, Numerical< n > >

struct	Ratio< ProductStruct< A, B >, ProductStruct< A, B > >

struct	Ratio< ProductStruct< A, B >, RatioStruct< C, D > >

struct	Ratio< ProductStruct< C, D >, ProductStruct< A, B > >

struct	Ratio< ProductStruct< Numerical< n >, A >, ProductStruct< Numerical< m >, B > >

struct	Ratio< ProductStruct< Numerical< n >, A >, ProductStruct< Numerical< n >, A > >

struct	Ratio< RatioStruct< A, B >, C >

struct	Ratio< RatioStruct< A, B >, Numerical< n > >

struct	Ratio< RatioStruct< A, B >, ProductStruct< C, D > >

struct	Ratio< RatioStruct< A, B >, RatioStruct< C, D > >

struct	Ratio< SinStruct< A >, CosStruct< A > >

struct	Ratio< SinStruct< A >, TanStruct< A > >

struct	Ratio< SumStruct< A, B >, C >

struct	Ratio< SumStruct< A, B >, Numerical< n > >

struct	Ratio< SumStruct< A, B >, ProductStruct< C, D > >

struct	Ratio< SumStruct< A, B >, RatioStruct< C, D > >

struct	Ratio< SumStruct< A, B >, SumStruct< B, A > >

struct	RatioP1

struct	RatioP2

struct	RatioPrimitive

struct	RatioSimpl

struct	RatioStruct

class	RootHistoPdf

struct	RootIntegrator

struct	Sgn

struct	SgnStruct

struct	SimpifyS2C2Sum

struct	SimpifyS2C2Sum< n, m, A, false >

struct	SimplifyNegativeRatio

struct	SimplifyNegativeRatio< n, A, false >

struct	SimplifyPowerProduct

struct	SimplifyPowerProduct< A, B, C, false >

struct	SimplifyPowerRatio

struct	SimplifyPowerRatio< A, B, C, false >

struct	SimplifyRatioSum

struct	SimplifyRatioSum< A, B, false >

struct	SimplifySCRatio

struct	SimplifySCRatio< A, false >

struct	SimplifySignedPower

struct	SimplifySignedPower< 0, A, true >

struct	SimplifySignedPower< n, A, false >

struct	SimplifySTnProduct

struct	SimplifySTnProduct< A, B, false >

struct	SimplifySTProduct

struct	SimplifySTProduct< A, false >

struct	SimplifySTRatio

struct	SimplifySTRatio< A, false >

struct	SimplSumOrd

struct	Sin

struct	Sin2

struct	Sin< MinusStruct< A > >

struct	SinStruct

struct	Slave

struct	Sqrt

struct	SqrtStruct

struct	Square

struct	Sum

struct	Sum< A, A >

struct	Sum< A, Numerical< 0 > >

struct	Sum< A, ProductStruct< Numerical< n >, A > >

struct	Sum< A, SumStruct< B, C > >

struct	Sum< FractionStruct< a, b >, FractionStruct< c, d > >

struct	Sum< FractionStruct< b, c >, Numerical< a > >

struct	Sum< MinusStruct< A >, MinusStruct< A > >

struct	Sum< MinusStruct< ProductStruct< A, B > >, MinusStruct< ProductStruct< A, B > > >

struct	Sum< Numerical< 0 >, MinusStruct< ProductStruct< A, B > > >

struct	Sum< Numerical< 0 >, Numerical< 0 > >

struct	Sum< Numerical< 0 >, ProductStruct< A, B > >

struct	Sum< Numerical< 0 >, SumStruct< A, B > >

struct	Sum< Numerical< a >, FractionStruct< b, c > >

struct	Sum< Numerical< n >, A >

struct	Sum< Numerical< n >, Numerical< m > >

struct	Sum< Numerical< n >, Numerical< n > >

struct	Sum< Numerical< n >, SumStruct< A, B > >

struct	Sum< PowerStruct< CosStruct< A >, Numerical< 2 > >, PowerStruct< SinStruct< A >, Numerical< 2 > > >

struct	Sum< PowerStruct< SinStruct< A >, Numerical< 2 > >, PowerStruct< CosStruct< A >, Numerical< 2 > > >

struct	Sum< ProductStruct< A, B >, Numerical< 0 > >

struct	Sum< ProductStruct< A, B >, ProductStruct< A, B > >

struct	Sum< ProductStruct< Numerical< m >, PowerStruct< CosStruct< A >, Numerical< 2 > > >, ProductStruct< Numerical< n >, PowerStruct< SinStruct< A >, Numerical< 2 > > > >

struct	Sum< ProductStruct< Numerical< n >, A >, A >

struct	Sum< ProductStruct< Numerical< n >, A >, ProductStruct< Numerical< m >, A > >

struct	Sum< ProductStruct< Numerical< n >, A >, ProductStruct< Numerical< n >, A > >

struct	Sum< ProductStruct< Numerical< n >, PowerStruct< SinStruct< A >, Numerical< 2 > > >, ProductStruct< Numerical< m >, PowerStruct< CosStruct< A >, Numerical< 2 > > > >

struct	Sum< SumStruct< A, B >, C >

struct	Sum< SumStruct< A, B >, Numerical< 0 > >

struct	Sum< SumStruct< A, B >, ProductStruct< C, D > >

struct	Sum< SumStruct< A, B >, SumStruct< C, D > >

struct	SumStruct

struct	Tan

struct	Tan< MinusStruct< A > >

struct	TanStruct

class	TrapezoidIntegrator

struct	UndefinedIntegral

struct	X

struct	Y

struct	Z

class	ZLineShape

Typedefs
typedef A	arg

typedef Polynomial< 0 >	Constant

typedef DecomposeProduct< arg, typename Div::arg >	D

typedef Divides< arg, void >	D0

typedef Divides< A, C >	D1

typedef Divides< B, C >	D2

typedef DecomposePower< A, NUM(n)>	Dec

typedef ::boost::mpl::if_< D1, D1, typename::boost::mpl::if_ < D2, D2, D0 >::type >::type	Div

typedef arg	type

Functions
template<typename T >
Abs< T >::type	abs (const T &t)

static type	combine (const A &_1, const B &_2)

template<typename A , typename B >
funct::Composition< A, B >::type	compose (const A &a, const B &b)

template<typename A , typename B , typename Integrator >
funct::Convolution< A, B, Integrator >::type	conv (const A &a, const B &b, double min, double max, const Integrator &i)

template<typename T >
Cos< T >::type	cos (const T &t)

typedef	DERIV (X, A) A1

template<typename X , typename A >
Derivative< X, A >::type	derivative (const A &_)

typedef	DIFF (PROD(A, B1), PRIMIT(X, PROD(A1, B1))) type

typedef	DIFF (PROD(A, B1), AB1) type

template<typename T >
Exp< T >::type	exp (const T &t)

template<int n, int m>
const Fraction< n, m >::type &	fract ()

	GET (arg, _)

	GET (arg, pow(Dec::getBase(_), num< p >()))

	GET (arg, Div::get(_._))

	GET (arg, Div::get(D::get(_)))

static type	get (const PROD_S(A, B)&_)

static type	get (const PROD_S(B, A)&_)

	GET (PROD_S(A, B), _._1 *primitive< X >(_._2))

	GET (PROD_S(A, B), _._2 *primitive< X >(_._1))

	GET (PROD_S(A, B), _ *X())

static type	get (const RATIO_S(A, B)&_)

static type	get (const RATIO_S(B, A)&_)

	GET (RATIO_S(A, B), _._1 *primitive< X >(num< 1 >/_._2))

	GET (RATIO_S(A, B), primitive< X >(_._1)/_._2)

	GET (RATIO_S(A, B), _ *X())

template<typename X , typename F >
Integral< F, X >::type	integral (const F &f)

template<typename X , typename F , typename Integrator >
Integral< F, X >::type	integral (const F &f, const Integrator &integrator)

template<typename X , typename F >
double	integral (const F &f, double min, double max)

template<typename X , typename F , typename Integrator >
double	integral (const F &f, double min, double max, const Integrator &integrator)

template<typename F , typename Integrator >
Integral< F >::type	integral_f (const F &f, const Integrator &integrator)

template<typename F >
Integral< F >::type	integral_f (const F &f)

template<typename F >
double	integral_f (const F &f, double min, double max)

template<typename F , typename Integrator >
double	integral_f (const F &f, double min, double max, const Integrator &integrator)

template<typename T >
Log< T >::type	log (const T &t)

template<typename F >
Master< F >	master (const F &f)

	MINUS_S (B)>

	MINUS_S (C)>

typedef	MINUS_S (A) arg

	MINUS_S (PROD_S(B, C))>

	MINUS_S (PROD_S(C, D))>

template<unsigned n, typename X , typename F >
NthDerivative< n, X, F >::type	nth_derivative (const F &f)

template<int n>
const Numerical< n > &	num ()

	NUM (n))

	NUM (m)>

template<typename A , typename B >
Product< A, B >::type	operator* (const A &a, const B &b)

template<typename A , typename B >
Sum< A, B >::type	operator+ (const A &a, const B &b)

template<typename A , typename B >
Difference< A, B >::type	operator- (const A &a, const B &b)

template<typename A >
Minus< A >::type	operator- (const A &a)

template<typename A , typename B >
Ratio< A, B >::type	operator/ (const A &a, const B &b)

template<int n>
std::ostream &	operator<< (std::ostream &cout, const Numerical< n > &)

template<int n, int m>
std::ostream &	operator<< (std::ostream &cout, const funct::FractionStruct< n, m > &)

template<int n, int m>
std::ostream &	operator<< (std::ostream &cout, const funct::MinusStruct< funct::FractionStruct< n, m > > &)

std::ostream &	operator<< (std::ostream &cout, const funct::Parameter &p)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::SqrtStruct< T > &f)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::ExpStruct< T > &f)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::LogStruct< T > &f)

std::ostream &	operator<< (std::ostream &cout, const Expression &e)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::SinStruct< T > &f)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::CosStruct< T > &f)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::TanStruct< T > &f)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::SgnStruct< T > &f)

template<typename T >
std::ostream &	operator<< (std::ostream &cout, const funct::AbsStruct< T > &f)

std::ostream &	operator<< (std::ostream &cout, const funct::DefaultVariable &)

template<typename X1 , typename X2 , typename X3 >
std::ostream &	operator<< (std::ostream &cout, const Function< X1, X2, X3 > &f)

std::ostream &	operator<< (std::ostream &cout, const funct::X &)

std::ostream &	operator<< (std::ostream &cout, const funct::Y &)

std::ostream &	operator<< (std::ostream &cout, const funct::Z &)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::SumStruct< A, B > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< A, B > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< A, B > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< A, B > &f)

template<typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::MinusStruct< A > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::SumStruct< A, funct::MinusStruct< B > > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::SumStruct< funct::MinusStruct< A >, funct::MinusStruct< B > > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::SumStruct< funct::MinusStruct< A >, B > &f)

template<typename A , int n>
std::ostream &	operator<< (std::ostream &cout, const funct::SumStruct< A, funct::Numerical< n > > &f)

template<typename A , int n>
std::ostream &	operator<< (std::ostream &cout, const funct::SumStruct< funct::MinusStruct< A >, funct::Numerical< n > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< C, funct::SumStruct< A, B > > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< funct::SumStruct< A, B >, funct::SumStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< funct::SumStruct< A, B >, C > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< funct::RatioStruct< A, B >, C > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< C, funct::RatioStruct< A, B > > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::ProductStruct< funct::RatioStruct< A, B >, funct::RatioStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::SumStruct< A, B >, C > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< C, funct::SumStruct< A, B > > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::SumStruct< A, B >, funct::SumStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< C, funct::ProductStruct< A, B > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::ProductStruct< A, B >, C > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::ProductStruct< A, B >, funct::ProductStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::RatioStruct< A, B >, C > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< C, funct::RatioStruct< A, B > > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::RatioStruct< A, B >, funct::RatioStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< C, funct::SumStruct< A, B > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::SumStruct< A, B >, C > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::SumStruct< A, B >, funct::SumStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< C, funct::ProductStruct< A, B > > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::ProductStruct< A, B >, funct::ProductStruct< C, D > > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::ProductStruct< A, B >, C > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::RatioStruct< A, B >, C > &f)

template<typename A , typename B , typename C >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< C, funct::RatioStruct< A, B > > &f)

template<typename A , typename B , typename C , typename D >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::RatioStruct< A, B >, funct::RatioStruct< C, D > > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< A, funct::FractionStruct< n, m > > &f)

template<int n, int m, int k, int l>
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::FractionStruct< n, m >, funct::FractionStruct< k, l > > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::MinusStruct< funct::FractionStruct< n, m > >, A > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< A, funct::MinusStruct< funct::FractionStruct< n, m > > > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< funct::FractionStruct< n, m >, A > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::FractionStruct< n, m >, A > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< A, funct::FractionStruct< n, m > > &f)

template<int n, int m, int k, int l>
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::FractionStruct< n, m >, funct::FractionStruct< k, l > > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< A, funct::MinusStruct< funct::FractionStruct< n, m > > > &f)

template<int n, int m, typename A >
std::ostream &	operator<< (std::ostream &cout, const funct::PowerStruct< funct::MinusStruct< funct::FractionStruct< n, m > >, A > &f)

template<typename A , typename B >
std::ostream &	operator<< (std::ostream &cout, const funct::MinusStruct< funct::SumStruct< A, B > > &f)

template<typename A , typename B >
Power< A, B >::type	operator^ (const A &a, const B &b)

template<typename A , typename B >
Power< A, B >::type	pow (const A &a, const B &b)

typedef	POWER (A, NUM(n)) arg

typedef	POWER (A, NUM(p)) type

	POWER_S (A, NUM(n))>

	POWER_S (A, NUM(m))>

typedef	PRIMIT (X, PROD(A1, B1)) AB1

	PRIMIT_RULE (TYPXT2, POWER_S(A, B), UndefinedIntegral, type())

	PRIMIT_RULE (TYPX, X, RATIO(POWER(X, NUM(2)), NUM(2)), pow(_, num< 2 >())/num< 2 >())

	PRIMIT_RULE (TYPXN1, POWER_S(X, NUM(n)), RATIO(POWER(X, NUM(n+1)), NUM(n+1)), pow(_._1, num< n+1 >())/num< n+1 >())

	PRIMIT_RULE (TYPXN1, RATIO_S(NUM(1), POWER_S(X, NUM(n))), RATIO(NUM(-1), PROD(NUM(n-1), POWER(X, NUM(n-1)))), num<-1 >()/(num< n-1 >()*pow(_._2._1, num< n-1 >())))

	PRIMIT_RULE (TYPXN1, POWER_S(RATIO_S(NUM(1), X), NUM(n)), RATIO(NUM(-1), PROD(NUM(n-1), POWER(X, NUM(n-1)))), num<-1 >()/(num< n-1 >()*pow(_._1._2, num< n-1 >())))

	PRIMIT_RULE (TYPXN2, POWER_S(X, FRACT_S(n, m)), PROD(FRACT(m, n+m), POWER(X, FRACT(n+m, m))),(fract< m, n+m >()*pow(_._1, fract< n+m, m >())))

	PRIMIT_RULE (TYPX, SQRT_S(X), PRIMIT(X, POWER_S(X, FRACT_S(1, 2))),(fract< 2, 3 >()*pow(_._, fract< 3, 2 >())))

	PRIMIT_RULE (TYPX, EXP_S(X), EXP(X), _)

	PRIMIT_RULE (TYPX, LOG_S(X), PROD(X, DIFF(LOG(X), NUM(1))), _._ *(_-num< 1 >()))

	PRIMIT_RULE (TYPX, SGN_S(X), ABS(X), abs(_._))

	PRIMIT_RULE (TYPX, SIN_S(X), MINUS(COS(X)),-cos(_._))

	PRIMIT_RULE (TYPX, COS_S(X), SIN(X), sin(_._))

	PRIMIT_RULE (TYPX, TAN_S(X), MINUS(LOG(ABS(COS(X)))),-log(abs(cos(_._))))

	PRIMIT_RULE (TYPX, RATIO_S(NUM(1), X), LOG(ABS(X)), log(abs(_._2)))

	PRIMIT_RULE (TYPX, POWER_S(X, NUM(-1)), LOG(ABS(X)), log(abs(_._1)))

	PRIMIT_RULE (TYPX, RATIO_S(NUM(1), POWER_S(COS_S(X), NUM(2))), TAN(X), tan(_._2._1._))

	PRIMIT_RULE (TYPX, RATIO_S(NUM(1), POWER_S(SIN_S(X), NUM(2))), RATIO(NUM(-1), TAN(X)), num<-1 >()/tan(_._2._1._))

	PRIMIT_RULE (TYPXT2, SUM_S(A, B), SUM(PRIMIT(X, A), PRIMIT(X, B)), primitive< X >(_._1)+primitive< X >(_._2))

	PRIMIT_RULE (TYPXT1, MINUS_S(A), MINUS(PRIMIT(X, A)),-primitive< X >(_._))

template<typename X , typename F >
Primitive< F, X >::type	primitive (const F &f)

template<typename F >
Primitive< F >::type	primitive (const F &f)

typedef	PROD (F, SUM(RATIO(A, F), RATIO(B, F))) type

	PROD_S (A, B)>

	PROD_S (B, C)>

	PROD_S (C, D)>

template<typename T >
Sgn< T >::type	sgn (const T &t)

template<typename T >
Sin< T >::type	sin (const T &t)

template<typename F >
Slave< F >	slave (const Master< F > &m)

template<typename F >
Square< F >::type	sqr (const F &f)

template<typename T >
Sqrt< T >::type	sqrt (const T &t)

template<typename T >
Tan< T >::type	tan (const T &t)

	TEMPL (T1) struct Divides0

	TEMPL (T2) struct Divides

	TEMPL (N1T1) struct Divides< POWER_S(A

	TEMPL (N2T1) struct ParametricDivN<n

	TEMPL (N2) struct Divides< NUM(n)

	TEMPL (N1) struct Divides< NUM(n)

	TEMPL (T3) struct Divides< PROD_S(A

	TEMPL (T4) struct Divides< PROD_S(A

	TEMPL (XT2) struct PartIntegral<X

	TEMPL (N1T2) struct Sum< PROD_S(A

template<typename F >
double	trapezoid_integral (const F &f, double min, double max, unsigned int samples)

Variables
void	__pad0__

A	__pad1__

A	__pad2__

C	__pad3__

C	__pad4__

	A { }

	B { }

	C

	false

	m

const double	oneOverSqrtTwoPi = 1/sqrt(2*M_PI)

static const int	p

	true

const double	twoOverPi = 2./M_PI

static const bool	value = Div::value

Typedef Documentation

typedef A funct::arg

Definition at line 36 of file Factorize.h.

typedef Polynomial<0> funct::Constant

Definition at line 6 of file Constant.h.

typedef DecomposeProduct<arg, typename Div::arg> funct::D

Definition at line 150 of file Factorize.h.

typedef Divides<arg, void> funct::D0

Definition at line 143 of file Factorize.h.

typedef Divides<A, C> funct::D1

Definition at line 144 of file Factorize.h.

typedef Divides<B, C> funct::D2

Definition at line 145 of file Factorize.h.

typedef DecomposePower<A, NUM(n)> funct::Dec

Definition at line 60 of file Factorize.h.

typedef ::boost::mpl::if_<D1, D1, typename ::boost::mpl::if_ <D2, D2, D0>::type>::type funct::Div

Definition at line 147 of file Factorize.h.

typedef Div::type funct::type

Definition at line 37 of file Factorize.h.

Function Documentation

template<typename T >

Abs<T>::type funct::abs ( const T & t )

inline

Definition at line 22 of file Abs.h.

References funct::Abs< T >::compose().

                                               { 
     return Abs<T>::compose(t); 
   }

static type funct::combine	(	const A &	_1,
		const B &	_2
	)

inlinestatic

Definition at line 186 of file Factorize.h.

References f, and reco::get().

Referenced by CandCombinerBase< OutputCollection, CandPtr >::combine(), and trajectoryToResiduals().

                                                          { 
       const F& f = Divides<A, B>::get(_1);       
       return f * ((_1 / f) + (_2 / f));
     }

template<typename A , typename B >

funct::Composition<A, B>::type funct::compose	(	const A &	a,
		const B &	b
	)

inline

Definition at line 32 of file Composition.h.

References funct::Composition< A, B >::compose().

                                                                              {
     return funct::Composition<A, B>::compose(a, b);
   }

template<typename A , typename B , typename Integrator >

funct::Convolution<A, B, Integrator>::type funct::conv	(	const A &	a,
		const B &	b,
		double	min,
		double	max,
		const Integrator &	i
	)

inline

Definition at line 48 of file Convolution.h.

References funct::Convolution< A, B, Integrator >::compose().

                                                                                                                                    {
     return funct::Convolution<A, B, Integrator>::compose(a, b, min, max, i);
   }

template<typename T >

Cos<T>::type funct::cos ( const T & t )

inline

Definition at line 22 of file Cos.h.

References funct::Cos< T >::compose().

22 { return Cos<T>::compose(t); }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

funct::compose

funct::Composition< A, B >::type compose(const A &a, const B &b)

Definition: Composition.h:32

typedef funct::DERIV	(	X	,
		A
	)

template<typename X , typename A >

Derivative< X , A >::type funct::derivative ( const A & _ )

Definition at line 18 of file Derivative.h.

References funct::Derivative< X, A >::get().

Referenced by MillePedeAlignmentAlgorithm::addLasBeam(), FedTimingAlgorithm::analyse(), ApvTimingAlgorithm::analyse(), and FrameToFrameDerivative::getDerivative().

                                                 { 
     return Derivative<X, A>::get(_); 
   }

typedef funct::DIFF	(	PROD(A, B1)	,
		PRIMIT(X, PROD(A1, B1))
	)

typedef funct::DIFF	(	PROD(A, B1)	,
		AB1
	)

template<typename T >

Exp<T>::type funct::exp ( const T & t )

inline

Definition at line 22 of file Exp.h.

References funct::Exp< T >::compose().

Referenced by funct::Gaussian::operator()().

22 { return Exp<T>::compose(t); }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

funct::compose

funct::Composition< A, B >::type compose(const A &a, const B &b)

Definition: Composition.h:32

template<int n, int m>

const Fraction<n, m>::type& funct::fract ( )

Definition at line 38 of file Fraction.h.

References EnergyCorrector::c.

Referenced by funct::Difference< Numerical< a >, FractionStruct< b, c > >::combine(), funct::Difference< FractionStruct< a, b >, FractionStruct< c, d > >::combine(), LogErrorEventFilter::endJob(), KDTreeLinkerPSEcal::insertFieldClusterElt(), KDTreeLinkerTrackHcal::insertFieldClusterElt(), and KDTreeLinkerTrackEcal::insertFieldClusterElt().

                                              { 
     static typename Fraction<n, m>::type c; 
     return c; 
   }

funct::GET	(	arg	,
		_
	)

Referenced by NUM(), PROD_S(), and TEMPL().

funct::GET	(	arg	,
		pow(Dec::getBase(_), num< p >())
	)

funct::GET	(	arg	,
		Div::	get_._
	)

funct::GET	(	arg	,
		Div::	getD::get(_)
	)

static type funct::get ( const PROD_S(A, B)& _ )

inlinestatic

Definition at line 173 of file Primitive.h.

References a, and b.

                                                   { 
       const A& a = _._1;
       B1 b = primitive<X>(_._2);
       return a * b - primitive<X>(derivative<X>(a) * b); 
     }

static type funct::get ( const PROD_S(B, A)& _ )

inlinestatic

Definition at line 185 of file Primitive.h.

References a, and b.

                                                   { 
       const A& a = _._2;
       B1 b = primitive<X>(_._1);
       return a * b - primitive<X>(derivative<X>(a) * b); 
     }

funct::GET	(	PROD_S(A, B)	,
		_._1 *primitive< X >	_._2
	)

funct::GET	(	PROD_S(A, B)	,
		_._2 *primitive< X >	_._1
	)

funct::GET	(	PROD_S(A, B)	,
		_ *	X()
	)

static type funct::get ( const RATIO_S(A, B)& _ )

inlinestatic

Definition at line 238 of file Primitive.h.

References a, and b.

                                                    { 
       const A& a = _._1;
       B1 b = primitive<X>(num<1>() / _._2);
       return a * b - primitive<X>(derivative<X>(a) * b); 
     }

static type funct::get ( const RATIO_S(B, A)& _ )

inlinestatic

Definition at line 250 of file Primitive.h.

References a, and b.

                                                    { 
       const A& a = _._1;
       B1 b = primitive<X>(num<1>() / _._2);
       return a * b - primitive<X>(derivative<X>(a) * b); 
     }

funct::GET	(	RATIO_S(A, B)	,
		_._1 *primitive< X >	num< 1 >/_._2
	)

funct::GET	(	RATIO_S(A, B)	,
		primitive< X >(_._1)/_.	_2
	)

funct::GET	(	RATIO_S(A, B)	,
		_ *	X()
	)

template<typename X , typename F >

Integral<F, X>::type funct::integral ( const F & f )

Definition at line 69 of file Integral.h.

Referenced by HcalPulseContainmentAlgo::calcpair(), RecoFCcorFactorAlgo< S >::calcpair(), DQMScaleToClient::dqmEndJob(), GetMPV(), GetRandom(), and SiStripGainFromCalibTree::produceTagFilter().

                                                    {
     return typename Integral<F, X>::type(f);
   }

template<typename X , typename F , typename Integrator >

Integral<F, X>::type funct::integral	(	const F &	f,
		const Integrator &	integrator
	)

Definition at line 74 of file Integral.h.

                                                                                   {
     return typename Integral<F, X>::type(f, integrator);
   }

template<typename X , typename F >

double funct::integral	(	const F &	f,
		double	min,
		double	max
	)

Definition at line 84 of file Integral.h.

References f.

                                                       {
     return integral<X>(f)(min, max);
   }

template<typename X , typename F , typename Integrator >

double funct::integral	(	const F &	f,
		double	min,
		double	max,
		const Integrator &	integrator
	)

Definition at line 89 of file Integral.h.

References f.

                                                                                      {
     return integral<X>(f, integrator)(min, max);
   }

template<typename F , typename Integrator >

Integral<F>::type funct::integral_f	(	const F &	f,
		const Integrator &	integrator
	)

Definition at line 79 of file Integral.h.

Referenced by integral_f(), funct::DefIntegral< F, MIN, MAX, Integrator, no_var >::operator()(), and funct::DefIntegral< F, MIN, MAX, no_var, no_var >::operator()().

                                                                                  {
     return typename Integral<F>::type(f, integrator);
   }

template<typename F >

Integral<F>::type funct::integral_f ( const F & f )

Definition at line 94 of file Integral.h.

                                                   {
     return typename Integral<F>::type(f);
   }

template<typename F >

double funct::integral_f	(	const F &	f,
		double	min,
		double	max
	)

Definition at line 99 of file Integral.h.

References integral_f(), bookConverter::max, and min().

                                                         {
     return integral_f(f)(min, max);
   }

template<typename F , typename Integrator >

double funct::integral_f	(	const F &	f,
		double	min,
		double	max,
		const Integrator &	integrator
	)

Definition at line 104 of file Integral.h.

References integral_f(), bookConverter::max, and min().

                                                                                        {
     return integral_f(f, integrator)(min, max);
   }

template<typename T >

Log<T>::type funct::log ( const T & t )

inline

Definition at line 22 of file Log.h.

References funct::Log< T >::compose().

22 { return Log<T>::compose(t); }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

funct::compose

funct::Composition< A, B >::type compose(const A &a, const B &b)

Definition: Composition.h:32

template<typename F >

Master<F> funct::master ( const F & f )

Definition at line 68 of file FunctClone.h.

References f.

68 { return Master<F>(f); }

f

double f[11][100]

Definition: MuScleFitUtils.cc:78

funct::MINUS_S ( B )

Definition at line 99 of file Factorize.h.

Referenced by PROD_S().

99 :

100 public Divides<A, B> { };

funct::MINUS_S ( C )

Definition at line 102 of file Factorize.h.

102 :

103 public Divides<PROD_S(A, B), C> { };

typedef funct::MINUS_S ( A )

funct::MINUS_S ( PROD_S(B, C) )

Definition at line 201 of file Factorize.h.

201 :

202 public FactorizeSum<A, MINUS_S(PROD_S(B, C))> { };

funct::MINUS_S ( PROD_S(C, D) )

Definition at line 208 of file Factorize.h.

                            : 
     public FactorizeSum<MINUS_S(PROD_S(A, B)), 
     MINUS_S(PROD_S(C, D))> { };

template<unsigned n, typename X , typename F >

NthDerivative<n, X, F>::type funct::nth_derivative ( const F & f )

Definition at line 26 of file NthDerivative.h.

References funct::NthDerivative< n, X, F >::get().

26 { return NthDerivative< n, X, F >::get(f); }

f

double f[11][100]

Definition: MuScleFitUtils.cc:78

reco::get

T get(const Candidate &c)

Definition: component.h:55

template<int n>

const Numerical<n>& funct::num ( )

Definition at line 16 of file Numerical.h.

References EnergyCorrector::c.

17 { static Numerical<n> c; return c; }

EnergyCorrector.c

tuple c

Definition: EnergyCorrector.py:43

funct::NUM ( n )

Definition at line 92 of file Factorize.h.

References GET().

Referenced by NUM(), and TEMPL().

                                            { 
     static const bool value = true;
     typedef NUM(n) arg;
     typedef arg type;
     GET(arg, _);
   };

funct::NUM ( m )

Definition at line 84 of file Factorize.h.

References GET(), NUM(), relativeConstraints::value, and value.

                                            { 
     enum { gcd = boost::math::static_gcd<tmpl::abs<n>::value, tmpl::abs<m>::value>::value };
     static const bool value = (gcd != 1);
     typedef NUM(n) arg;
     typedef NUM(gcd) type;
     GET(arg, num<gcd>());
   };

template<typename A , typename B >

Product<A, B>::type funct::operator*	(	const A &	a,
		const B &	b
	)

inline

Definition at line 34 of file Product.h.

References funct::Product< A, B >::combine().

                                                                       {
     return Product<A, B>::combine(a, b);
   }

template<typename A , typename B >

Sum<A, B>::type funct::operator+	(	const A &	a,
		const B &	b
	)

inline

Definition at line 33 of file Sum.h.

References funct::Sum< A, B >::combine().

                                                                   {
     return Sum<A, B>::combine(a, b);
   }

template<typename A , typename B >

Difference<A, B>::type funct::operator-	(	const A &	a,
		const B &	b
	)

inline

Definition at line 15 of file Difference.h.

References funct::Difference< A, B >::combine().

                                                                          {
     return Difference<A, B>::combine(a, b);
   }

template<typename A >

Minus<A>::type funct::operator- ( const A & a )

inline

Definition at line 34 of file Minus.h.

References funct::Minus< A >::operate().

                                                      {
     return Minus<A>::operate(a);
   }

template<typename A , typename B >

Ratio<A, B>::type funct::operator/	(	const A &	a,
		const B &	b
	)

inline

Definition at line 34 of file Ratio.h.

References funct::Ratio< A, B >::combine().

                                                                     {
     return Ratio<A, B>::combine(a, b);
   }

template<int n>

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const Numerical< n > &
	)

Definition at line 13 of file FunctionsIO.h.

References gather_cfg::cout, and gen::n.

                                                               {
   return cout << n;
 }

template<int n, int m>

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::FractionStruct< n, m > &
	)

Definition at line 18 of file FunctionsIO.h.

References gather_cfg::cout, m, and gen::n.

                                                                             { 
   return cout << n << "/" << m; 
 }

template<int n, int m>

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::MinusStruct< funct::FractionStruct< n, m > > &
	)

Definition at line 23 of file FunctionsIO.h.

References m, and gen::n.

                                                                   {
   return cout << "-" << n << "/" << m; 
 }

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::Parameter &	p
	)

inline

Definition at line 27 of file Parameter.h.

References funct::Parameter::name(), and funct::Parameter::value().

                                                                             {
     return cout << p.name() <<" = " << p.value();
   }

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SqrtStruct< T > &	f
	)

Definition at line 36 of file FunctionsIO.h.

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::ExpStruct< T > &	f
	)

Definition at line 37 of file FunctionsIO.h.

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::LogStruct< T > &	f
	)

Definition at line 38 of file FunctionsIO.h.

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const Expression &	e
	)

inline

Definition at line 39 of file Expression.h.

References gather_cfg::cout, and funct::Expression::print().

                                                                       { 
    e.print(cout); return cout; 
  }

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SinStruct< T > &	f
	)

Definition at line 39 of file FunctionsIO.h.

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::CosStruct< T > &	f
	)

Definition at line 40 of file FunctionsIO.h.

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::TanStruct< T > &	f
	)

Definition at line 41 of file FunctionsIO.h.

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SgnStruct< T > &	f
	)

Definition at line 42 of file FunctionsIO.h.

template<typename T >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::AbsStruct< T > &	f
	)

Definition at line 43 of file FunctionsIO.h.

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::DefaultVariable &
	)

inline

Definition at line 49 of file Variables.h.

template<typename X1 , typename X2 , typename X3 >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const Function< X1, X2, X3 > &	f
	)

Definition at line 49 of file Function.h.

References gather_cfg::cout, and f.

                                                                           { 
     return f.print(cout); 
   }

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::X &
	)

inline

Definition at line 50 of file Variables.h.

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::Y &
	)

inline

Definition at line 51 of file Variables.h.

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::Z &
	)

inline

Definition at line 52 of file Variables.h.

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SumStruct< A, B > &	f
	)

Definition at line 61 of file FunctionsIO.h.

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::ProductStruct< A, B > &	f
	)

Definition at line 62 of file FunctionsIO.h.

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::RatioStruct< A, B > &	f
	)

Definition at line 63 of file FunctionsIO.h.

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::PowerStruct< A, B > &	f
	)

Definition at line 64 of file FunctionsIO.h.

template<typename A >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::MinusStruct< A > &	f
	)

Definition at line 65 of file FunctionsIO.h.

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SumStruct< A, funct::MinusStruct< B > > &	f
	)

Definition at line 71 of file FunctionsIO.h.

References f.

                                                                 { 
   return cout << f._1 << " - " << f._2._; 
 }

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SumStruct< funct::MinusStruct< A >, funct::MinusStruct< B > > &	f
	)

Definition at line 77 of file FunctionsIO.h.

References f.

                                                                                   { 
   return cout << "- " << f._1._ << " - " << f._2._; 
 }

template<typename A , typename B >

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SumStruct< funct::MinusStruct< A >, B > &	f
	)

Definition at line 83 of file FunctionsIO.h.

References f.

                                                                { 
   return cout << "- " << f._1._ << " + " << f._2; 
 }

template<typename A , int n>

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SumStruct< A, funct::Numerical< n > > &	f
	)

Definition at line 89 of file FunctionsIO.h.

References abs(), f, and gen::n.

                                                               { 
   return cout << f._1 << (n >= 0 ? " + " : " - ") << ::abs(n); 
 }

template<typename A , int n>

std::ostream& funct::operator<<	(	std::ostream &	cout,
		const funct::SumStruct< funct::MinusStruct< A >, funct::Numerical< n > > &	f
	)

Definition at line 95 of file FunctionsIO.h.

References abs(), f, and gen::n.

                                                                                  { 
   return cout << "- " << f._1._ << (n >= 0 ? " + " : " - ") << ::abs(n); 
 }