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	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	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< MINUS_S(PROD_S(A, B)), MINUS_S(PROD_S(C, D))>

struct	Sum< MINUS_S(PROD_S(A, B)), PROD_S(C, D)>

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< PROD_S(A, B), MINUS_S(PROD_S(C, D))>

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

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 std::conditional< D1::value, D1, typename std::conditional< D2::value, 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)

typedef	MINUS_S (A) arg

	MINUS_S (B)>

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

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

PROD_S(A, B)>	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)

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 Expression &e)

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

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 X1 , typename X2 , typename X3 >
std::ostream &	operator<< (std::ostream &cout, const Function< X1, X2, X3 > &f)

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< funct::SumStruct< A, B >, C > &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::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< 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< funct::SumStruct< A, B >, C > &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 >
std::ostream &	operator<< (std::ostream &cout, const funct::RatioStruct< C, funct::ProductStruct< A, B > > &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< C, funct::RatioStruct< A, B > > &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 , 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< funct::SumStruct< A, B >, C > &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 , 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< funct::ProductStruct< A, B >, C > &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< C, funct::ProductStruct< A, B > > &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< funct::FractionStruct< n, m >, A > &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::PowerStruct< funct::FractionStruct< n, m >, A > &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< funct::MinusStruct< funct::FractionStruct< n, m > >, A > &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< A, funct::FractionStruct< n, m > > &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

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 (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 (T2) struct Divides< PROD_S(A

PROD_S(A, B)>	TEMPL (N1T1) struct Divides< POWER_S(A

	TEMPL (N2T1) struct ParametricDivN< n

	TEMPL (N2) struct Divides< NUM(n)

	TEMPL (N1) struct Divides< NUM(n)

MINUS_S(B)>	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
A	__pad0__

C	__pad1__

true	__pad2__

X	__pad3__

	A {}

TEMPL(T2) struct Divides	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

TEMPL(T2) struct Divides	void

Typedef Documentation

◆ arg

typedef A funct::arg

Definition at line 31 of file Factorize.h.

◆ Constant

typedef Polynomial<0> funct::Constant

Definition at line 6 of file Constant.h.

◆ D

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

Definition at line 141 of file Factorize.h.

◆ D0

typedef Divides<arg, void> funct::D0

Definition at line 135 of file Factorize.h.

◆ D1

typedef Divides<A, C> funct::D1

Definition at line 136 of file Factorize.h.

◆ D2

typedef Divides<B, C> funct::D2

Definition at line 137 of file Factorize.h.

◆ Dec

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

Definition at line 55 of file Factorize.h.

◆ Div

typedef std::conditional<D1::value, D1, typename std::conditional<D2::value, D2, D0>::type>::type funct::Div

Definition at line 138 of file Factorize.h.

◆ type

typedef Div::type funct::type

Definition at line 32 of file Factorize.h.

Function Documentation

◆ abs()

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(), and submitPVValidationJobs::t.

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

◆ combine()

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

inlinestatic

Definition at line 176 of file Factorize.h.

References F(), f, and get.

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

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

◆ compose()

template<typename A , typename B >

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

inline

Definition at line 23 of file Composition.h.

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

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

◆ conv()

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 46 of file Convolution.h.

References a, b, funct::Convolution< A, B, Integrator >::compose(), mps_fire::i, SiStripPI::max, and SiStripPI::min.

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

◆ cos()

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(), and submitPVValidationJobs::t.

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

◆ DERIV()

typedef funct::DERIV	(	X	,
		A
	)

◆ derivative()

template<typename X , typename A >

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

Definition at line 18 of file Derivative.h.

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

Referenced by MillePedeAlignmentAlgorithm::addLasBeam(), FedTimingAlgorithm::analyse(), ApvTimingAlgorithm::analyse(), ThirdOrderDelayODE::calculate(), PadeTableODE::calculate(), SeedingOTEDProducer::computeGlobalThetaError(), FrameToFrameDerivative::getDerivative(), TwoTrackMinimumDistanceHelixLine::oneIteration(), and TwoBodyDecayTrajectoryState::setError().

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

crabWrapper._

_

Definition: crabWrapper.py:19

get

#define get

◆ DIFF() [1/2]

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

◆ DIFF() [2/2]

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

◆ exp()

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(), and submitPVValidationJobs::t.

Referenced by funct::ExpStruct< T >::operator()(), and funct::Gaussian::operator()().

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

◆ fract()

template<int n, int m>

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

Definition at line 36 of file Fraction.h.

References HltBtagPostValidation_cff::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;
   }

◆ GET() [1/10]

funct::GET	(	arg	,
		_
	)

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

◆ GET() [2/10]

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

◆ GET() [3/10]

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

◆ GET() [4/10]

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

◆ get() [1/4]

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

inlinestatic

Definition at line 170 of file Primitive.h.

References crabWrapper::_, A, a, and b.

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

◆ get() [2/4]

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

inlinestatic

Definition at line 182 of file Primitive.h.

References crabWrapper::_, A, a, and b.

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

◆ GET() [5/10]

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

◆ GET() [6/10]

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

◆ GET() [7/10]

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

◆ get() [3/4]

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

inlinestatic

Definition at line 228 of file Primitive.h.

References crabWrapper::_, A, a, and b.

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

◆ get() [4/4]

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

inlinestatic

Definition at line 240 of file Primitive.h.

References crabWrapper::_, A, a, and b.

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

◆ GET() [8/10]

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

◆ GET() [9/10]

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

◆ GET() [10/10]

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

◆ integral() [1/4]

template<typename X , typename F >

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

Definition at line 70 of file Integral.h.

References f.

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

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

◆ integral() [2/4]

template<typename X , typename F , typename Integrator >

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

Definition at line 75 of file Integral.h.

References f.

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

◆ integral() [3/4]

template<typename X , typename F >

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

Definition at line 85 of file Integral.h.

References f, SiStripPI::max, and SiStripPI::min.

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

◆ integral() [4/4]

template<typename X , typename F , typename Integrator >

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

Definition at line 90 of file Integral.h.

References f, SiStripPI::max, and SiStripPI::min.

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

◆ integral_f() [1/4]

template<typename F , typename Integrator >

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

Definition at line 80 of file Integral.h.

References f.

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);
   }

◆ integral_f() [2/4]

template<typename F >

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

Definition at line 95 of file Integral.h.

References f.

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

◆ integral_f() [3/4]

template<typename F >

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

Definition at line 100 of file Integral.h.

References f, integral_f(), SiStripPI::max, and SiStripPI::min.

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

◆ integral_f() [4/4]

template<typename F , typename Integrator >

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

Definition at line 105 of file Integral.h.

References f, integral_f(), SiStripPI::max, and SiStripPI::min.

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

◆ log()

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(), and submitPVValidationJobs::t.

Referenced by funct::LogStruct< T >::operator()().

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

◆ master()

template<typename F >

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

Definition at line 63 of file FunctClone.h.

References f.

                                {
     return Master<F>(f);
   }

◆ MINUS_S() [1/2]

typedef funct::MINUS_S ( A )

Referenced by MINUS_S(), and PROD_S().

◆ MINUS_S() [2/2]

funct::MINUS_S ( B )

Definition at line 106 of file Factorize.h.

References crabWrapper::_, A, GET(), get, MINUS_S(), and value.

                                                    {
     typedef Divides<A, B> Div;
     static const bool value = Div::value;
     typedef MINUS_S(A) arg;
     typedef typename Div::type type;
     GET(arg, Div::get(_._));
   };

◆ nth_derivative()

template<unsigned n, typename X , typename F >

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

Definition at line 24 of file NthDerivative.h.

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

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

◆ num()

template<int n>

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

Definition at line 18 of file Numerical.h.

References HltBtagPostValidation_cff::c.

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

◆ NUM() [1/2]

funct::NUM ( n )

Definition at line 87 of file Factorize.h.

References crabWrapper::_, GET(), and dqmiodumpmetadata::n.

Referenced by NUM(), and TEMPL().

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

◆ NUM() [2/2]

funct::NUM ( m )

Definition at line 79 of file Factorize.h.

References GET(), dqmiodumpmetadata::n, and NUM().

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

◆ operator*()

template<typename A , typename B >

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

inline

Definition at line 23 of file Product.h.

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

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

◆ operator+()

template<typename A , typename B >

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

inline

Definition at line 24 of file Sum.h.

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

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

◆ operator-() [1/2]

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 a, b, and funct::Difference< A, B >::combine().

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

◆ operator-() [2/2]

template<typename A >

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

inline

Definition at line 24 of file Minus.h.

References a, and funct::Minus< A >::operate().

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

◆ operator/()

template<typename A , typename B >

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

inline

Definition at line 23 of file Ratio.h.

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

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

◆ operator<<() [1/63]

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 dqmiodumpmetadata::n.

                                                                 {
     return cout << n;
   }

◆ operator<<() [2/63]

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 dqmiodumpmetadata::n.

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

◆ operator<<() [3/63]

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 gather_cfg::cout, m, and dqmiodumpmetadata::n.

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

◆ operator<<() [4/63]

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

inline

Definition at line 30 of file Parameter.h.

References gather_cfg::cout, and p.

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

◆ operator<<() [5/63]

template<typename T >

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

Definition at line 35 of file FunctionsIO.h.

◆ operator<<() [6/63]

template<typename T >

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

Definition at line 36 of file FunctionsIO.h.

◆ operator<<() [7/63]

template<typename T >

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

Definition at line 37 of file FunctionsIO.h.

◆ operator<<() [8/63]

template<typename T >

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

Definition at line 38 of file FunctionsIO.h.

◆ operator<<() [9/63]

template<typename T >

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

Definition at line 39 of file FunctionsIO.h.

◆ operator<<() [10/63]

template<typename T >

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

Definition at line 40 of file FunctionsIO.h.

◆ operator<<() [11/63]

template<typename T >

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

Definition at line 41 of file FunctionsIO.h.

◆ operator<<() [12/63]

template<typename T >

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

Definition at line 42 of file FunctionsIO.h.

◆ operator<<() [13/63]

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

inline

Definition at line 44 of file Expression.h.

References gather_cfg::cout, and MillePedeFileConverter_cfg::e.

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

◆ operator<<() [14/63]

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

inline

Definition at line 50 of file Variables.h.

◆ operator<<() [15/63]

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

inline

Definition at line 51 of file Variables.h.

◆ operator<<() [16/63]

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

inline

Definition at line 52 of file Variables.h.

◆ operator<<() [17/63]

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

inline

Definition at line 53 of file Variables.h.

◆ operator<<() [18/63]

template<typename X1 , typename X2 , typename X3 >

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

Definition at line 56 of file Function.h.

References gather_cfg::cout, and f.

                                                                           {
     return f.print(cout);
   }

◆ operator<<() [19/63]

template<typename A , typename B >

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

Definition at line 62 of file FunctionsIO.h.

◆ operator<<() [20/63]

template<typename A , typename B >

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

Definition at line 63 of file FunctionsIO.h.

◆ operator<<() [21/63]

template<typename A , typename B >

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

Definition at line 64 of file FunctionsIO.h.

◆ operator<<() [22/63]

template<typename A , typename B >

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

Definition at line 65 of file FunctionsIO.h.

◆ operator<<() [23/63]

template<typename A >

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

Definition at line 66 of file FunctionsIO.h.

◆ operator<<() [24/63]

template<typename A , typename B >

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

Definition at line 72 of file FunctionsIO.h.

References gather_cfg::cout, and f.

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

◆ operator<<() [25/63]

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 gather_cfg::cout, and f.

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

◆ operator<<() [26/63]

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 gather_cfg::cout, and f.

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

◆ operator<<() [27/63]

template<typename A , int n>

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

Definition at line 88 of file FunctionsIO.h.

References abs(), gather_cfg::cout, f, and dqmiodumpmetadata::n.

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

◆ operator<<() [28/63]

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 93 of file FunctionsIO.h.

References abs(), gather_cfg::cout, f, and dqmiodumpmetadata::n.

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

◆ operator<<() [29/63]

template<typename A , typename B , typename C >

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

Definition at line 152 of file FunctionsIO.h.

◆ operator<<() [30/63]

template<typename A , typename B , typename C >

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

Definition at line 152 of file FunctionsIO.h.

◆ operator<<() [31/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 152 of file FunctionsIO.h.

◆ operator<<() [32/63]

template<typename A , typename B , typename C >

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

Definition at line 153 of file FunctionsIO.h.

◆ operator<<() [33/63]

template<typename A , typename B , typename C >

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

Definition at line 153 of file FunctionsIO.h.

◆ operator<<() [34/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 153 of file FunctionsIO.h.

◆ operator<<() [35/63]

template<typename A , typename B , typename C >

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

Definition at line 154 of file FunctionsIO.h.

◆ operator<<() [36/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 154 of file FunctionsIO.h.

◆ operator<<() [37/63]

template<typename A , typename B , typename C >

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

Definition at line 154 of file FunctionsIO.h.

◆ operator<<() [38/63]

template<typename A , typename B , typename C >

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

Definition at line 155 of file FunctionsIO.h.

◆ operator<<() [39/63]

template<typename A , typename B , typename C >

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

Definition at line 155 of file FunctionsIO.h.

◆ operator<<() [40/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 155 of file FunctionsIO.h.

◆ operator<<() [41/63]

template<typename A , typename B , typename C >

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

Definition at line 156 of file FunctionsIO.h.

◆ operator<<() [42/63]

template<typename A , typename B , typename C >

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

Definition at line 156 of file FunctionsIO.h.

◆ operator<<() [43/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 156 of file FunctionsIO.h.

◆ operator<<() [44/63]

template<typename A , typename B , typename C >

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

Definition at line 158 of file FunctionsIO.h.

◆ operator<<() [45/63]

template<typename A , typename B , typename C >

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

Definition at line 158 of file FunctionsIO.h.

◆ operator<<() [46/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 158 of file FunctionsIO.h.

◆ operator<<() [47/63]

template<typename A , typename B , typename C >

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

Definition at line 159 of file FunctionsIO.h.

◆ operator<<() [48/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 159 of file FunctionsIO.h.

◆ operator<<() [49/63]

template<typename A , typename B , typename C >

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

Definition at line 159 of file FunctionsIO.h.

◆ operator<<() [50/63]

template<typename A , typename B , typename C >

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

Definition at line 160 of file FunctionsIO.h.

◆ operator<<() [51/63]

template<typename A , typename B , typename C >

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

Definition at line 160 of file FunctionsIO.h.

◆ operator<<() [52/63]

template<typename A , typename B , typename C , typename D >

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

Definition at line 160 of file FunctionsIO.h.

◆ operator<<() [53/63]

template<int n, int m, typename A >

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

Definition at line 163 of file FunctionsIO.h.

◆ operator<<() [54/63]

template<int n, int m, typename A >

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

Definition at line 163 of file FunctionsIO.h.

◆ operator<<() [55/63]

template<int n, int m, int k, int l>

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

Definition at line 163 of file FunctionsIO.h.

◆ operator<<() [56/63]

template<int n, int m, typename A >

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

Definition at line 163 of file FunctionsIO.h.

◆ operator<<() [57/63]

template<int n, int m, typename A >

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

Definition at line 163 of file FunctionsIO.h.

◆ operator<<() [58/63]

template<int n, int m, typename A >

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

Definition at line 164 of file FunctionsIO.h.

◆ operator<<() [59/63]

template<int n, int m, int k, int l>

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

Definition at line 164 of file FunctionsIO.h.

◆ operator<<() [60/63]

template<int n, int m, typename A >

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

Definition at line 164 of file FunctionsIO.h.

◆ operator<<() [61/63]

template<int n, int m, typename A >

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

Definition at line 164 of file FunctionsIO.h.

◆ operator<<() [62/63]

template<int n, int m, typename A >

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

Definition at line 164 of file FunctionsIO.h.

◆ operator<<() [63/63]

template<typename A , typename B >

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

Definition at line 166 of file FunctionsIO.h.

◆ operator^()

template<typename A , typename B >

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

inline

Definition at line 24 of file Power.h.

References a, b, and funct::Power< A, B >::combine().

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

◆ pow()

template<typename A , typename B >

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

inline

Definition at line 29 of file Power.h.

References a, b, and funct::Power< A, B >::combine().

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

◆ POWER() [1/2]

typedef funct::POWER	(	A	,
		NUM(n)
	)

◆ POWER() [2/2]

typedef funct::POWER	(	A	,
		NUM(p)
	)

◆ PRIMIT()

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

◆ PRIMIT_RULE() [1/19]

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

◆ PRIMIT_RULE() [2/19]

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

◆ PRIMIT_RULE() [3/19]

funct::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() [4/19]

funct::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() [5/19]

funct::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() [6/19]

funct::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() [7/19]

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

◆ PRIMIT_RULE() [8/19]

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

◆ PRIMIT_RULE() [9/19]

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

◆ PRIMIT_RULE() [10/19]

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

◆ PRIMIT_RULE() [11/19]

funct::PRIMIT_RULE	(	TYPX	,
		SIN_S(X)	,
		MINUS(COS(X))	,
		-	cos_._
	)

◆ PRIMIT_RULE() [12/19]

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

◆ PRIMIT_RULE() [13/19]

funct::PRIMIT_RULE	(	TYPX	,
		TAN_S(X)	,
		MINUS(LOG(ABS(COS(X))))	,
		-	logabs(cos(_._))
	)

◆ PRIMIT_RULE() [14/19]

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

◆ PRIMIT_RULE() [15/19]

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

◆ PRIMIT_RULE() [16/19]

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

◆ PRIMIT_RULE() [17/19]

funct::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() [18/19]

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

◆ PRIMIT_RULE() [19/19]

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

◆ primitive() [1/2]

template<typename X , typename F >

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

Definition at line 41 of file Primitive.h.

References f, and funct::ConstPrimitive< X, F >::get().

Referenced by DTTrigPhase2Prod::assignIndex(), L1TPhase2GMTEndcapStubProcessor::buildCSCOnlyStub(), L1TPhase2GMTEndcapStubProcessor::buildRPCOnlyStub(), cond::OMSServiceResultRef::getArray(), MuonPath::isAnalyzable(), MuonPath::isEqualTo(), PlotAlignmentValidation::plotChi2(), and MuonPath::setLateralCombFromPrimitives().

                                                      {
     return Primitive<F, X>::get(f);
   }

◆ primitive() [2/2]

template<typename F >

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

Definition at line 46 of file Primitive.h.

References f, and funct::ConstPrimitive< X, F >::get().

                                                   {
     return Primitive<F>::get(f);
   }

◆ PROD()

typedef funct::PROD	(	F	,
		SUM(RATIO(A, F), RATIO(B, F))
	)

◆ PROD_S() [1/2]

funct::PROD_S	(	B	,
		C
	)

Definition at line 114 of file Factorize.h.

References crabWrapper::_, A, GET(), get, MINUS_S(), and value.

Referenced by PROD_S().

                                                      {
     typedef Divides<A, PROD_S(B, C)> Div;
     static const bool value = Div::value;
     typedef MINUS_S(A) arg;
     typedef typename Div::type type;
     GET(arg, Div::get(_._));
   };

◆ PROD_S() [2/2]

funct::PROD_S	(	C	,
		D
	)

Definition at line 145 of file Factorize.h.

References crabWrapper::_, A, B, GET(), get, PROD_S(), and value.

                                                        {
     typedef PROD_S(A, B) arg;
     typedef Divides<arg, void> D0;
     typedef Divides<arg, C> D1;
     typedef Divides<arg, D> D2;
     typedef typename std::conditional<D1::value, D1, typename std::conditional<D2::value, D2, D0>::type>::type Div;
     static const bool value = Div::value;
     typedef typename Div::type type;
     GET(arg, Div::get(_));
   };

◆ sgn()

template<typename T >

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

inline

Definition at line 21 of file Sgn.h.

References funct::Sgn< T >::compose(), and submitPVValidationJobs::t.

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

◆ sin()

template<typename T >

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

inline

Definition at line 22 of file Sin.h.

References funct::Sin< T >::compose(), and submitPVValidationJobs::t.

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

◆ slave()

template<typename F >

Slave<F> funct::slave ( const Master< F > & m )

Definition at line 68 of file FunctClone.h.

References m.

                                      {
     return Slave<F>(m);
   }

◆ sqr()

template<typename F >

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

Definition at line 14 of file Square.h.

References f, and pow().

Referenced by MonopoleTransportation::AlongStepGetPhysicalInteractionLength(), ThirdHitPredictionFromCircle::angle(), HitPairGeneratorFromLayerPairForPhotonConversion::checkRZCompatibilityWithSeedTrack(), RectangularEtaPhiTrackingRegion::checkRZOld(), ThirdHitPredictionFromCircle::curvature(), RectangularEtaPhiTrackingRegion::estimator(), FullModelReactionDynamics::GenerateXandPt(), HitPairGeneratorFromLayerPairForPhotonConversion::getPhiRange(), CAHitTripletGenerator::hitNtuplets(), CAHitQuadrupletGenerator::hitNtuplets(), HitPairGeneratorFromLayerPairForPhotonConversion::hitPairs(), ThirdHitCorrection::init(), SeedFromConsecutiveHitsCreator::initialError(), SeedForPhotonConversion1Leg::initialError(), JacobianLocalToCartesian::JacobianLocalToCartesian(), SeedFromConsecutiveHitsCreator::makeSeed(), MatchJet::matchCollections(), RKCurvilinearDistance< T, N >::momentum(), RKCurvilinearDistance< T, N >::operator()(), ThirdHitZPrediction::operator()(), ThirdHitPredictionFromCircle::phi(), InnerDeltaPhi::phiRange(), ThirdHitPredictionFromCircle::HelixRZ::rAtZ(), reco::GhostTrackVertexFinder::reassignTracks(), PrimaryVertexResolution::Resolution::Resolution(), PhotonConversionTrajectorySeedProducerFromSingleLegAlgo::selectPriVtxCompatibleWithTrack(), MSLayersKeeperX0AtEta::setX0(), reco::SequentialGhostTrackFitter::stable(), MSLayersAtAngle::sumX0D(), ThirdHitPredictionFromCircle::transverseIP(), reco::GhostTrackVertexFinder::vertexCompat(), reco::TrackGhostTrackState::vertexStateOnGhostTrack(), reco::TrackGhostTrackState::vertexStateOnMeasurement(), and ThirdHitPredictionFromCircle::HelixRZ::zAtR().

                                          {
     return pow(f, num<2>());
   }

◆ sqrt()

template<typename T >

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

inline

Definition at line 22 of file Sqrt.h.

References funct::Sqrt< T >::compose(), and submitPVValidationJobs::t.

Referenced by funct::SqrtStruct< T >::operator double(), and funct::SqrtStruct< T >::operator()().

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

◆ tan()

template<typename T >

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

inline

Definition at line 22 of file Tan.h.

References funct::Tan< T >::compose(), and submitPVValidationJobs::t.

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

◆ TEMPL() [1/10]

funct::TEMPL ( T1 )

Definition at line 15 of file Factorize.h.

References A, GET(), and NUM().

                             {
     static const bool value = false;
     typedef A arg;
     typedef NUM(1) type;
     GET(arg, num<1>());
   };

◆ TEMPL() [2/10]

funct::TEMPL ( T2 )

◆ TEMPL() [3/10]

PROD_S (A, B)> funct::TEMPL ( N1T1 )

◆ TEMPL() [4/10]

funct::TEMPL ( N2T1 )

◆ TEMPL() [5/10]

funct::TEMPL ( N2 )

◆ TEMPL() [6/10]

funct::TEMPL ( N1 )

◆ TEMPL() [7/10]

funct::TEMPL ( T3 )

◆ TEMPL() [8/10]

funct::TEMPL ( T4 )

◆ TEMPL() [9/10]

funct::TEMPL ( XT2 )

◆ TEMPL() [10/10]

funct::TEMPL ( N1T2 )

◆ trapezoid_integral()

template<typename F >

double funct::trapezoid_integral	(	const F &	f,
		double	min,
		double	max,
		unsigned int	samples
	)

Definition at line 20 of file NumericalIntegration.h.

References dumpMFGeometry_cfg::delta, f, mps_fire::i, MainPageGenerator::l, SiStripPI::max, SiStripPI::min, and EgammaValidation_cff::samples.

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

                                                                                       {
     const double l = max - min, delta = l / samples;
     double sum = 0;
     for (unsigned int i = 0; i < samples; ++i) {
       sum += f(min + (i + 0.5) * delta);
     }
     return sum * delta;
   }

Variable Documentation

◆ pad0

true funct::__pad0__

Definition at line 36 of file Factorize.h.

◆ pad1

X funct::__pad1__

Definition at line 182 of file Factorize.h.

◆ pad2

true funct::__pad2__

Definition at line 248 of file Primitive.h.

◆ pad3

X funct::__pad3__

Definition at line 268 of file Primitive.h.

◆ A

X funct::A {}

Definition at line 45 of file Factorize.h.

Referenced by get(), MINUS_S(), PROD_S(), and TEMPL().

◆ B

X funct::B {}

Definition at line 24 of file Factorize.h.

Referenced by PROD_S().

◆ C

C funct::C

Initial value:

{

typedef PROD_S(A, B) arg

B

Definition: APVGainStruct.h:7

funct::arg

A arg

Definition: Factorize.h:31

A

Definition: APVGainStruct.h:7

PROD_S

#define PROD_S(A, B)

Definition: Simplify_begin.h:39

Definition at line 133 of file Factorize.h.

◆ false

true funct::false

Initial value:

{

static const bool value = true

value

Definition: value.py:1

Definition at line 29 of file Factorize.h.

Referenced by HOCalibAnalyzer::analyze(), GEMGeometryBuilder::buildChamber(), l1t::ConditionEvaluation::checkRangeDeltaEta(), l1t::ConditionEvaluation::checkRangeEta(), RectangularPixelTopology::containsBigPixelInX(), RectangularPixelTopology::containsBigPixelInY(), edm::PileUp::doPileUp(), CastorSD::getFromLibrary(), PixelDataFormatter::interpretRawData(), TrackingParticleSelector::isCharged(), DTTopology::isWireValid(), sistrip::RawToDigiUnpacker::locateStartOfFedBuffer(), edm::ThinnedAssociationsHelper::lower_bound(), TkAccumulatingSensitiveDetector::newHit(), math::Graph< N, E >::const_iterator::operator!=(), SimG4HcalHitCluster::operator<(), CaloHit::operator<(), edm::operator<(), PFBlockAlgo::packLinks(), pat::PATJetProducer::PATJetProducer(), CutBasedElectronID::robustSelection(), and hcaldqm::filter::HashFilter::skip().

◆ m

funct::m

Definition at line 45 of file Factorize.h.

Referenced by funct::GaussLegendreIntegrator::GaussLegendreIntegrator(), funct::Numerical< n >::Numerical(), funct::FractionStruct< n, m >::operator double(), funct::FractionStruct< n, m >::operator()(), operator<<(), and slave().

◆ oneOverSqrtTwoPi

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

Definition at line 9 of file Gaussian.h.

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

◆ p

const int funct::p

static

Initial value:

= []() {
      if constexpr (n < m)
        return n;
      else
        return m;
    }()

Definition at line 48 of file Factorize.h.

Referenced by funct::Primitive< Parameter >::get(), and operator<<().

◆ true

true funct::true

Initial value:

{

typedef typename Divides<A, B>::type F

funct::type

arg type

Definition: Factorize.h:32

F

static uInt32 F(BLOWFISH_CTX *ctx, uInt32 x)

Definition: blowfish.cc:163

Definition at line 173 of file Factorize.h.

Referenced by DTMeantimerPatternReco::addHits(), L1TMP7ZeroSupp::analyze(), CSCSegAlgoSK::areHitsCloseInGlobalPhi(), CSCSegAlgoTC::areHitsCloseInGlobalPhi(), CSCSegAlgoRU::areHitsCloseInGlobalPhi(), CSCSegAlgoTC::areHitsCloseInLocalX(), CSCSegAlgoSK::areHitsCloseInLocalX(), cscdqm::Collection::book(), Phase2TrackerMonitorDigi::bookLayerHistos(), Phase2TrackerValidateDigi::bookLayerHistos(), edm::stream::impl::InputProcessBlockCacheHolder< CacheTypes >::cacheFillersRegistered(), VFATFrame::channelActive(), MuonTrajectoryCleaner::clean(), Phase2L1GMT::Isolation::compute_trk_iso(), trklet::KFin::consume(), AlcaBeamSpotManager::createWeightedPayloads(), BiasedTauDecayer::decay(), Phase2TrackerDigitizerAlgorithm::digitize(), SiStripDigitizerAlgorithm::digitize(), CSCEfficiency::efficienciesPerChamber(), TopSingleLepton::MonitorEnsemble::fill(), SingleTopTChannelLepton::MonitorEnsemble::fill(), TopDiLeptonOffline::MonitorEnsemble::fill(), HFShowerLibrary::fillHits(), cms::MTCCHLTrigger::filter(), edm::Prescaler::filter(), MuonSeedBuilder::foundMatchingSegment(), CastorSD::getFromLibrary(), ZdcShowerLibrary::getHits(), TrackTransformerForCosmicMuons::getTransientRecHits(), HCalSD::hitForFibre(), CosmicHitPairGeneratorFromLayerPair::hitPairs(), reco::CandidatePtrTransientTrack::impactPointStateAvailable(), reco::TrackTransientTrack::impactPointStateAvailable(), hcaldqm::mapper::HashMapper::isDHash(), hcaldqm::mapper::HashMapper::isEHash(), DDXMLElement::isEmpty(), CSCSegAlgoSK::isHitNearSegment(), CSCSegAlgoTC::isHitNearSegment(), CSCSegAlgoRU::isHitNearSegment(), MuonTrackResidualAnalyzer::isInTheAcceptance(), MuonTrackAnalyzer::isInTheAcceptance(), CSCSegment::isME11a_duplicate(), hcaldqm::mapper::HashMapper::isMixHash(), TtGenEvent::isSemiLeptonic(), DTRecSegment2D::ist0Valid(), hcaldqm::mapper::HashMapper::isTHash(), edm::ThinnedAssociationsHelper::lower_bound(), edm::ELextendedID::operator<(), reco::PreshowerCluster::operator<(), operator<(), FastLineRecognition::Cluster::operator<(), StepID::operator<(), edm::operator<(), CaloCellId::operator==(), CaloHitID::operator==(), math::Graph< N, E >::const_iterator::operator==(), StepID::operator==(), StepID::operator>(), L1MuDTSecProcId::ovl(), L1MuBMSecProcId::ovl(), EgammaCutBasedEleId::PassTriggerCuts(), hcaldqm::filter::HashFilter::preserve(), MFProducer::produce(), ecaldqm::LaserClient::producePlots(), ecaldqm::LedClient::producePlots(), readSRF(), readTTF(), CSCEfficiency::recHitSegment_Efficiencies(), CSCEfficiency::recSimHitEfficiency(), TtDecayChannelSelector::search(), SelectionStep< Object >::select(), CSCEfficiency::stripWire_Efficiencies(), EgammaCutBasedEleId::TestWP(), TrackTransformerForGlobalCosmicMuons::transform(), TrackTransformerForCosmicMuons::transform(), l1t::stage2::emtf::SPBlockUnpacker::unpack(), CaloSteppingAction::update(), and PrimaryVertexValidation::vtxSort().

◆ twoOverPi

const double funct::twoOverPi = 2. / M_PI

Definition at line 8 of file BreitWigner.h.

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

◆ value

static const bool funct::value = Div::value

static

Definition at line 100 of file Factorize.h.

Referenced by MINUS_S(), and PROD_S().

◆ void

TEMPL (T2) struct Divides funct::void

Definition at line 24 of file Factorize.h.

Referenced by edmtest::ThingAnalyzer::analyze(), TrackingManagerHelper::Physics::AtRestDoIt(), mkfit::Shell::Compare(), edm::ConditionalTaskHelper::ConditionalTaskHelper(), spu::def(), TotemT2DQMSource::fillErrorFlagsHistogram(), edmtest::AcquireIntStreamFilter::filter(), edmtest::AcquireIntFilter::filter(), edm::ParameterSet::getParameterNamesForType(), edmtest::ThingAnalyzer::globalBeginLuminosityBlock(), edmtest::ThingAnalyzer::globalBeginRun(), edmtest::ThingAnalyzer::globalEndLuminosityBlock(), edmtest::ThingAnalyzer::globalEndRun(), spu::inf(), DTCCablingMapProducer::LoadModulesToDTCCablingMapFromCSV(), SiStripCondTypes::makeBitSet(), L1GtVhdlWriterCore::makeFirmware(), edm::detail::getValueType< T, false >::operator()(), edm::detail::getMemberType< T, false >::operator()(), edmtest::AcquireIntStreamProducer::produce(), edmtest::AcquireIntProducer::produce(), mkfit::Event::read_in(), PythonEventProcessor::run(), TestInterProcessRandomProd::streamBeginLuminosityBlock(), TestInterProcessProd::streamBeginLuminosityBlock(), ExternalGeneratorFilter::streamBeginLuminosityBlock(), TestInterProcessProd::streamBeginRun(), TestInterProcessProd::streamEndLuminosityBlock(), TestInterProcessProd::streamEndRun(), ExternalGeneratorFilter::streamEndRun(), edm::test::TestProcessor::TestProcessor(), trklet::TrackletCalculator::TrackletCalculator(), and edm::PtrVectorBase::typeInfo().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ arg

◆ Constant

◆ D

◆ D0

◆ D1

◆ D2

◆ Dec

◆ Div

◆ type

Function Documentation

◆ abs()

◆ combine()

◆ compose()

◆ conv()

◆ cos()

◆ DERIV()

◆ derivative()

◆ DIFF() [1/2]

◆ DIFF() [2/2]

◆ exp()

◆ fract()

◆ GET() [1/10]

◆ GET() [2/10]

◆ GET() [3/10]

◆ GET() [4/10]

◆ get() [1/4]

◆ get() [2/4]

◆ GET() [5/10]

◆ GET() [6/10]

◆ GET() [7/10]

◆ get() [3/4]

◆ get() [4/4]

◆ GET() [8/10]

◆ GET() [9/10]

◆ GET() [10/10]

◆ integral() [1/4]

◆ integral() [2/4]

◆ integral() [3/4]

◆ integral() [4/4]

◆ integral_f() [1/4]

◆ integral_f() [2/4]

◆ integral_f() [3/4]

◆ integral_f() [4/4]

◆ log()

◆ master()

◆ MINUS_S() [1/2]

◆ MINUS_S() [2/2]

◆ nth_derivative()

◆ num()

◆ NUM() [1/2]

◆ NUM() [2/2]

◆ operator*()

◆ operator+()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator/()

◆ operator<<() [1/63]

◆ operator<<() [2/63]

◆ operator<<() [3/63]

◆ operator<<() [4/63]

◆ operator<<() [5/63]

◆ operator<<() [6/63]

◆ operator<<() [7/63]

◆ operator<<() [8/63]

◆ operator<<() [9/63]

◆ operator<<() [10/63]

◆ operator<<() [11/63]

◆ operator<<() [12/63]

◆ operator<<() [13/63]

◆ operator<<() [14/63]

◆ operator<<() [15/63]

◆ operator<<() [16/63]

◆ operator<<() [17/63]

◆ operator<<() [18/63]