Primitive.h File Reference

#include "PhysicsTools/Utilities/interface/Functions.h"
#include "PhysicsTools/Utilities/interface/Operations.h"
#include "PhysicsTools/Utilities/interface/Fraction.h"
#include "PhysicsTools/Utilities/interface/Derivative.h"
#include "PhysicsTools/Utilities/interface/Parameter.h"
#include "PhysicsTools/Utilities/interface/Identity.h"
#include <type_traits>
#include "PhysicsTools/Utilities/interface/Simplify_begin.h"
#include "PhysicsTools/Utilities/interface/Simplify_end.h"

Go to the source code of this file.

Classes
struct	funct::ConstPrimitive< X, F, independent >
struct	funct::ConstPrimitive< X, F, true >
struct	funct::PartIntegral< TYPXT2, bint, aint >
struct	funct::PartIntegral2< TYPXT2, bint, aint >
struct	funct::Primitive< F, X >
struct	funct::Primitive< F >
struct	funct::Primitive< Parameter >
struct	funct::ProductPrimitive< TYPXT2, indepf, indepg >
struct	funct::RatioPrimitive< TYPXT2, indepa, indepb >
struct	funct::UndefinedIntegral

Namespaces
	funct

Macros
#define	DECLARE_FUNCT_PRIMITIVE(F, P)
#define	DECLARE_PRIMITIVE(X, F, P)

Functions
typedef	funct::DERIV (X, A) A1
typedef	funct::DIFF (PROD(A, B1), PRIMIT(X, PROD(A1, B1))) type
typedef	funct::DIFF (PROD(A, B1), AB1) type
static type	funct::get (const PROD_S(A, B)&_)
static type	funct::get (const PROD_S(B, A)&_)
	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)&_)
static type	funct::get (const RATIO_S(B, A)&_)
	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())
typedef	funct::PRIMIT (X, PROD(A1, B1)) AB1
	funct::PRIMIT_RULE (TYPXT2, POWER_S(A, B), UndefinedIntegral, type())
	funct::PRIMIT_RULE (TYPX, X, RATIO(POWER(X, NUM(2)), NUM(2)), pow(_, num< 2 >())/num< 2 >())
	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 >())
	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 >())))
	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 >())))
	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 >())))
	funct::PRIMIT_RULE (TYPX, SQRT_S(X), PRIMIT(X, POWER_S(X, FRACT_S(1, 2))),(fract< 2, 3 >()*pow(_._, fract< 3, 2 >())))
	funct::PRIMIT_RULE (TYPX, EXP_S(X), EXP(X), _)
	funct::PRIMIT_RULE (TYPX, LOG_S(X), PROD(X, DIFF(LOG(X), NUM(1))), _._ *(_-num< 1 >()))
	funct::PRIMIT_RULE (TYPX, SGN_S(X), ABS(X), abs(_._))
	funct::PRIMIT_RULE (TYPX, SIN_S(X), MINUS(COS(X)),-cos(_._))
	funct::PRIMIT_RULE (TYPX, COS_S(X), SIN(X), sin(_._))
	funct::PRIMIT_RULE (TYPX, TAN_S(X), MINUS(LOG(ABS(COS(X)))),-log(abs(cos(_._))))
	funct::PRIMIT_RULE (TYPX, RATIO_S(NUM(1), X), LOG(ABS(X)), log(abs(_._2)))
	funct::PRIMIT_RULE (TYPX, POWER_S(X, NUM(-1)), LOG(ABS(X)), log(abs(_._1)))
	funct::PRIMIT_RULE (TYPX, RATIO_S(NUM(1), POWER_S(COS_S(X), NUM(2))), TAN(X), tan(_._2._1._))
	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._))
	funct::PRIMIT_RULE (TYPXT2, SUM_S(A, B), SUM(PRIMIT(X, A), PRIMIT(X, B)), primitive< X >(_._1)+primitive< X >(_._2))
	funct::PRIMIT_RULE (TYPXT1, MINUS_S(A), MINUS(PRIMIT(X, A)),-primitive< X >(_._))
template<typename X , typename F >
Primitive< F, X >::type	funct::primitive (const F &f)
template<typename F >
Primitive< F >::type	funct::primitive (const F &f)
	funct::TEMPL (XT2) struct PartIntegral<X

Macro Definition Documentation

#define DECLARE_FUNCT_PRIMITIVE	(		F,
			P
	)

Value:

namespace funct { \
template<> struct Primitive<F> { \
  typedef P type; \
  inline static type get(const F& _) \
  { return type(); } \
}; \
} \
struct __useless_ignoreme

Definition at line 302 of file Primitive.h.

#define DECLARE_PRIMITIVE	(		X,
			F,
			P
	)

Value:

namespace funct { \
template<typename X> struct Primitive<F, X> { \
  typedef P type; \
  inline static type get(const F& _) \
  { return type(_._); } \
}; \
} \
struct __useless_ignoreme

Definition at line 292 of file Primitive.h.