* This file must be processed with yacc/bison. */
/*
- * GiNaC Copyright (C) 1999-2015 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2020 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include "ginsh.h"
+using namespace std;
+using namespace GiNaC;
+
#define YYERROR_VERBOSE 1
#ifdef HAVE_LIBREADLINE
typedef ex (*fcnp2)(const exprseq &e, int serial);
struct fcn_desc {
- fcn_desc() : p(NULL), num_params(0), is_ginac(false), serial(0) {}
+ fcn_desc() : p(nullptr), num_params(0), is_ginac(false), serial(0) {}
fcn_desc(fcnp func, int num) : p(func), num_params(num), is_ginac(false), serial(0) {}
fcn_desc(fcnp2 func, int num, int ser) : p((fcnp)func), num_params(num), is_ginac(true), serial(ser) {}
exp : T_NUMBER {$$ = $1;}
| T_SYMBOL {
- exmap::const_iterator i = assigned_symbol_table.find($1);
+ auto i = assigned_symbol_table.find($1);
if (i == assigned_symbol_table.end())
$$ = $1;
else
- $$ = i->second.eval();
+ $$ = i->second;
}
| '\'' T_SYMBOL '\'' {$$ = $2;}
| T_LITERAL {$$ = $1;}
| T_QUOTE2 {$$ = exstack[1];}
| T_QUOTE3 {$$ = exstack[2];}
| T_SYMBOL '(' exprseq ')' {
- fcn_tab::const_iterator i = find_function($1, $3.nops());
+ auto i = find_function($1, $3.nops());
if (i->second.is_ginac) {
$$ = ((fcnp2)(i->second.p))(ex_to<exprseq>($3), i->second.serial);
} else {
| '[' matrix ']' {$$ = lst_to_matrix(ex_to<lst>($2));}
;
-exprseq : exp {$$ = exprseq($1);}
+exprseq : exp {$$ = exprseq{$1};}
| exprseq ',' exp {exprseq es(ex_to<exprseq>($1)); $$ = es.append($3);}
;
| list {$$ = $1;}
;
-list : exp {$$ = lst($1);}
+list : exp {$$ = lst{$1};}
| list ',' exp {lst l(ex_to<lst>($1)); $$ = l.append($3);}
;
-matrix : '[' row ']' {$$ = lst($2);}
+matrix : '[' row ']' {$$ = lst{$2};}
| matrix ',' '[' row ']' {lst l(ex_to<lst>($1)); $$ = l.append($4);}
;
-row : exp {$$ = lst($1);}
+row : exp {$$ = lst{$1};}
| row ',' exp {lst l(ex_to<lst>($1)); $$ = l.append($3);}
;
static ex f_convert_H_to_Li(const exprseq &e) {return convert_H_to_Li(e[0], e[1]);}
static ex f_degree(const exprseq &e) {return e[0].degree(e[1]);}
static ex f_denom(const exprseq &e) {return e[0].denom();}
-static ex f_eval1(const exprseq &e) {return e[0].eval();}
-static ex f_evalf1(const exprseq &e) {return e[0].evalf();}
+static ex f_evalf(const exprseq &e) {return e[0].evalf();}
static ex f_evalm(const exprseq &e) {return e[0].evalm();}
static ex f_eval_integ(const exprseq &e) {return e[0].eval_integ();}
static ex f_expand(const exprseq &e) {return e[0].expand();}
static ex f_ldegree(const exprseq &e) {return e[0].ldegree(e[1]);}
static ex f_lsolve(const exprseq &e) {return lsolve(e[0], e[1]);}
static ex f_nops(const exprseq &e) {return e[0].nops();}
-static ex f_normal1(const exprseq &e) {return e[0].normal();}
+static ex f_normal(const exprseq &e) {return e[0].normal();}
static ex f_numer(const exprseq &e) {return e[0].numer();}
static ex f_numer_denom(const exprseq &e) {return e[0].numer_denom();}
static ex f_pow(const exprseq &e) {return pow(e[0], e[1]);}
return fail();
}
-static ex f_eval2(const exprseq &e)
-{
- CHECK_ARG(1, numeric, eval);
- return e[0].eval(ex_to<numeric>(e[1]).to_int());
-}
-
-static ex f_evalf2(const exprseq &e)
-{
- CHECK_ARG(1, numeric, evalf);
- return e[0].evalf(ex_to<numeric>(e[1]).to_int());
-}
-
static ex f_find(const exprseq &e)
{
exset found;
static ex f_integral(const exprseq &e)
{
CHECK_ARG(0, symbol, integral);
- return integral(e[0], e[1], e[2], e[3]);
+ return GiNaC::integral(e[0], e[1], e[2], e[3]);
}
static ex f_inverse(const exprseq &e)
throw std::runtime_error("FAIL");
}
-static ex f_normal2(const exprseq &e)
-{
- CHECK_ARG(1, numeric, normal);
- return e[0].normal(ex_to<numeric>(e[1]).to_int());
-}
-
static ex f_op(const exprseq &e)
{
CHECK_ARG(1, numeric, op);
return e[0].unit(e[1]);
}
+static ex f_basic_log_kernel(const exprseq &e)
+{
+ return basic_log_kernel();
+}
+
+static ex f_multiple_polylog_kernel(const exprseq &e)
+{
+ return multiple_polylog_kernel(e[0]);
+}
+
+static ex f_ELi_kernel(const exprseq &e)
+{
+ return ELi_kernel(e[0],e[1],e[2],e[3]);
+}
+
+static ex f_Ebar_kernel(const exprseq &e)
+{
+ return Ebar_kernel(e[0],e[1],e[2],e[3]);
+}
+
+static ex f_Kronecker_dtau_kernel_4(const exprseq &e)
+{
+ return Kronecker_dtau_kernel(e[0],e[1],e[2],e[3]);
+}
+
+static ex f_Kronecker_dtau_kernel_3(const exprseq &e)
+{
+ return Kronecker_dtau_kernel(e[0],e[1],e[2]);
+}
+
+static ex f_Kronecker_dtau_kernel_2(const exprseq &e)
+{
+ return Kronecker_dtau_kernel(e[0],e[1]);
+}
+
+static ex f_Kronecker_dz_kernel_5(const exprseq &e)
+{
+ return Kronecker_dz_kernel(e[0],e[1],e[2],e[3],e[4]);
+}
+
+static ex f_Kronecker_dz_kernel_4(const exprseq &e)
+{
+ return Kronecker_dz_kernel(e[0],e[1],e[2],e[3]);
+}
+
+static ex f_Kronecker_dz_kernel_3(const exprseq &e)
+{
+ return Kronecker_dz_kernel(e[0],e[1],e[2]);
+}
+
+static ex f_Eisenstein_kernel_6(const exprseq &e)
+{
+ return Eisenstein_kernel(e[0],e[1],e[2],e[3],e[4],e[5]);
+}
+
+static ex f_Eisenstein_kernel_5(const exprseq &e)
+{
+ return Eisenstein_kernel(e[0],e[1],e[2],e[3],e[4]);
+}
+
+static ex f_Eisenstein_h_kernel_5(const exprseq &e)
+{
+ return Eisenstein_h_kernel(e[0],e[1],e[2],e[3],e[4]);
+}
+
+static ex f_Eisenstein_h_kernel_4(const exprseq &e)
+{
+ return Eisenstein_h_kernel(e[0],e[1],e[2],e[3]);
+}
+
+static ex f_modular_form_kernel_3(const exprseq &e)
+{
+ return modular_form_kernel(e[0],e[1],e[2]);
+}
+
+static ex f_modular_form_kernel_2(const exprseq &e)
+{
+ return modular_form_kernel(e[0],e[1]);
+}
+
+static ex f_user_defined_kernel(const exprseq &e)
+{
+ return user_defined_kernel(e[0],e[1]);
+}
+
+static ex f_q_expansion_modular_form(const exprseq &e)
+{
+ if ( is_a<Eisenstein_kernel>(e[0]) ) {
+ return ex_to<Eisenstein_kernel>(e[0]).q_expansion_modular_form(e[1], ex_to<numeric>(e[2]).to_int());
+ }
+ if ( is_a<Eisenstein_h_kernel>(e[0]) ) {
+ return ex_to<Eisenstein_h_kernel>(e[0]).q_expansion_modular_form(e[1], ex_to<numeric>(e[2]).to_int());
+ }
+ if ( is_a<modular_form_kernel>(e[0]) ) {
+ return ex_to<modular_form_kernel>(e[0]).q_expansion_modular_form(e[1], ex_to<numeric>(e[2]).to_int());
+ }
+ throw(std::invalid_argument("first argument must be a modular form"));
+}
+
static ex f_dummy(const exprseq &e)
{
throw(std::logic_error("dummy function called (shouldn't happen)"));
{"diff", f_diff2, 2},
{"diff", f_diff3, 3},
{"divide", f_divide, 2},
- {"eval", f_eval1, 1},
- {"eval", f_eval2, 2},
- {"evalf", f_evalf1, 1},
- {"evalf", f_evalf2, 2},
+ {"evalf", f_evalf, 1},
{"evalm", f_evalm, 1},
{"eval_integ", f_eval_integ, 1},
{"expand", f_expand, 1},
{"map", f_map, 2},
{"match", f_match, 2},
{"nops", f_nops, 1},
- {"normal", f_normal1, 1},
- {"normal", f_normal2, 2},
+ {"normal", f_normal, 1},
{"numer", f_numer, 1},
{"numer_denom", f_numer_denom, 1},
{"op", f_op, 2},
{"transpose", f_transpose, 1},
{"unassign", f_unassign, 1},
{"unit", f_unit, 2},
- {NULL, f_dummy, 0} // End marker
+ {"basic_log_kernel", f_basic_log_kernel, 0},
+ {"multiple_polylog_kernel", f_multiple_polylog_kernel, 1},
+ {"ELi_kernel", f_ELi_kernel, 4},
+ {"Ebar_kernel", f_Ebar_kernel, 4},
+ {"Kronecker_dtau_kernel", f_Kronecker_dtau_kernel_4, 4},
+ {"Kronecker_dtau_kernel", f_Kronecker_dtau_kernel_3, 3},
+ {"Kronecker_dtau_kernel", f_Kronecker_dtau_kernel_2, 2},
+ {"Kronecker_dz_kernel", f_Kronecker_dz_kernel_5, 5},
+ {"Kronecker_dz_kernel", f_Kronecker_dz_kernel_4, 4},
+ {"Kronecker_dz_kernel", f_Kronecker_dz_kernel_3, 3},
+ {"Eisenstein_kernel", f_Eisenstein_kernel_6, 6},
+ {"Eisenstein_kernel", f_Eisenstein_kernel_5, 5},
+ {"Eisenstein_h_kernel", f_Eisenstein_h_kernel_5, 5},
+ {"Eisenstein_h_kernel", f_Eisenstein_h_kernel_4, 4},
+ {"modular_form_kernel", f_modular_form_kernel_3, 3},
+ {"modular_form_kernel", f_modular_form_kernel_2, 2},
+ {"user_defined_kernel", f_user_defined_kernel, 2},
+ {"q_expansion_modular_form", f_q_expansion_modular_form, 3},
+ {nullptr, f_dummy, 0} // End marker
};
struct fcn_help_init {
{"tan", "tangent function"},
{"tanh", "hyperbolic tangent function"},
{"zeta", "zeta function\nzeta(x) is Riemann's zeta function, zetaderiv(n,x) its nth derivative.\nIf x is a GiNaC::lst, it is a multiple zeta value\nzeta(x,s) is an alternating Euler sum"},
+ {"G", "multiple polylogarithm (integral representation)"},
{"Li2", "dilogarithm"},
{"Li3", "trilogarithm"},
{"Li", "(multiple) polylogarithm"},
{"S", "Nielsen's generalized polylogarithm"},
{"H", "harmonic polylogarithm"},
+ {"EllipticK", "complete elliptic integral of the first kind"},
+ {"EllipticE", "complete elliptic integral of the second kind"},
+ {"iterated_integral", "iterated integral"},
{"Order", "order term function (for truncated power series)"},
{"Derivative", "inert differential operator"},
- {NULL, NULL} // End marker
+ {nullptr, nullptr} // End marker
};
#include "ginsh_extensions.h"
static ex f_ginac_function(const exprseq &es, int serial)
{
- return GiNaC::function(serial, es).eval(1);
+ return GiNaC::function(serial, es);
}
// All registered GiNaC functions
if (strncmp(fcn_name, text, len) == 0)
return strdup(fcn_name);
}
- return NULL;
+ return nullptr;
}
#ifdef HAVE_LIBREADLINE
void greeting(void)
{
cout << "ginsh - GiNaC Interactive Shell (GiNaC V" << GINACLIB_VERSION << ")" << endl;
- cout << " __, _______ Copyright (C) 1999-2015 Johannes Gutenberg University Mainz,\n"
+ cout << " __, _______ Copyright (C) 1999-2020 Johannes Gutenberg University Mainz,\n"
<< " (__) * | Germany. This is free software with ABSOLUTELY NO WARRANTY.\n"
<< " ._) i N a C | You are welcome to redistribute it under certain conditions.\n"
<< "<-------------' For details type `warranty;'.\n" << endl;
file_list = argv + 1;
if (num_files) {
yyin = fopen(*file_list, "r");
- if (yyin == NULL) {
+ if (yyin == nullptr) {
cerr << "Can't open " << *file_list << endl;
exit(1);
}
git://www.ginac.de / ginac.git / blobdiff