BASIC.h File Reference

Basic header file. More...

#include <ginac/ginac.h>
#include <ginac/parser.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <chrono>
#include <fstream>
#include <tuple>
#include <list>
#include <omp.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include "Symbols.h"

Include dependency graph for BASIC.h:

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

Go to the source code of this file.

Classes
class	HepLib::Symbol
	class extended to GiNaC symbol class, represent a positive symbol More...
class	HepLib::Symbol::visitor
class	HepLib::iSymbol
	class extended to GiNaC symbol class, pure imaginary symbol More...
class	HepLib::iSymbol::visitor
class	HepLib::Error
	class used to wrap error message More...
class	HepLib::lstHelper
	class as lst Helper More...
class	HepLib::MapFunction
	class to wrap map_function of GiNaC More...
class	HepLib::Parser
	class to parse for string or file, helpful with Symbol class More...
class	HepLib::XIntegral
	XIntegral Class, preface to SecDec. More...
class	HepLib::XIntegral::visitor
class	HepLib::Fermat
	interface to communicate with Fermat program More...
class	HepLib::Form
	interface to communicate with Form program More...
class	HepLib::MMAFormat
	class for Mathematica Format Output More...
class	HepLib::Server

Namespaces
namespace	HepLib
	HepLib namespace.

Macros
#define	DEFAULT_CTOR(classname)   classname::classname() { setflag(status_flags::evaluated | status_flags::expanded); }
#define	IMPLEMENT_HAS(classname)
#define	IMPLEMENT_ALL(classname)
#define	RESET   "\033[0m"
#define	BLACK   "\033[30m"
#define	RED   "\033[31m"
#define	GREEN   "\033[32m"
#define	YELLOW   "\033[33m"
#define	BLUE   "\033[34m"
#define	MAGENTA   "\033[35m"
#define	CYAN   "\033[36m"
#define	WHITE   "\033[37m"
#define	BOLDBLACK   "\033[1m\033[30m"
#define	BOLDRED   "\033[1m\033[31m"
#define	BOLDGREEN   "\033[1m\033[32m"
#define	BOLDYELLOW   "\033[1m\033[33m"
#define	BOLDBLUE   "\033[1m\033[34m"
#define	BOLDMAGENTA   "\033[1m\033[35m"
#define	BOLDCYAN   "\033[1m\033[36m"
#define	BOLDWHITE   "\033[1m\033[37m"

Typedefs
typedef std::initializer_list< ex >	HepLib::init_list
typedef void(*	RUN) (std::string dir_id)

Functions
ex	HepLib::subs (const ex &e, init_list sl)
bool	HepLib::has_any (ex expr, lst ps)
bool	HepLib::has_all (ex expr, lst ps)
bool	HepLib::is_equal_any (ex expr, lst ps)
bool	HepLib::match_any (ex expr, lst ps)
bool	HepLib::match_all (ex expr, lst ps)
vector< std::string >	HepLib::split (const string &s, char delimiter)
string	HepLib::now (bool use_date)
	date/time string
lst	HepLib::gather_symbols (const ex &e)
	get all symbols from input expression
lst	HepLib::gather_symbols (const exvector &ve)
	get all symbols from input expression
bool	HepLib::file_remove (string fn)
bool	HepLib::file_exists (string fn)
bool	HepLib::key_exists (const exmap &map, const ex &key)
bool	HepLib::dir_exists (string dir)
exvector	HepLib::GiNaC_Parallel (int ntotal, std::function< ex(int)> f, const string &key)
	GiNaC Parallel Evaluation using fork.
string	HepLib::RunOS (const string &cmd)
	run symtem command and return the output as string
void	HepLib::garRead (const string &garfn, map< string, ex > &resMap)
	garRead from file, and output in a map
ex	HepLib::garRead (const string &garfn, const char *key)
	garRead from file, only the element w.r.t. key
ex	HepLib::garRead (const string &garfn)
	garRead from file, only the element w.r.t. key "res", note inner check will be performed
void	HepLib::garWrite (const string &garfn, const map< string, ex > &resMap)
	garWrite to write the string-key map to the archive
void	HepLib::garWrite (const map< string, ex > &resMap, const string &garfn)
void	HepLib::garWrite (const string &garfn, const ex &res)
	garWrite to write the expression to the archive, with key: "res", including a check key will be written
void	HepLib::garWrite (const ex &res, const string &garfn)
ex	HepLib::str2ex (const string &expr, symtab stab)
	convert string to ex expression, using Parser internally
ex	HepLib::str2ex (const string &expr)
	convert string to ex expression, using Parser internally
lst	HepLib::str2lst (const string &expr, symtab stab)
	convert string to the lst, using Parser internally
lst	HepLib::str2lst (const string &expr)
	convert string to the lst, using Parser internally
matrix	HepLib::lst2mat (const lst &ls)
	convert 2Dim lst to matrix
string	HepLib::file2str (string filename)
	read file content to string
void	HepLib::str2file (const string &ostr, string filename)
	export string to a file
void	HepLib::str2file (char *buff, FILE *fh)
vector< string >	HepLib::file2strvec (string filename, bool skip_empty)
	read file content to string vector
ex	HepLib::file2ex (string filename)
	read file content to ex
ex	HepLib::file2ex (string filename, symtab st)
	read file content to ex
int	HepLib::ex2int (ex num)
	ex to integer
void	HepLib::ex2file (const ex &expr, string filename)
	export expression file
void	HepLib::ex2file (string filename, const ex &expr)
	export expression file
string	HepLib::ex2str (const ex &expr)
	convert ex to output string, the defalut printer format will be used
string	HepLib::ex2str (const exvector &expr)
	convert exvec to output string, the defalut printer format will be used
string	HepLib::ex2str (const exmap &expr)
	convert exmap to output string, the defalut printer format will be used
string	HepLib::ex2str (const exset &expr)
	convert exset to output string, the defalut printer format will be used
string	HepLib::in2str (int i)
ex	HepLib::q2ex (__float128 num)
	__float128 to ex
__float128	HepLib::ex2q (ex num)
	ex of numeric to __float128
lst	HepLib::vec2lst (const exvector &ev)
	convert exvector to lst
exvector	HepLib::lst2vec (const lst &alst)
	convert lst to exvector
lst	HepLib::add2lst (const ex &expr)
	convert add to lst
lst	HepLib::mul2lst (const ex &expr)
	convert mul to lst
lst	HepLib::xlst (int ei)
	return a lst: x(0), x(1), ..., x(ei)
lst	HepLib::xlst (int bi, int ei)
	return a lst: x(bi), x(bi+1), ..., x(ei)
int	HepLib::CpuCores ()
	return the cpu cores using OpenMP
void	HepLib::let_op_append (ex &ex_in, const ex item)
	append item into expression
void	HepLib::let_op_prepend (ex &ex_in, const ex item)
	preppend item into expression
void	HepLib::let_op_remove_last (ex &ex_in)
	remove last from expression
void	HepLib::let_op_remove_first (ex &ex_in)
	remove first from expression
void	HepLib::let_op_append (ex &ex_in, int index, ex const item)
	append item into index-th of expression
void	HepLib::let_op_prepend (ex &ex_in, int index, ex const item)
	prepend item into index-th of expression
void	HepLib::let_op_remove_last (ex &ex_in, int index)
	remove the last in index-th of expression
void	HepLib::let_op_remove_first (ex &ex_in, int index)
	remove the first in index-th of expression
void	HepLib::let_op_append (lst &ex_in, int index, ex const item)
	append item into index-th of expression
void	HepLib::let_op_prepend (lst &ex_in, int index, ex const item)
	prepend item into index-th of expression
void	HepLib::let_op_remove_last (lst &ex_in, int index)
	remove the last in index-th of expression
void	HepLib::let_op_remove_first (lst &ex_in, int index)
	remove the first in index-th of expression
void	HepLib::let_op_append (ex &ex_in, int index1, int index2, ex const item)
	append item into index1-th.index2-th of expression
void	HepLib::let_op_prepend (ex &ex_in, int index1, int index2, ex const item)
	prepend item into index1-th.index2-th of expression
void	HepLib::let_op_remove_last (ex &ex_in, int index1, int index2)
	remove the last in index1-th.index2-th of expression
void	HepLib::let_op_remove_first (ex &ex_in, int index1, int index2)
	remove the first in index1-th.index2-th of expression
void	HepLib::let_op_append (lst &ex_in, int index1, int index2, ex const item)
	append item into index1-th.index2-th of expression
void	HepLib::let_op_prepend (lst &ex_in, int index1, int index2, ex const item)
	prepend item into index1-th.index2-th of expression
void	HepLib::let_op_remove_last (lst &ex_in, int index1, int index2)
	remove the last in index1-th.index2-th of expression
void	HepLib::let_op_remove_first (lst &ex_in, int index1, int index2)
	remove the first in index1-th.index2-th of expression
void	HepLib::let_op (ex &ex_in, int index1, int index2, const ex item)
	update index1-th.index2-th of expression with item
void	HepLib::let_op (lst &ex_in, int index1, int index2, const ex item)
	update index1-th.index2-th of expression with item
void	HepLib::let_op (ex &ex_in, int index1, int index2, int index3, const ex item)
	update index1-th.index2-th.index3-th of expression with item
void	HepLib::let_op (lst &ex_in, int index1, int index2, int index3, const ex item)
	update index1-th.index2-th.index3-th of expression with item
ex	HepLib::get_op (const ex ex_in, int index1, int index2)
	return index1-th.index2-th of expression
ex	HepLib::get_op (const lst ex_in, int index1, int index2)
	return index1-th.index2-th of expression
ex	HepLib::get_op (const ex ex_in, int index1, int index2, int index3)
	return index1-th.index2-th.index3-th of expression
ex	HepLib::get_op (const lst ex_in, int index1, int index2, int index3)
	return index1-th.index2-th.index3-th of expression
ex	HepLib::series_ex (ex const &expr_in, symbol const &s0, int sn0)
	the series like Mathematica, include s^n
ex	HepLib::series_ex (ex const &expr_in, ex const &s0, int sn0)
	the series like Mathematica, include s^n
ex	HepLib::expand_ex (ex const &expr_in, std::function< bool(const ex &)> has_func)
	the expand like Mathematica
ex	HepLib::expand_ex (const ex &expr)
ex	HepLib::expand_ex (ex const &expr, lst const &pats)
ex	HepLib::expand_ex (ex const &expr, ex const &pat)
ex	HepLib::collect_ex (ex const &expr_in, std::function< bool(const ex &)> has_func, int opt)
	the collect function like Mathematica
ex	HepLib::collect_ex (const ex &expr, init_list const &pats, int opt=o_none)
ex	HepLib::collect_ex (const ex &expr, lst const &pats, int opt=o_none)
ex	HepLib::collect_ex (const ex &expr, ex const &pat, int opt=o_none)
lst	HepLib::collect_lst (ex const &expr_in, std::function< bool(const ex &)> has_func, int opt)
	the collect function like Mathematica, reture the lst { {c1,v1}, {c2,v2}, ... }
lst	HepLib::collect_lst (const ex &expr, init_list const &pats, int opt=o_none)
lst	HepLib::collect_lst (const ex &expr, lst const &pats, int opt=o_none)
lst	HepLib::collect_lst (const ex &expr, ex const &pat, int opt=o_none)
ex	HepLib::diff_ex (ex const expr, ex const xp, unsigned nth, bool expand)
	the differential like Mathematica
ex	HepLib::fermat_eval (const ex &expr)
	return the numerator and denominator after normalization
ex	HepLib::numer_denom_fermat (const ex &expr, bool dfactor)
	return the numerator and denominator after normalization
ex	HepLib::numer_fermat (const ex &expr)
ex	HepLib::fermat_numer_denom (const ex &expr, bool dfactor=false)
ex	HepLib::normal_fermat (const ex &expr, bool dfactor)
	return the normalizatied expression, using fermat_numer_denom
ex	HepLib::fermat_normal (const ex &expr, bool dfactor=false)
ex	HepLib::normal_flint (const ex &expr, int opt=o_flint)
ex	HepLib::factor_flint (const ex &e, bool nd=true)
ex	HepLib::form_eval (const ex &expr)
ex	HepLib::factor_form (const ex &expr, bool nd)
	factorize a expression using FORM
ex	HepLib::form_factor (const ex &expr, bool nd=true)
ex	HepLib::exfactor (const ex &expr_in, int opt)
	factorize a expression
ex	HepLib::exnormal (const ex &expr, int opt)
	normalize a expression
ex	HepLib::exnd (const ex &expr, int opt)
	num_den a expression
ex	HepLib::collect_factors (const ex &expr)
	a wrapper for collect_common_factors, catch errors
ex	HepLib::EvalF (ex expr)
	the nuerical evaluation, Digits=100 will be used
ex	HepLib::EvalL (ex expr)
ex	HepLib::EvalQ (ex expr)
ex	HepLib::EvalMP (ex expr)
ex	HepLib::NN (ex expr, int digits)
	the nuerical evaluation
bool	HepLib::xPositive (ex const expr)
	check the expr is xPositive, i.e., each x-monomial item is postive
int	HepLib::xSign (ex const expr)
	the always sign for expr
std::function< GiNaC::function(const ex &)>	HepLib::GiNaC_Function_1 (const string name)
std::function< GiNaC::function(const ex &, const ex &)>	HepLib::GiNaC_Function_2 (const string name)
std::function< GiNaC::function(const ex &, const ex &, const ex &)>	HepLib::GiNaC_Function_3 (const string name)
std::function< GiNaC::function(const ex &, const ex &, const ex &, const ex &)>	HepLib::GiNaC_Function_4 (const string name)
bool	HepLib::isFunction (const ex &e, string func_name)
bool	HepLib::isFunction (const ex &e, string func_name, int nargs)
bool	HepLib::has_function (const ex &expr)
void	HepLib::PreTree (const ex &e, std::function< void(const ex &)> f)
void	HepLib::PostTree (const ex &e, std::function< void(const ex &)> f)
void	HepLib::string_replace_all (string &str, const string &from, const string &to)
void	HepLib::string_trim (string &str)
bool	HepLib::string_start_with (const string &fstr, const string &sstr)
bool	HepLib::string_end_with (const string &fstr, const string &estr)
bool	HepLib::string_contain (const string &fstr, const string &mstr)
void	HepLib::Combinations (int n, int m, std::function< void(const int *)> f)
void	HepLib::CombinationsR (int n, int m, std::function< void(const int *)> f)
void	HepLib::Permutations (int n, std::function< void(const int *)> f)
void	HepLib::Permutations (int n, int m, std::function< void(const int *)> f)
void	HepLib::PermutationsR (int n, int m, std::function< void(const int *)> f)
bool	HepLib::isSorted (const lst &exs)
bool	HepLib::isSorted (int n, const ex exs[])
int	HepLib::ACSort (lst &exs)
int	HepLib::ACSort (int n, ex exs[])
void	HepLib::set_precision (long prec, bool push)
void	HepLib::reset_precision ()
long	HepLib::get_precision ()
ex	HepLib::Rationalize (const ex &e, int dn)
long long	HepLib::node_number (const ex &expr, int level=0)
bool	HepLib::ex_less (const ex &a, const ex &b)
void	HepLib::sort_lst (lst &ilst, bool less)
	sort the list in less order, or the reverse
void	HepLib::sort_lst_by (lst &ilst, int ki, bool less)
	sort the list in less order, or the reverse
void	HepLib::sort_vec (exvector &ivec, bool less)
	sort the list in less order, or the reverse
void	HepLib::sort_vec_by (exvector &ivec, int ki, bool less)
	sort the list in less order, or the reverse
void	HepLib::append_to (const exvector &exv, lst &alst)
void	HepLib::append_to (const lst &alst, exvector &exv)
lst	HepLib::CoPat (const ex &e, std::function< bool(const ex &)> f)
void	HepLib::garWrite (const exvector &exv, string garfn)
void	HepLib::garWrite (string garfn, const exvector &exv)
void	HepLib::garRead (exvector &exv, string garfn)
void	HepLib::garRead (string garfn, exvector &exv)
ex	HepLib::add_collect_normal (const exvector &exv, ex const &pats, int opt)
ex	HepLib::add_collect_normal (const exvector &exv, lst const &pats, int opt)
ex	HepLib::add_collect_normal (const exvector &exv, init_list const &pats, int opt)
ex	HepLib::add_collect_normal (const ex &e, ex const &pats, int opt)
ex	HepLib::add_collect_normal (const ex &e, lst const &pats, int opt)
ex	HepLib::add_collect_normal (const ex &e, init_list const &pats, int opt)
bool	HepLib::has_w (const ex &e)
void	HepLib::subs_w (exmap &repl)
void	HepLib::subs_w (lst &repl)
void	HepLib::ReShare (const ex &e)
void	HepLib::ReShare (const lst &es)
void	HepLib::ReShare (const ex &e1, const ex &e2)
void	HepLib::ReShare (const ex &e1, const ex &e2, const ex &e3)
void	HepLib::ReShare (const exvector &ev)
void	HepLib::ReShare (const exvector &ev1, const exvector &ev2)
ex	HepLib::nextprime (const ex &n)
ex	HepLib::nextprime (int n)
numeric	HepLib::RationalReconstruct (numeric a, numeric p)
numeric	HepLib::mulInv (numeric a, numeric b)
numeric	HepLib::ChineseRemainder (std::vector< numeric > a, std::vector< numeric > n)
numeric	HepLib::RationalReconstruct (vector< numeric > aa, vector< numeric > pp)
ex	HepLib::Thiele (const exvector &keys, const exvector &values, const ex &d)
ex	HepLib::Newton (const exvector &keys, const exvector &values, const ex &d, const ex factor=1)
matrix	HepLib::fermat_Redrowech (const matrix &mat)
matrix	HepLib::fermat_Redrowech_Sparse (const matrix &mat)
ex	HepLib::fermat_Det (const matrix &mat)
ex	HepLib::fermat_Det_Sparse (const matrix &mat)
matrix	HepLib::fermat_inv (const matrix &mat)
matrix	HepLib::fermat_mul (const matrix &m1, const matrix &m2)
matrix	HepLib::fermat_pow (const matrix &mat_in, int n)
void	HepLib::fermat_mat (const matrix &mat_in, const string &name)
matrix	HepLib::fermat_mat (const string &name)
void	HepLib::fermat_eval (const string &fcmd="@[**]")
bool	HepLib::has_symbol (const ex &e)
void	HepLib::arg2map (int argc, char **argv, const char *optstring, std::map< char, std::string > &kv)

Variables
string	HepLib::Version = "1.5 @2024-04-28"
unsigned	HepLib::nopat = GiNaC::subs_options::no_pattern
const int	HepLib::o_none = (_o_++)
const int	HepLib::o_normal = (_o_++)
const int	HepLib::o_fermat = (_o_++)
const int	HepLib::o_fermatfD = (_o_++)
const int	HepLib::o_fermatN = (_o_++)
const int	HepLib::o_form = (_o_++)
const int	HepLib::o_flint = (_o_++)
const int	HepLib::o_flintf = (_o_++)
const int	HepLib::o_flintfD = (_o_++)
const int	HepLib::o_normal_fermat = (_o_++)
const int	HepLib::o_normal_form = (_o_++)
const int	HepLib::o_fermat_form = (_o_++)
bool	HepLib::In_GiNaC_Parallel = false
int	HepLib::GiNaC_Parallel_Process = -1
map< string, int >	HepLib::GiNaC_Parallel_Verb
map< string, int >	HepLib::GiNaC_Parallel_NP
int	HepLib::GiNaC_Parallel_Batch = 0
map< string, int >	HepLib::GiNaC_Parallel_NB
map< string, bool >	HepLib::GiNaC_Parallel_RM
map< string, bool >	HepLib::GiNaC_Parallel_ReWR
map< string, string >	HepLib::GiNaC_Parallel_PRE
bool	HepLib::using_cache = true
long long	HepLib::cache_limit = -1
int	HepLib::fermat_using_array = 0
map< ex, long long, ex_is_less >	HepLib::fermat_weight
int	HepLib::NNDigits = 100
ex	HepLib::w = wild()
ex	HepLib::w0 = wild(0)
ex	HepLib::w1 = wild(1)
ex	HepLib::w2 = wild(2)
ex	HepLib::w3 = wild(3)
ex	HepLib::w4 = wild(4)
ex	HepLib::w5 = wild(5)
ex	HepLib::w6 = wild(6)
ex	HepLib::w7 = wild(7)
ex	HepLib::w8 = wild(8)
ex	HepLib::w9 = wild(9)
string	HepLib::InstallPrefix = install_prefix()
string	HepLib::INC_FLAGS = "-I'"+InstallPrefix+"/include' " + "@INC_FLAGS@"
string	HepLib::LIB_FLAGS = "-L'"+InstallPrefix+"/lib' -Wl,-rpath,'"+InstallPrefix+"'/lib " + "@LIB_FLAGS@"
const iSymbol	HepLib::iEpsilon
const ex	HepLib::iEpsilonN = I*pow(ex(10), -50)
int	HepLib::Verbose = 0
string	HepLib::PRE = " "
bool	HepLib::Debug = false
MMAFormat	HepLib::mout

Detailed Description

Basic header file.

Definition in file BASIC.h.

Macro Definition Documentation

BLACK

#define BLACK   "\033[30m"

Definition at line 80 of file BASIC.h.

BLUE

#define BLUE   "\033[34m"

Definition at line 84 of file BASIC.h.

BOLDBLACK

#define BOLDBLACK   "\033[1m\033[30m"

Definition at line 88 of file BASIC.h.

BOLDBLUE

#define BOLDBLUE   "\033[1m\033[34m"

Definition at line 92 of file BASIC.h.

BOLDCYAN

#define BOLDCYAN   "\033[1m\033[36m"

Definition at line 94 of file BASIC.h.

BOLDGREEN

#define BOLDGREEN   "\033[1m\033[32m"

Definition at line 90 of file BASIC.h.

BOLDMAGENTA

#define BOLDMAGENTA   "\033[1m\033[35m"

Definition at line 93 of file BASIC.h.

BOLDRED

#define BOLDRED   "\033[1m\033[31m"

Definition at line 89 of file BASIC.h.

BOLDWHITE

#define BOLDWHITE   "\033[1m\033[37m"

Definition at line 95 of file BASIC.h.

BOLDYELLOW

#define BOLDYELLOW   "\033[1m\033[33m"

Definition at line 91 of file BASIC.h.

CYAN

#define CYAN   "\033[36m"

Definition at line 86 of file BASIC.h.

DEFAULT_CTOR

#define DEFAULT_CTOR

(

classname

)

classname::classname() { setflag(status_flags::evaluated | status_flags::expanded); }

Definition at line 21 of file BASIC.h.

GREEN

#define GREEN   "\033[32m"

Definition at line 82 of file BASIC.h.

IMPLEMENT_ALL

#define IMPLEMENT_ALL

(

classname

)

Value:

lst classname::all(const ex &e) { \
    lst ret;\
    for(const_preorder_iterator i = e.preorder_begin(); i != e.preorder_end(); ++i) if(is_a<classname>(*i)) ret.append(*i); \
    ret.sort(); \
    ret.unique(); \
    return ret; \
}

Definition at line 30 of file BASIC.h.

IMPLEMENT_HAS

#define IMPLEMENT_HAS

(

classname

)

Value:

bool classname::has(const ex &e) { \
    for(const_preorder_iterator i = e.preorder_begin(); i != e.preorder_end(); ++i) if(is_a<classname>(*i)) return true; \
    return false; \
}

Definition at line 24 of file BASIC.h.

MAGENTA

#define MAGENTA   "\033[35m"

Definition at line 85 of file BASIC.h.

RED

#define RED   "\033[31m"

Definition at line 81 of file BASIC.h.

RESET

#define RESET   "\033[0m"

Definition at line 79 of file BASIC.h.

WHITE

#define WHITE   "\033[37m"

Definition at line 87 of file BASIC.h.

YELLOW

#define YELLOW   "\033[33m"

Definition at line 83 of file BASIC.h.

Typedef Documentation

RUN

typedef void(* RUN) (std::string dir_id)

Definition at line 923 of file BASIC.h.