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), AB1) type
typedef	funct::DIFF (PROD(A, B1), PRIMIT(X, PROD(A1, B1))) type
static type	funct::get (const PROD_S(A, B) &_)
static type	funct::get (const PROD_S(B, A) &_)
static type	funct::get (const RATIO_S(A, B) &_)
static type	funct::get (const RATIO_S(B, A) &_)
	funct::GET (PROD_S(A, B), _ *X())
	funct::GET (PROD_S(A, B), _._1 *primitive< X >(_._2))
	funct::GET (PROD_S(A, B), _._2 *primitive< X >(_._1))
	funct::GET (RATIO_S(A, B), _ *X())
	funct::GET (RATIO_S(A, B), _._1 *primitive< X >(num< 1 >/_._2))
	funct::GET (RATIO_S(A, B), primitive< X >(_._1)/_._2)
typedef	funct::PRIMIT (X, PROD(A1, B1)) AB1
	funct::PRIMIT_RULE (TYPX, COS_S(X), SIN(X), sin(_._))
	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, 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 (TYPX, RATIO_S(NUM(1), X), LOG(ABS(X)), log(abs(_._2)))
	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, SQRT_S(X), PRIMIT(X, POWER_S(X, FRACT_S(1, 2))),(fract< 2, 3 >() *pow(_._, fract< 3, 2 >())))
	funct::PRIMIT_RULE (TYPX, TAN_S(X), MINUS(LOG(ABS(COS(X)))), -log(abs(cos(_._))))
	funct::PRIMIT_RULE (TYPX, X, RATIO(POWER(X, NUM(2)), NUM(2)), pow(_, num< 2 >())/num< 2 >())
	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 (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 (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 (TYPXT1, MINUS_S(A), MINUS(PRIMIT(X, A)), -primitive< X >(_._))
	funct::PRIMIT_RULE (TYPXT2, POWER_S(A, B), UndefinedIntegral, type())
	funct::PRIMIT_RULE (TYPXT2, SUM_S(A, B), SUM(PRIMIT(X, A), PRIMIT(X, B)), primitive< X >(_._1)+primitive< X >(_._2))
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

Variables
true	funct::__pad2__
X	funct::__pad3__

Macro Definition Documentation

DECLARE_FUNCT_PRIMITIVE

#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 293 of file Primitive.h.

DECLARE_PRIMITIVE

#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 283 of file Primitive.h.