#include <algorithm>
#include <cmath>
#include <complex>
#include <limits>
#include <numeric>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <Eigen/Core>
#include "eigen_tensor.hpp"
#include "error.hpp"
#include "logger.hpp"
#include "if.hpp"
#include "sum.hpp"
#include "which.hpp"

Include dependency graph for wrappers.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	flexiblesusy

namespace	flexiblesusy::anonymous_namespace{wrappers.hpp}

Macros
#define	Conjugate(x) Conj(x)

#define	DEFINE_COMMUTATIVE_OPERATOR_COMPLEX_INT(op)

#define	DEFINE_PROJECTOR(M, N, X, Y)

#define	FSFlagProblem(p) [&](){ (p); return 0.; }()

#define	FSFlagWarning(p) [&](){ (p); return 0.; }()

#define	PROJECTOR Proj

#define	UNITMATRIX(rows) Eigen::Matrix<double,rows,rows>::Identity()

#define	UNITMATRIXCOMPLEX(rows) Eigen::Matrix<std::complex<double>,rows,rows>::Identity()

#define	ZEROARRAY(rows) Eigen::Array<double,rows,1>::Zero()

#define	ZEROARRAYCOMPLEX(rows) Eigen::Array<std::complex<double>,rows,1>::Zero()

#define	ZEROMATRIX(rows, cols) Eigen::Matrix<double,rows,cols>::Zero()

#define	ZEROMATRIXCOMPLEX(rows, cols) Eigen::Matrix<std::complex<double>,rows,cols>::Zero()

#define	ZEROTENSOR3(d1, d2, d3) ZeroTensor3<double,d1,d2,d3>()

#define	ZEROTENSOR3COMPLEX(d1, d2, d3) ZeroTensor3<std::complex<double>,d1,d2,d3>()

#define	ZEROTENSOR4(d1, d2, d3, d4) ZeroTensor4<double,d1,d2,d3,d4>()

#define	ZEROTENSOR4COMPLEX(d1, d2, d3, d4) ZeroTensor4<std::complex<double>,d1,d2,d3,d4>()

#define	ZEROVECTOR(rows) Eigen::Matrix<double,rows,1>::Zero()

#define	ZEROVECTORCOMPLEX(rows) Eigen::Matrix<std::complex<double>,rows,1>::Zero()

Functions
template<typename Derived >
auto	flexiblesusy::Abs (const Eigen::ArrayBase< Derived > &x) -> decltype(x.cwiseAbs().eval())

template<typename Derived >
auto	flexiblesusy::Abs (const Eigen::MatrixBase< Derived > &x) -> decltype(x.cwiseAbs().eval())

double	flexiblesusy::Abs (const std::complex< double > &x) noexcept

float	flexiblesusy::Abs (const std::complex< float > &x) noexcept

long double	flexiblesusy::Abs (const std::complex< long double > &x) noexcept

double	flexiblesusy::Abs (double x) noexcept

float	flexiblesusy::Abs (float x) noexcept

int	flexiblesusy::Abs (int x) noexcept

long double	flexiblesusy::Abs (long double x) noexcept

long long	flexiblesusy::Abs (long long x) noexcept

long	flexiblesusy::Abs (long x) noexcept

template<typename Derived >
auto	flexiblesusy::AbsSqr (const Eigen::ArrayBase< Derived > &x) -> decltype(x.cwiseAbs().eval().square().eval())

template<typename Derived >
auto	flexiblesusy::AbsSqr (const Eigen::MatrixBase< Derived > &x) -> decltype(AbsSqr(x.array()).matrix().eval())

double	flexiblesusy::AbsSqr (const std::complex< double > &x) noexcept

float	flexiblesusy::AbsSqr (const std::complex< float > &x) noexcept

long double	flexiblesusy::AbsSqr (const std::complex< long double > &x) noexcept

double	flexiblesusy::AbsSqr (double x) noexcept

float	flexiblesusy::AbsSqr (float x) noexcept

int	flexiblesusy::AbsSqr (int x) noexcept

long double	flexiblesusy::AbsSqr (long double x) noexcept

long long	flexiblesusy::AbsSqr (long long x) noexcept

long	flexiblesusy::AbsSqr (long x) noexcept

template<typename Derived >
auto	flexiblesusy::AbsSqrt (const Eigen::ArrayBase< Derived > &x) -> decltype(x.cwiseAbs().cwiseSqrt())

template<typename Derived >
auto	flexiblesusy::AbsSqrt (const Eigen::MatrixBase< Derived > &x) -> decltype(x.cwiseAbs().cwiseSqrt())

double	flexiblesusy::AbsSqrt (const std::complex< double > &x) noexcept

double	flexiblesusy::AbsSqrt (double x) noexcept

std::complex< double >	flexiblesusy::ArcCos (const std::complex< double > &x) noexcept

double	flexiblesusy::ArcCos (double x) noexcept

std::complex< double >	flexiblesusy::ArcSin (const std::complex< double > &x) noexcept

double	flexiblesusy::ArcSin (double x) noexcept

std::complex< double >	flexiblesusy::ArcTan (const std::complex< double > &x) noexcept

double	flexiblesusy::ArcTan (double x) noexcept

double	flexiblesusy::Arg (const std::complex< double > &x) noexcept

double	flexiblesusy::Arg (double x) noexcept

double	flexiblesusy::Cbrt (double x) noexcept

std::complex< double >	flexiblesusy::ComplexLog (const std::complex< double > &z) noexcept

std::complex< double >	flexiblesusy::ComplexLog (double a) noexcept

template<typename Derived >
auto	flexiblesusy::Conj (const Eigen::ArrayBase< Derived > &x) -> decltype(x.conjugate())

template<typename Derived >
auto	flexiblesusy::Conj (const Eigen::MatrixBase< Derived > &x) -> decltype(x.conjugate())

std::complex< double >	flexiblesusy::Conj (const std::complex< double > &x) noexcept

std::complex< float >	flexiblesusy::Conj (const std::complex< float > &x) noexcept

std::complex< long double >	flexiblesusy::Conj (const std::complex< long double > &x) noexcept

double	flexiblesusy::Conj (double x) noexcept

float	flexiblesusy::Conj (float x) noexcept

int	flexiblesusy::Conj (int x) noexcept

long double	flexiblesusy::Conj (long double x) noexcept

long long	flexiblesusy::Conj (long long x) noexcept

long	flexiblesusy::Conj (long x) noexcept

double	flexiblesusy::Cos (double x) noexcept

double	flexiblesusy::Cot (double a) noexcept

double	flexiblesusy::Csc (double x) noexcept

template<typename T >
constexpr T	flexiblesusy::Cube (T a) noexcept

int	flexiblesusy::Delta (int i, int j) noexcept

template<class Derived >
Eigen::MatrixBase< Derived >::PlainObject	flexiblesusy::Diag (const Eigen::MatrixBase< Derived > &m)

template<typename T >
T	flexiblesusy::Exp (T z) noexcept

double	flexiblesusy::FiniteLog (double a) noexcept

double	flexiblesusy::FSThrow (const std::string &s)

template<typename Derived >
void	flexiblesusy::Hermitianize (Eigen::PlainObjectBase< Derived > &m)

template<class Derived >
auto	flexiblesusy::Im (const Eigen::MatrixBase< Derived > &x) noexcept -> decltype(x.imag().eval())

double	flexiblesusy::Im (const std::complex< double > &x) noexcept

double	flexiblesusy::Im (double) noexcept

bool	flexiblesusy::IsClose (double a, double b, double eps) noexcept

bool	flexiblesusy::IsCloseRel (double a, double b, double eps) noexcept

template<class Derived >
bool	flexiblesusy::IsFinite (const Eigen::DenseBase< Derived > &m)

bool	flexiblesusy::IsFinite (const std::complex< double > &x) noexcept

bool	flexiblesusy::IsFinite (double x) noexcept

template<typename T >
T	flexiblesusy::KallenLambda (T x, T y, T z) noexcept

int	flexiblesusy::KroneckerDelta (int i, int j) noexcept

double	flexiblesusy::Log (double a) noexcept

template<int M, int N, int i, int j, typename Scalar = double>
auto	flexiblesusy::MatrixProjector () noexcept -> Eigen::Matrix< Scalar, M, N >
	matrix projector of size MxN into direction i, j

template<int M, int N, typename Scalar = double>
auto	flexiblesusy::MatrixProjector (int i, int j) noexcept -> Eigen::Matrix< Scalar, M, N >
	matrix projector of size MxN into direction i, j

Eigen::MatrixXd	flexiblesusy::MatrixProjector (int M, int N, int i, int j) noexcept
	unit matrix projector of size MxN into direction i, j

template<typename T >
T	flexiblesusy::Max (T &&t) noexcept

template<typename T0 , typename T1 , typename... Ts>
std::common_type< T0, T1, Ts... >::type	flexiblesusy::Max (T0 &&val1, T1 &&val2, Ts &&... vs) noexcept

template<class Derived >
auto	flexiblesusy::MaxAbsValue (const Eigen::ArrayBase< Derived > &x) noexcept -> decltype(x.cwiseAbs().maxCoeff())

template<class Derived >
auto	flexiblesusy::MaxAbsValue (const Eigen::MatrixBase< Derived > &x) noexcept -> decltype(x.cwiseAbs().maxCoeff())

double	flexiblesusy::MaxAbsValue (const std::complex< double > &x) noexcept

double	flexiblesusy::MaxAbsValue (double x) noexcept

template<class Derived >
auto	flexiblesusy::MaxRelDiff (const Eigen::PlainObjectBase< Derived > &a, const Eigen::PlainObjectBase< Derived > &b) -> decltype(MaxRelDiff(a.data()[0], b.data()[0]))

double	flexiblesusy::MaxRelDiff (const std::complex< double > &a, const std::complex< double > &b) noexcept

double	flexiblesusy::MaxRelDiff (double a, double b) noexcept

template<typename T >
T	flexiblesusy::Min (T &&t) noexcept

template<typename T0 , typename T1 , typename... Ts>
std::common_type< T0, T1, Ts... >::type	flexiblesusy::Min (T0 &&val1, T1 &&val2, Ts &&... vs) noexcept

template<typename T >
std::complex< T >	flexiblesusy::operator* (const std::complex< T > &lhs, int rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator* (int lhs, const std::complex< T > &rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator+ (const std::complex< T > &lhs, int rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator+ (int lhs, const std::complex< T > &rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator- (const std::complex< T > &lhs, int rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator- (int lhs, const std::complex< T > &rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator/ (const std::complex< T > &lhs, int rhs)

template<typename T >
std::complex< T >	flexiblesusy::operator/ (int lhs, const std::complex< T > &rhs)

std::complex< double >	flexiblesusy::PolyLog (int, const std::complex< double > &) noexcept
	complex polylogarithm

double	flexiblesusy::PolyLog (int, double) noexcept
	real polylogarithm

template<typename Base , typename Exponent >
Base	flexiblesusy::Power (Base base, Exponent exp) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power10 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power11 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power12 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power2 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power3 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power4 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power5 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power6 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power7 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power8 (Base b) noexcept

template<typename Base >
constexpr Base	flexiblesusy::Power9 (Base b) noexcept

template<typename... Ts>
double	flexiblesusy::PrintDEBUG (Ts &&... vs)
	print debug information to cerr

template<typename... Ts>
double	flexiblesusy::PrintERROR (Ts &&... vs)
	print error to cerr

template<typename... Ts>
double	flexiblesusy::PrintFATAL (Ts &&... vs)
	print error to cerr and stop program

template<typename... Ts>
double	flexiblesusy::PrintINFO (Ts &&... vs)
	print an information message

template<typename Printer >
void	flexiblesusy::anonymous_namespace{wrappers.hpp}::PrintTo (std::stringstream &ostr, Printer &&printer)

template<typename Printer , typename T0 , typename... Ts>
void	flexiblesusy::anonymous_namespace{wrappers.hpp}::PrintTo (std::stringstream &ostr, Printer &&printer, T0 &&v, Ts &&... vs)

template<typename... Ts>
double	flexiblesusy::PrintVERBOSE (Ts &&... vs)
	print verbose information to cerr

template<typename... Ts>
double	flexiblesusy::PrintWARNING (Ts &&... vs)
	print warning to cerr

template<typename T >
constexpr T	flexiblesusy::Quad (T a) noexcept

template<class Derived >
auto	flexiblesusy::Re (const Eigen::MatrixBase< Derived > &x) noexcept -> decltype(x.real().eval())

double	flexiblesusy::Re (const std::complex< double > &x) noexcept

double	flexiblesusy::Re (double x) noexcept

template<typename T >
T	flexiblesusy::RelDiff (T a, T b, T eps=std::numeric_limits< T >::epsilon()) noexcept

int	flexiblesusy::Round (double a) noexcept

double	flexiblesusy::Sec (double x) noexcept

int	flexiblesusy::Sign (double x) noexcept

int	flexiblesusy::Sign (int x) noexcept

template<typename Derived >
auto	flexiblesusy::SignedAbsSqrt (const Eigen::ArrayBase< Derived > &a) noexcept -> typename Derived::PlainObject
	component-wise signed square root of absolute

double	flexiblesusy::SignedAbsSqrt (double a) noexcept
	signed square root of absolute

double	flexiblesusy::Sin (double x) noexcept

template<typename Derived >
auto	flexiblesusy::Sqr (const Eigen::ArrayBase< Derived > &a) noexcept -> typename Derived::PlainObject
	component-wise square

template<typename Derived >
auto	flexiblesusy::Sqr (const Eigen::MatrixBase< Derived > &a) noexcept -> typename Derived::PlainObject
	matrix square

template<typename T >
constexpr std::complex< T >	flexiblesusy::Sqr (const std::complex< T > &a) noexcept

template<typename T , class = std::enable_if_t<std::is_arithmetic<T>::value,T>>
constexpr T	flexiblesusy::Sqr (T a) noexcept

template<typename Derived >
auto	flexiblesusy::Sqrt (const Eigen::ArrayBase< Derived > &a) noexcept -> typename Derived::PlainObject
	component-wise square root

template<class T , typename = std::enable_if_t<std::is_floating_point<T>::value,T>>
T	flexiblesusy::Sqrt (T a) noexcept

template<class T , typename = std::enable_if_t<std::is_integral<T>::value,T>>
double	flexiblesusy::Sqrt (T a) noexcept

template<typename Derived >
void	flexiblesusy::Symmetrize (Eigen::PlainObjectBase< Derived > &m)

double	flexiblesusy::Tan (double a) noexcept

template<class Scalar , int M>
Eigen::Matrix< Scalar, M, M >	flexiblesusy::ToMatrix (const Eigen::Array< Scalar, M, 1 > &a) noexcept

template<class Scalar , int M, int N>
Eigen::Matrix< Scalar, M, N >	flexiblesusy::ToMatrix (const Eigen::Matrix< Scalar, M, N > &a) noexcept

std::string	flexiblesusy::ToString (char a)

std::string	flexiblesusy::ToString (const std::complex< double > &a)

std::string	flexiblesusy::ToString (double a)

std::string	flexiblesusy::ToString (signed char a)

std::string	flexiblesusy::ToString (signed int a)

std::string	flexiblesusy::ToString (signed long a)

std::string	flexiblesusy::ToString (signed long long a)

std::string	flexiblesusy::ToString (signed short a)

std::string	flexiblesusy::ToString (unsigned char a)

std::string	flexiblesusy::ToString (unsigned int a)

std::string	flexiblesusy::ToString (unsigned long a)

std::string	flexiblesusy::ToString (unsigned long long a)

std::string	flexiblesusy::ToString (unsigned short a)

template<typename Derived >
auto	flexiblesusy::Total (const Eigen::DenseBase< Derived > &a) noexcept -> typename Derived::Scalar
	sum of elements

std::complex< double >	flexiblesusy::Total (const std::complex< double > &) noexcept
	sum of all arguments

double	flexiblesusy::Total (double) noexcept
	sum of all arguments

template<typename T >
constexpr int	flexiblesusy::UnitStep (T x) noexcept
	step function (0 for x < 0, 1 otherwise)

template<int N, int i, typename Scalar = double>
constexpr auto	flexiblesusy::UnitVector () noexcept -> Eigen::Matrix< Scalar, N, 1 >
	unit vector of length N into direction i

template<int N, typename Scalar = double>
constexpr auto	flexiblesusy::UnitVector (int i) noexcept -> Eigen::Matrix< Scalar, N, 1 >
	unit vector of length N into direction i

Eigen::VectorXd	flexiblesusy::UnitVector (int N, int i) noexcept
	unit vector of length N into direction i

template<typename Derived >
Derived	flexiblesusy::ZeroSqrt (const Eigen::ArrayBase< Derived > &m) noexcept
	sqrt(x) for x >= 0; 0 for x < 0

double	flexiblesusy::ZeroSqrt (double x) noexcept
	sqrt(x) for x >= 0; 0 for x < 0

Variables
static constexpr double	flexiblesusy::fiveLoop = 1.018360064207223307e-11

static constexpr double	flexiblesusy::fourLoop = 1.608129755454920543e-09

static constexpr double	flexiblesusy::ln2 = 0.69314718055994531

static constexpr double	flexiblesusy::oneLoop = 6.332573977646110963e-03

static constexpr double	flexiblesusy::oneOver16Pi = 0.019894367886486917

static constexpr double	flexiblesusy::oneOver16PiSqr = 6.332573977646110963e-03

static constexpr double	flexiblesusy::oneOver4Pi = 0.079577471545947668

static constexpr double	flexiblesusy::oneOverSqrt2 = 0.70710678118654752

static constexpr double	flexiblesusy::Pi = 3.141592653589793

static constexpr double	flexiblesusy::sqrt2 = 1.4142135623730950

static constexpr double	flexiblesusy::threeLoop = 2.539456721913701978e-07

static constexpr bool	flexiblesusy::True = true

static constexpr double	flexiblesusy::twoLoop = 4.010149318236068752e-05

static constexpr double	flexiblesusy::zeta2 = 1.6449340668482264

static constexpr double	flexiblesusy::zeta3 = 1.2020569031595943

static constexpr double	flexiblesusy::zeta4 = 1.0823232337111382

static constexpr double	flexiblesusy::zeta5 = 1.0369277551433699

Macro Definition Documentation

◆ Conjugate

#define Conjugate ( x ) Conj(x)

Definition at line 176 of file wrappers.hpp.

◆ DEFINE_COMMUTATIVE_OPERATOR_COMPLEX_INT

#define DEFINE_COMMUTATIVE_OPERATOR_COMPLEX_INT ( op )

Value:

   template <typename T>                                                \
   std::complex<T> operator op(const std::complex<T>& lhs, int rhs)     \
   {                                                                    \
      return lhs op static_cast<T>(rhs);                                \
   }                                                                    \
                                                                        \
   template <typename T>                                                \
   std::complex<T> operator op(int lhs, const std::complex<T>& rhs)     \
   {                                                                    \
      return static_cast<T>(lhs) op rhs;                                \
   }

Definition at line 661 of file wrappers.hpp.

◆ DEFINE_PROJECTOR

#define DEFINE_PROJECTOR	(	M,
		N,
		X,
		Y
	)

Value:

Eigen::Matrix<double,M,N> Proj(Eigen::Matrix<double,M,N>::Zero()); \

Proj((X)-1,(Y)-1) = 1;

Definition at line 715 of file wrappers.hpp.

◆ FSFlagProblem

#define FSFlagProblem ( p ) [&](){ (p); return 0.; }()

Definition at line 209 of file wrappers.hpp.

◆ FSFlagWarning

#define FSFlagWarning ( p ) [&](){ (p); return 0.; }()

Definition at line 213 of file wrappers.hpp.

◆ PROJECTOR

#define PROJECTOR Proj

Definition at line 714 of file wrappers.hpp.

◆ UNITMATRIX

#define UNITMATRIX ( rows ) Eigen::Matrix<double,rows,rows>::Identity()

Definition at line 699 of file wrappers.hpp.

◆ UNITMATRIXCOMPLEX

#define UNITMATRIXCOMPLEX ( rows ) Eigen::Matrix<std::complex<double>,rows,rows>::Identity()

Definition at line 705 of file wrappers.hpp.

◆ ZEROARRAY

#define ZEROARRAY ( rows ) Eigen::Array<double,rows,1>::Zero()

Definition at line 704 of file wrappers.hpp.

◆ ZEROARRAYCOMPLEX

#define ZEROARRAYCOMPLEX ( rows ) Eigen::Array<std::complex<double>,rows,1>::Zero()

Definition at line 710 of file wrappers.hpp.

◆ ZEROMATRIX

#define ZEROMATRIX	(	rows,
		cols
	)	Eigen::Matrix<double,rows,cols>::Zero()

Definition at line 700 of file wrappers.hpp.

◆ ZEROMATRIXCOMPLEX

#define ZEROMATRIXCOMPLEX	(	rows,
		cols
	)	Eigen::Matrix<std::complex<double>,rows,cols>::Zero()

Definition at line 706 of file wrappers.hpp.

◆ ZEROTENSOR3

#define ZEROTENSOR3	(	d1,
		d2,
		d3
	)	ZeroTensor3<double,d1,d2,d3>()

Definition at line 701 of file wrappers.hpp.

◆ ZEROTENSOR3COMPLEX

#define ZEROTENSOR3COMPLEX	(	d1,
		d2,
		d3
	)	ZeroTensor3<std::complex<double>,d1,d2,d3>()

Definition at line 708 of file wrappers.hpp.

◆ ZEROTENSOR4

#define ZEROTENSOR4	(	d1,
		d2,
		d3,
		d4
	)	ZeroTensor4<double,d1,d2,d3,d4>()

Definition at line 702 of file wrappers.hpp.

◆ ZEROTENSOR4COMPLEX

#define ZEROTENSOR4COMPLEX	(	d1,
		d2,
		d3,
		d4
	)	ZeroTensor4<std::complex<double>,d1,d2,d3,d4>()

Definition at line 709 of file wrappers.hpp.

◆ ZEROVECTOR

#define ZEROVECTOR ( rows ) Eigen::Matrix<double,rows,1>::Zero()

Definition at line 703 of file wrappers.hpp.

◆ ZEROVECTORCOMPLEX

#define ZEROVECTORCOMPLEX ( rows ) Eigen::Matrix<std::complex<double>,rows,1>::Zero()

Definition at line 707 of file wrappers.hpp.

Namespaces

Macros

Functions

Variables