"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "ginsh/ginsh_parser.ypp" between
ginac-1.7.11.tar.bz2 and ginac-1.8.0.tar.bz2

About: GiNaC (GiNaC is Not a CAS (Computer Algebra System)) is a C++ library for symbolic calculations.

ginsh_parser.ypp  (ginac-1.7.11.tar.bz2):ginsh_parser.ypp  (ginac-1.8.0.tar.bz2)
skipping to change at line 573 skipping to change at line 573
if (i != assigned_symbol_table.end()) if (i != assigned_symbol_table.end())
assigned_symbol_table.erase(i); assigned_symbol_table.erase(i);
return e[0]; return e[0];
} }
static ex f_unit(const exprseq &e) static ex f_unit(const exprseq &e)
{ {
return e[0].unit(e[1]); 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) static ex f_dummy(const exprseq &e)
{ {
throw(std::logic_error("dummy function called (shouldn't happen)")); throw(std::logic_error("dummy function called (shouldn't happen)"));
} }
// Tables for initializing the "fcns" map and the function help topics // Tables for initializing the "fcns" map and the function help topics
struct fcn_init { struct fcn_init {
const char *name; const char *name;
fcnp p; fcnp p;
int num_params; int num_params;
skipping to change at line 649 skipping to change at line 748
{"sqrfree", f_sqrfree2, 2}, {"sqrfree", f_sqrfree2, 2},
{"sqrt", f_sqrt, 1}, {"sqrt", f_sqrt, 1},
{"subs", f_subs2, 2}, {"subs", f_subs2, 2},
{"subs", f_subs3, 3}, {"subs", f_subs3, 3},
{"tcoeff", f_tcoeff, 2}, {"tcoeff", f_tcoeff, 2},
{"time", f_dummy, 0}, // for Tab-completion {"time", f_dummy, 0}, // for Tab-completion
{"trace", f_trace, 1}, {"trace", f_trace, 1},
{"transpose", f_transpose, 1}, {"transpose", f_transpose, 1},
{"unassign", f_unassign, 1}, {"unassign", f_unassign, 1},
{"unit", f_unit, 2}, {"unit", f_unit, 2},
{"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 {nullptr, f_dummy, 0} // End marker
}; };
struct fcn_help_init { struct fcn_help_init {
const char *name; const char *name;
const char *help; const char *help;
}; };
static const fcn_help_init builtin_help[] = { static const fcn_help_init builtin_help[] = {
{"acos", "inverse cosine function"}, {"acos", "inverse cosine function"},
skipping to change at line 680 skipping to change at line 797
{"factorial", "factorial function"}, {"factorial", "factorial function"},
{"lgamma", "natural logarithm of Gamma function"}, {"lgamma", "natural logarithm of Gamma function"},
{"tgamma", "Gamma function"}, {"tgamma", "Gamma function"},
{"log", "natural logarithm"}, {"log", "natural logarithm"},
{"psi", "psi function\npsi(x) is the digamma function, psi(n,x) the nth p olygamma function"}, {"psi", "psi function\npsi(x) is the digamma function, psi(n,x) the nth p olygamma function"},
{"sin", "sine function"}, {"sin", "sine function"},
{"sinh", "hyperbolic sine function"}, {"sinh", "hyperbolic sine function"},
{"tan", "tangent function"}, {"tan", "tangent function"},
{"tanh", "hyperbolic 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"}, {"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"}, {"Li2", "dilogarithm"},
{"Li3", "trilogarithm"}, {"Li3", "trilogarithm"},
{"Li", "(multiple) polylogarithm"}, {"Li", "(multiple) polylogarithm"},
{"S", "Nielsen's generalized polylogarithm"}, {"S", "Nielsen's generalized polylogarithm"},
{"H", "harmonic 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)"}, {"Order", "order term function (for truncated power series)"},
{"Derivative", "inert differential operator"}, {"Derivative", "inert differential operator"},
{nullptr, nullptr} // End marker {nullptr, nullptr} // End marker
}; };
#include "ginsh_extensions.h" #include "ginsh_extensions.h"
/* /*
* Add functions to ginsh * Add functions to ginsh
*/ */
 End of changes. 4 change blocks. 
0 lines changed or deleted 124 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)