HepLib
HEP.h
Go to the documentation of this file.
1 
6 #pragma once
7 
8 #include "BASIC.h"
9 #include "IBP.h"
10 
11 namespace HepLib {
12 
13  using namespace std;
14  using namespace GiNaC;
15  using namespace HepLib;
16 
17  extern exmap SP_map;
18 
19  extern int form_trace_mode;
20  extern const int form_trace_auto;
21  extern const int form_trace_all;
22  extern const int form_trace_each_all;
23  extern const int form_trace_each_each;
24 
25  extern int form_expand_mode;
26  extern const int form_expand_none;
27  extern const int form_expand_tr;
28  extern const int form_expand_ci;
29  extern const int form_expand_li;
30  extern const int form_expand_all;
31 
32  extern bool Apart_using_fermat;
33  extern bool form_using_su3;
34  extern bool form_using_dim4;
35  extern bool form_using_gamma5;
36 
37  class Index;
38  class Vector;
39  class Pair;
40 
44  class FormFormat : public print_dflt {
45  GINAC_DECLARE_PRINT_CONTEXT(FormFormat, print_dflt)
46  public:
47  FormFormat(ostream &os, unsigned opt=0);
48  static void power_print(const power & p, const FormFormat & c, unsigned level=0);
49 
50  template<class T> const FormFormat & operator << (const T & v) const {
51  s << v;
52  return *this;
53  };
54  const FormFormat & operator << (const basic & v) const;
55  const FormFormat & operator << (const ex & v) const;
56  const FormFormat & operator << (const lst & v) const;
57  const FormFormat & operator<<(std::ostream& (*v)(std::ostream&)) const;
58 
59  #ifndef DOXYGEN_SKIP
60  class _init {
61  public: _init();
62  };
63  private:
64  static _init FormFormat_init;
65  #endif
66  };
67 
71  class FCFormat : public print_dflt {
72  GINAC_DECLARE_PRINT_CONTEXT(FCFormat, print_dflt)
73  public:
74  FCFormat(ostream &os, unsigned opt=0);
75  static void ncmul_print(const ncmul & p, const FCFormat & c, unsigned level=0);
76 
77  template<class T> const FCFormat & operator << (const T & v) const {
78  s << v;
79  return *this;
80  };
81  const FCFormat & operator << (const basic & v) const;
82  const FCFormat & operator << (const ex & v) const;
83  const FCFormat & operator << (const lst & v) const;
84  const FCFormat & operator<<(std::ostream& (*v)(std::ostream&)) const;
85 
86  const FCFormat & operator << (const matrix & v) const;
87  const FCFormat & operator << (const exvector & v) const;
88  const FCFormat & operator << (const exmap & v) const;
89  const FCFormat & operator << (const exset & v) const;
90 
91  #ifndef DOXYGEN_SKIP
92  class _init {
93  public: _init();
94  };
95  private:
96  static _init FCFormat_init;
97  #endif
98  };
99  extern FCFormat fcout;
100 
104  class Index : public basic {
105  //GINAC_DECLARE_REGISTERED_CLASS(Index, basic)
106  private:
107  static GiNaC::registered_class_info reg_info;
108  public:
109  static GiNaC::exmap Dimension;
110  static GiNaC::registered_class_info &get_class_info_static();
111  class visitor {
112  public:
113  virtual void visit(const Index &) = 0; // classname
114  virtual ~visitor();
115  };
116  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
117  typedef basic inherited; // supername
118  Index(); // classname
119  Index * duplicate() const override; // classname
120  void accept(GiNaC::visitor & v) const override;
121  const GiNaC::registered_class_info &get_class_info() const override;
122  GiNaC::registered_class_info &get_class_info() override;
123  const char *class_name() const override;
124  protected:
125  int compare_same_type(const GiNaC::basic & other) const override;
126  // GINAC_DECLARE_REGISTERED_CLASS END
127 
128  public:
129  enum Type {VD, CF, CA};
130  Index(const string &s, const Type type=Type::VD);
131  Pair operator() (const Index & i);
132  Pair operator() (const Vector & p);
133  Symbol name;
134  Type type;
135  void print(const print_context &c, unsigned level = 0) const;
136  void archive(archive_node & n) const override;
137  void read_archive(const archive_node& n) override;
138  static bool has(const ex &e);
139  static bool hasc(const ex &e);
140  static bool hasv(const ex &e);
141  static lst all(const ex &e);
142  ex derivative(const symbol & s) const override;
143  bool is_equal_same_type(const basic & other) const override;
144  };
145 
149  class Vector : public basic {
150  //GINAC_DECLARE_REGISTERED_CLASS(Vector, basic)
151  private:
152  static GiNaC::registered_class_info reg_info;
153  public:
154  static GiNaC::registered_class_info &get_class_info_static();
155  class visitor {
156  public:
157  virtual void visit(const Vector &) = 0; // classname
158  virtual ~visitor();
159  };
160  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
161  typedef basic inherited; // supername
162  Vector(); // classname
163  Vector * duplicate() const override; // classname
164  void accept(GiNaC::visitor & v) const override;
165  const GiNaC::registered_class_info &get_class_info() const override;
166  GiNaC::registered_class_info &get_class_info() override;
167  const char *class_name() const override;
168  protected:
169  int compare_same_type(const GiNaC::basic & other) const override;
170  // GINAC_DECLARE_REGISTERED_CLASS END
171 
172  public:
173  Vector(const string &s);
174  Pair operator() (const Vector & p);
175  Pair operator() (const Index & mu);
176  Symbol name;
177  void print(const print_context &c, unsigned level = 0) const;
178  void archive(archive_node & n) const override;
179  void read_archive(const archive_node& n) override;
180  static bool has(const ex &e);
181  static lst all(const ex &e);
182  ex derivative(const symbol & s) const override;
183  bool is_equal_same_type(const basic & other) const override;
184  };
185 
189  class SUNT : public basic {
190  //GINAC_DECLARE_REGISTERED_CLASS(SUNT, basic)
191  private:
192  static GiNaC::registered_class_info reg_info;
193  public:
194  static GiNaC::registered_class_info &get_class_info_static();
195  class visitor {
196  public:
197  virtual void visit(const SUNT &) = 0; // classname
198  virtual ~visitor();
199  };
200  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
201  typedef basic inherited; // supername
202  SUNT(); // classname
203  SUNT * duplicate() const override; // classname
204  void accept(GiNaC::visitor & v) const override;
205  const GiNaC::registered_class_info &get_class_info() const override;
206  GiNaC::registered_class_info &get_class_info() override;
207  const char *class_name() const override;
208  protected:
209  int compare_same_type(const GiNaC::basic & other) const override;
210  // GINAC_DECLARE_REGISTERED_CLASS END
211 
212  public:
213  SUNT(ex a, ex i, ex j);
214  ex aij[3]; // Index
215  size_t nops() const override;
216  ex op(size_t i) const override;
217  ex& let_op(size_t i) override;
218  void form_print(const FormFormat &c, unsigned level = 0) const;
219  void fc_print(const FCFormat &c, unsigned level = 0) const;
220  void print(const print_dflt &c, unsigned level = 0) const;
221  void archive(archive_node & n) const override;
222  void read_archive(const archive_node& n) override;
223  static bool has(const ex &e);
224  static lst all(const ex &e);
225  ex derivative(const symbol & s) const override;
226  ex conjugate() const override;
227  bool is_equal_same_type(const basic & other) const override;
228  };
229 
233  class SUNF : public basic {
234  //GINAC_DECLARE_REGISTERED_CLASS(SUNF, basic)
235  private:
236  static GiNaC::registered_class_info reg_info;
237  public:
238  static GiNaC::registered_class_info &get_class_info_static();
239  class visitor {
240  public:
241  virtual void visit(const SUNF &) = 0; // classname
242  virtual ~visitor();
243  };
244  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
245  typedef basic inherited; // supername
246  SUNF(); // classname
247  SUNF * duplicate() const override; // classname
248  void accept(GiNaC::visitor & v) const override;
249  const GiNaC::registered_class_info &get_class_info() const override;
250  GiNaC::registered_class_info &get_class_info() override;
251  const char *class_name() const override;
252  protected:
253  int compare_same_type(const GiNaC::basic & other) const override;
254  // GINAC_DECLARE_REGISTERED_CLASS END
255 
256  public:
257  SUNF(ex i, ex j, ex k);
258  ex ijk[3]; // Index
259  size_t nops() const override;
260  ex op(size_t i) const override;
261  ex& let_op(size_t i) override;
262  ex eval() const override;
263  void print(const print_dflt &c, unsigned level = 0) const;
264  void form_print(const FormFormat &c, unsigned level = 0) const;
265  void fc_print(const FCFormat &c, unsigned level = 0) const;
266  void archive(archive_node & n) const override;
267  void read_archive(const archive_node& n) override;
268  static bool has(const ex &e);
269  static lst all(const ex &e);
270  ex derivative(const symbol & s) const override;
271  bool is_equal_same_type(const basic & other) const override;
272  };
273 
274 
278  class SUNF4 : public basic {
279  //GINAC_DECLARE_REGISTERED_CLASS(SUNF4, basic)
280  private:
281  static GiNaC::registered_class_info reg_info;
282  public:
283  static GiNaC::registered_class_info &get_class_info_static();
284  class visitor {
285  public:
286  virtual void visit(const SUNF4 &) = 0; // classname
287  virtual ~visitor();
288  };
289  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
290  typedef basic inherited; // supername
291  SUNF4(); // classname
292  SUNF4 * duplicate() const override; // classname
293  void accept(GiNaC::visitor & v) const override;
294  const GiNaC::registered_class_info &get_class_info() const override;
295  GiNaC::registered_class_info &get_class_info() override;
296  const char *class_name() const override;
297  protected:
298  int compare_same_type(const GiNaC::basic & other) const override;
299  // GINAC_DECLARE_REGISTERED_CLASS END
300 
301  public:
302  SUNF4(ex i, ex j, ex k, ex l);
303  ex ijkl[4]; // Index
304  size_t nops() const override;
305  ex op(size_t i) const override;
306  ex& let_op(size_t i) override;
307  ex eval() const override;
308  void print(const print_dflt &c, unsigned level = 0) const;
309  void form_print(const FormFormat &c, unsigned level = 0) const;
310  void fc_print(const FCFormat &c, unsigned level = 0) const;
311  void archive(archive_node & n) const override;
312  void read_archive(const archive_node& n) override;
313  static bool has(const ex &e);
314  static lst all(const ex &e);
315  ex derivative(const symbol & s) const override;
316  bool is_equal_same_type(const basic & other) const override;
317  };
318 
322  class Pair : public basic {
323  //GINAC_DECLARE_REGISTERED_CLASS(Pair, basic)
324  private:
325  static GiNaC::registered_class_info reg_info;
326  public:
327  static GiNaC::registered_class_info &get_class_info_static();
328  class visitor {
329  public:
330  virtual void visit(const Pair &) = 0; // classname
331  virtual ~visitor();
332  };
333  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
334  typedef basic inherited; // supername
335  Pair(); // classname
336  Pair * duplicate() const override; // classname
337  void accept(GiNaC::visitor & v) const override;
338  const GiNaC::registered_class_info &get_class_info() const override;
339  GiNaC::registered_class_info &get_class_info() override;
340  const char *class_name() const override;
341  protected:
342  int compare_same_type(const GiNaC::basic & other) const override;
343  // GINAC_DECLARE_REGISTERED_CLASS END
344 
345  public:
346  Pair(const Vector &p1, const Vector &p2);
347  Pair(const Index &i1, const Index &i2);
348  Pair(const Vector &p, const Index &i);
349  Pair(const Index &i, const Vector &p);
350  size_t nops() const override;
351  ex op(size_t i) const override;
352  ex& let_op(size_t i) override;
353  ex eval() const override;
354  void print(const print_dflt &c, unsigned level = 0) const;
355  void form_print(const FormFormat &c, unsigned level = 0) const;
356  void fc_print(const FCFormat &c, unsigned level = 0) const;
357  void archive(archive_node & n) const override;
358  void read_archive(const archive_node& n) override;
359  static bool has(const ex &e);
360  static lst all(const ex &e);
361  ex derivative(const symbol & s) const override;
362  bool is_equal_same_type(const basic & other) const override;
363  private:
364  ex lr[2];
365  };
366 
367  ex SP(const ex &a, bool use_map=false);
368  ex SP(const ex &a, const ex &b, bool use_map=false);
369  ex sp(const ex & a, const ex & b);
370  ex sp(const ex & a);
371  ex& letSP(const ex &p1, const ex &p2);
372  ex& letSP(const ex &p);
373  void clearSP(const ex &p1, const ex &p2);
374  void clearSP(const ex &p);
375  void clearSP();
376  ex SP2sp(const ex & exin);
377  exmap sp_map();
378 
386  class Eps : public basic {
387  //GINAC_DECLARE_REGISTERED_CLASS(Eps, basic)
388  private:
389  static GiNaC::registered_class_info reg_info;
390  public:
391  static GiNaC::registered_class_info &get_class_info_static();
392  class visitor {
393  public:
394  virtual void visit(const Eps &) = 0; // classname
395  virtual ~visitor();
396  };
397  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
398  typedef basic inherited; // supername
399  Eps(); // classname
400  Eps * duplicate() const override; // classname
401  void accept(GiNaC::visitor & v) const override;
402  const GiNaC::registered_class_info &get_class_info() const override;
403  GiNaC::registered_class_info &get_class_info() override;
404  const char *class_name() const override;
405  protected:
406  int compare_same_type(const GiNaC::basic & other) const override;
407  // GINAC_DECLARE_REGISTERED_CLASS END
408 
409  public:
410  exvector pis;
411  Eps(const Vector &p1, const Vector &p2, const Vector &p3, const Vector &p4);
412  Eps(const Vector &p1, const Vector &p2, const Vector &p3, const Index &i1);
413  Eps(const Vector &p1, const Vector &p2, const Index &i1, const Index &i2);
414  Eps(const Vector &p1, const Index &i1, const Index &i2, const Index &i3);
415  Eps(const Index &i1, const Index &i2, const Index &i3, const Index &i4);
416  Eps(vector<Vector> vs, vector<Index> is);
417  Eps(const exvector & pis0);
418  size_t nops() const override;
419  ex op(size_t i) const override;
420  ex & let_op(size_t i) override;
421  ex eval() const override;
422  void print(const print_dflt &c, unsigned level = 0) const;
423  void form_print(const FormFormat &c, unsigned level = 0) const;
424  void fc_print(const FCFormat &c, unsigned level = 0) const;
425  void archive(archive_node & n) const override;
426  void read_archive(const archive_node& n) override;
427  static bool has(const ex &e);
428  static lst all(const ex &e);
429  ex derivative(const symbol & s) const override;
430  bool is_equal_same_type(const basic & other) const override;
431  };
432  ex LC(ex pi1, ex pi2, ex pi3, ex pi4);
433 
437  class DGamma : public basic {
438  //GINAC_DECLARE_REGISTERED_CLASS(DGamma, basic)
439  private:
440  static GiNaC::registered_class_info reg_info;
441  public:
442  static GiNaC::registered_class_info &get_class_info_static();
443  class visitor {
444  public:
445  virtual void visit(const DGamma &) = 0; // classname
446  virtual ~visitor();
447  };
448  template<class B, typename... Args> friend B & dynallocate(Args &&... args);
449  typedef basic inherited; // supername
450  DGamma(); // classname
451  DGamma * duplicate() const override; // classname
452  void accept(GiNaC::visitor & v) const override;
453  const GiNaC::registered_class_info &get_class_info() const override;
454  GiNaC::registered_class_info &get_class_info() override;
455  const char *class_name() const override;
456  protected:
457  int compare_same_type(const GiNaC::basic & other) const override;
458  // GINAC_DECLARE_REGISTERED_CLASS END
459 
460  public:
461  ex pi;
462  unsigned rl;
463  DGamma(const Vector &p, unsigned rl=0);
464  DGamma(const Index &i, unsigned rl=0);
465  DGamma(int int_1567, unsigned _rl=0);
466  DGamma(const DGamma &g, unsigned _rl);
467  void print(const print_dflt &c, unsigned level = 0) const;
468  void form_print(const FormFormat &c, unsigned level = 0) const;
469  void fc_print(const FCFormat &c, unsigned level = 0) const;
470  return_type_t return_type_tinfo() const override;
471  unsigned return_type() const override { return return_types::noncommutative; }
472  bool match_same_type(const basic & other) const override;
473  unsigned get_rl();
474  size_t nops() const override;
475  ex op(size_t i) const override;
476  ex& let_op(size_t i) override;
477  ex eval() const override;
478  void archive(archive_node & n) const override;
479  void read_archive(const archive_node& n) override;
480  static bool has(const ex &e);
481  static lst all(const ex &e);
482  ex derivative(const symbol & s) const override;
483  ex conjugate() const override;
484  bool is_equal_same_type(const basic & other) const override;
485  };
486 
487  //-----------------------------------------------------------
488  // TR/GAS functions
489  //-----------------------------------------------------------
490  DECLARE_FUNCTION_3P(Matrix)
491  DECLARE_FUNCTION_1P(TR)
492  DECLARE_FUNCTION_1P(TTR)
493  DECLARE_FUNCTION_1P(HF)
494 
495  inline ex GAS(const Vector &p, unsigned rl=0) { return DGamma(p,rl); }
496  inline ex GAS(const Index &i, unsigned rl=0) { return DGamma(i,rl); }
497  ex GAS(const ex &expr, unsigned rl=0);
498 
499  // Form, TIR, Apart
500  ex charge_conjugate(const ex &);
501  ex form(const ex &expr, int verb=0);
502  ex UnContract(const ex expr, const lst &loop_ps, const lst &ext_ps=lst{}); // Eps/DGamma always uncontract
503  ex TIR(const ex &expr_in, const lst &loop_ps, const lst &ext_ps);
504  ex MatrixContract(const ex & expr_in);
505  ex Apart(const matrix & mat);
506  ex Apart(const ex &expr_in, const lst &vars, exmap sgnmap={});
507  ex Apart(const ex &expr_in, const lst &loops, const lst & extmoms, exmap sgnmap={});
508  ex ApartIR2ex(const ex & expr_in);
509  ex ApartIR2F(const ex & expr_in);
510  ex F2ex(const ex & expr_in);
511  ex ApartIRC(const ex & expr_in);
512  void ApartIBP(exvector &io_vec, int IBPmethod, const lst & loops, const lst & exts,
513  const lst & cut_props=lst{}, std::function<lst(const IBP &, const ex &)> uf=LoopUF);
514  inline void ApartIBP(int IBPmethod, exvector &io_vec, const lst & loops, const lst & exts,
515  const lst & cut_props=lst{}, std::function<lst(const IBP &, const ex &)> uf=LoopUF) {
516  return ApartIBP(io_vec, IBPmethod, loops, exts, cut_props, uf);
517  }
518  exmap ApartRules(const exvector &airs, bool irc=true);
519 
520  struct AIOption {
521  int pn_sector = 0; // treat each sector as a spearate problem when total denominators > pn_sector, set 0 to disable this feature
522  bool ap_rules = true; // minimize the total number of ibp problems
523  int IBPmethod = 1; // 0
524  lst Internal; // Internal for Apart/IBP
525  lst External; // External for Apart/IBP
526  lst DSP; // DSP for IBP
527  exmap smap; // Sign Map for Apart
528  lst Cut; // Cut Propagator. optional
529  lst CSP; // SP in Cut, to be cleared. optional
530  lst ISP; // SP for IBP. optional
531  bool CutFirst = true;
532  bool keep0F = false; // keep 0 exponent in F
533  int NIBP = 0;
534  ex apart1 = 0; // set Apart(1,{x,y,...}) to apart1
535  lst pat = { F(w1,w2), gs, nL, nH };
536  std::function<ex(const ex &, const ex &)> cv = nullptr;
537  string SaveDir = ""; // save temporary result, and restart from it
538  std::function<lst(const IBP &, const ex &)> UF = LoopUF;
539  void init_smap() { for(auto li : Internal) smap[SP(li)] = 1; }
540  };
541  void ApartIBP(exvector &io_vec, AIOption aip);
542 
543  bool IsZero(const ex & e);
544 
545  #ifndef DOXYGEN_SKIP
546 
547  class ApartIR1_SERIAL { public: static unsigned serial; };
548  template<typename T1>
549  inline GiNaC::function ApartIR(const T1 & p1) {
550  return GiNaC::function(ApartIR1_SERIAL::serial, ex(p1));
551  }
552 
553  class ApartIR2_SERIAL { public: static unsigned serial; };
554  template<typename T1, typename T2>
555  inline GiNaC::function ApartIR(const T1 & p1, const T2 & p2) {
556  return GiNaC::function(ApartIR2_SERIAL::serial, ex(p1), ex(p2));
557  }
558 
559  #endif
560 
561  ex ToCF(const ex & e);
562  ex ToCACF(const ex & e);
563  ex HomCACF(const ex & e);
564  ex DoColor(const ex & e, const ex & pref=1, int method=0);
565  ex A0(const ex m2, int n=1, const ex d=4-2*ep);
566 
567 
568 }
569 
a
int * a
Definition: Functions.cpp:234
BASIC.h
Basic header file.
IBP.h
IBP header file.
HepLib::DGamma::visitor::visit
virtual void visit(const DGamma &)=0
HepLib::DGamma
class for Dirac Gamma object
Definition: HEP.h:437
HepLib::DGamma::return_type
unsigned return_type() const override
Definition: HEP.h:471
HepLib::DGamma::all
static lst all(const ex &e)
HepLib::DGamma::inherited
basic inherited
Definition: HEP.h:449
HepLib::DGamma::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::DGamma::has
static bool has(const ex &e)
HepLib::DGamma::rl
unsigned rl
Definition: HEP.h:462
HepLib::Eps::visitor::visit
virtual void visit(const Eps &)=0
HepLib::Eps
class for Levi-Civita object https://onlinelibrary.wiley.com/doi/pdf/10.1002/9783527630097....
Definition: HEP.h:386
HepLib::Eps::has
static bool has(const ex &e)
HepLib::Eps::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::Eps::all
static lst all(const ex &e)
HepLib::Eps::inherited
basic inherited
Definition: HEP.h:398
HepLib::Eps::pis
exvector pis
Definition: HEP.h:410
HepLib::FCFormat
class for FCFormat Output
Definition: HEP.h:71
HepLib::FormFormat
class for FormFormat Output
Definition: HEP.h:44
HepLib::IBP
IBP base class for IBP reduction.
Definition: IBP.h:24
HepLib::Index::visitor::visit
virtual void visit(const Index &)=0
HepLib::Index
class for index object
Definition: HEP.h:104
HepLib::Index::name
Symbol name
Definition: HEP.h:133
HepLib::Index::type
Type type
Definition: HEP.h:134
HepLib::Index::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::Index::inherited
basic inherited
Definition: HEP.h:117
HepLib::Index::Dimension
static GiNaC::exmap Dimension
Definition: HEP.h:109
HepLib::Index::all
static lst all(const ex &e)
HepLib::Index::has
static bool has(const ex &e)
HepLib::Pair::visitor::visit
virtual void visit(const Pair &)=0
HepLib::Pair
class for Pair object
Definition: HEP.h:322
HepLib::Pair::inherited
basic inherited
Definition: HEP.h:334
HepLib::Pair::all
static lst all(const ex &e)
HepLib::Pair::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::Pair::has
static bool has(const ex &e)
HepLib::SUNF4::visitor::visit
virtual void visit(const SUNF4 &)=0
HepLib::SUNF4
class for SUNF4 object
Definition: HEP.h:278
HepLib::SUNF4::all
static lst all(const ex &e)
HepLib::SUNF4::inherited
basic inherited
Definition: HEP.h:290
HepLib::SUNF4::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::SUNF4::has
static bool has(const ex &e)
HepLib::SUNF::visitor::visit
virtual void visit(const SUNF &)=0
HepLib::SUNF
class for SUNF object
Definition: HEP.h:233
HepLib::SUNF::has
static bool has(const ex &e)
HepLib::SUNF::all
static lst all(const ex &e)
HepLib::SUNF::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::SUNF::inherited
basic inherited
Definition: HEP.h:245
HepLib::SUNT::visitor::visit
virtual void visit(const SUNT &)=0
HepLib::SUNT
class for SUNT object
Definition: HEP.h:189
HepLib::SUNT::has
static bool has(const ex &e)
HepLib::SUNT::all
static lst all(const ex &e)
HepLib::SUNT::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::SUNT::inherited
basic inherited
Definition: HEP.h:201
HepLib::Symbol
class extended to GiNaC symbol class, represent a positive symbol
Definition: BASIC.h:113
HepLib::Vector::visitor::visit
virtual void visit(const Vector &)=0
HepLib::Vector
class for vector object
Definition: HEP.h:149
HepLib::Vector::all
static lst all(const ex &e)
HepLib::Vector::inherited
basic inherited
Definition: HEP.h:161
HepLib::Vector::has
static bool has(const ex &e)
HepLib::Vector::dynallocate
friend B & dynallocate(Args &&... args)
HepLib::Vector::name
Symbol name
Definition: HEP.h:176
HepLib
HepLib namespace.
Definition: BASIC.cpp:17
HepLib::SP2sp
ex SP2sp(const ex &exin)
convert SP(a,b) to sp(a,b)
Definition: Pair.cpp:302
HepLib::form_using_dim4
bool form_using_dim4
Definition: Init.cpp:209
HepLib::form_expand_tr
const int form_expand_tr
Definition: Init.cpp:202
HepLib::DoColor
ex DoColor(const ex &expr, const ex &pref, int method)
Definition: Basic.cpp:845
HepLib::sp
ex sp(const ex &a, const ex &b)
translated the vector dot a.b to a*b, useful in SecDec
Definition: Pair.cpp:237
HepLib::sp_map
exmap sp_map()
the SP_map with SP(a,b) replaced to sp(a,b)
Definition: Pair.cpp:318
HepLib::let_op
void let_op(ex &ex_in, int index1, int index2, const ex item)
update index1-th.index2-th of expression with item
Definition: BASIC.cpp:1560
HepLib::HomCACF
ex HomCACF(const ex &e)
Definition: Basic.cpp:803
HepLib::gs
const Symbol gs
HepLib::MatrixContract
ex MatrixContract(const ex &expr_in)
make contract on matrix, i.e., Matrix(a,i1,i2)*Matrix(b,i2,i3) -> Matrix(a*b,i1,i3)
Definition: Basic.cpp:599
HepLib::form_expand_none
const int form_expand_none
Definition: Init.cpp:201
HepLib::SP_map
exmap SP_map
Definition: Init.cpp:179
HepLib::ApartIR2F
ex ApartIR2F(const ex &expr_in)
convert ApartIR to F(ps, ns), ns is like FIRE convention
Definition: Apart.cpp:61
HepLib::ApartIRC
ex ApartIRC(const ex &expr_in)
complete the ApartIR elements
Definition: Apart.cpp:914
HepLib::ep
const Symbol ep
HepLib::ApartIBP
void ApartIBP(exvector &air_vec, AIOption aio)
perform IBP reduction on the Aparted input
Definition: ApartIBP.cpp:109
HepLib::form_expand_mode
int form_expand_mode
Definition: Init.cpp:206
HepLib::Apart_using_fermat
bool Apart_using_fermat
Definition: Init.cpp:207
HepLib::form_trace_all
const int form_trace_all
Definition: Init.cpp:196
HepLib::GAS
ex GAS(const ex &expr, unsigned rl)
function similar to GAD/GSD in FeynClac
Definition: DGamma.cpp:246
HepLib::form_expand_ci
const int form_expand_ci
Definition: Init.cpp:203
HepLib::LoopUF
lst LoopUF(const IBP &ibp, const ex &idx)
UF function.
Definition: IBP.cpp:310
HepLib::ApartIR2ex
ex ApartIR2ex(const ex &expr_in)
convert ApartIR to ex
Definition: Apart.cpp:35
HepLib::UF
lst UF(const ex &props, const ex &ns, const ex &loops, const ex &tloops, const ex &lsubs, const ex &tsubs)
UF function, from FIRE.m.
Definition: IBP.cpp:420
HepLib::form_trace_mode
int form_trace_mode
Definition: Init.cpp:199
HepLib::form_using_su3
bool form_using_su3
Definition: Init.cpp:208
HepLib::F2ex
ex F2ex(const ex &expr_in)
convert F(ps, ns) to normal ex, ns is like FIRE convention
Definition: ApartIBP.cpp:87
HepLib::form_trace_each_all
const int form_trace_each_all
Definition: Init.cpp:197
HepLib::vs
const Symbol vs
HepLib::d
const Symbol d
HepLib::form_expand_all
const int form_expand_all
Definition: Init.cpp:205
HepLib::ToCACF
ex ToCACF(const ex &e)
Definition: Basic.cpp:776
HepLib::mu
const Symbol mu
HepLib::CA
const Symbol CA
HepLib::letSP
ex & letSP(const ex &p1, const ex &p2)
return the reference of p1.p2
Definition: Pair.cpp:252
HepLib::CF
const Symbol CF
HepLib::fcout
FCFormat fcout
HepLib::A0
ex A0(const ex m2, int n, ex d)
scalar integral A0, devided by (2pi)^(4-2ep)
Definition: ABCD.cpp:17
HepLib::charge_conjugate
ex charge_conjugate(const ex &expr)
make the charge conjugate operaton, M -> C^{-1} . M^T . C w.r.t. a Matrix object
Definition: Form.cpp:637
HepLib::form_using_gamma5
bool form_using_gamma5
Definition: Init.cpp:210
HepLib::ApartRules
exmap ApartRules(const exvector &airs, bool irc)
Definition: Apart.cpp:156
HepLib::form_trace_each_each
const int form_trace_each_each
Definition: Init.cpp:198
HepLib::ToCF
ex ToCF(const ex &e)
Definition: Basic.cpp:741
HepLib::form_trace_auto
const int form_trace_auto
Definition: Init.cpp:195
HepLib::IsZero
bool IsZero(const ex &e)
HepLib::Apart
ex Apart(const matrix &mat)
Apart on matrix.
Definition: Apart.cpp:280
HepLib::nL
const Symbol nL
HepLib::nH
const Symbol nH
HepLib::w1
ex w1
Definition: BASIC.h:499
HepLib::clearSP
void clearSP(const ex &p1, const ex &p2)
delete the assignment of p1.p2
Definition: Pair.cpp:274
HepLib::UnContract
ex UnContract(const ex expr, const lst &loop_ps, const lst &ext_ps=lst{})
Definition: TIR.cpp:43
HepLib::form_expand_li
const int form_expand_li
Definition: Init.cpp:204
HepLib::LC
ex LC(ex pi1, ex pi2, ex pi3, ex pi4)
function similar to LCD in FeynCalc
Definition: Eps.cpp:179
HepLib::w2
ex w2
Definition: BASIC.h:499
HepLib::form
ex form(const ex &iexpr, int verb)
evalulate expr in form program, see also the form_trace_mode and form_expand_mode
Definition: Form.cpp:563
HepLib::TIR
ex TIR(const ex &expr_in, const lst &loop_ps, const lst &ext_ps)
Tensor Index Reduction, note that we only handle numerator.
Definition: TIR.cpp:112
HepLib::SP
ex SP(const ex &a, bool use_map=false)
Definition: Pair.cpp:166
HepLib::AIOption::smap
exmap smap
Definition: HEP.h:527
HepLib::AIOption::Internal
lst Internal
Definition: HEP.h:524
HepLib::AIOption::External
lst External
Definition: HEP.h:525
HepLib::AIOption::init_smap
void init_smap()
Definition: HEP.h:539
Generated by doxygen 1.9.1