From: Alexander Frink Date: Mon, 21 Feb 2000 23:11:41 +0000 (+0000) Subject: container.pl: can now generate constructors for an arbitary number X-Git-Tag: release_0-5-3~9 X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=commitdiff_plain;h=5184d67c0ec1056ac039419e08558632793a4e2c;hp=b2613f4b583961c3b3fe46dc6ddd2bd1f1b2684c container.pl: can now generate constructors for an arbitary number of arguments function.pl: new concept for specifying options for functions, take a look at the function_options class first experimental support for remembering functions IMPORTANT: the syntax of the macro REGISTER_FUNCTION() has changed incompatibly (see inifcns.cpp for an example) flags.h: flags for remembering strategies (lru, lfu,...) inifcns*.cpp: use the new REGISTER_FUNCTION() macro syntax numeric.h/cpp: hashing for numbers using CLN's cl_equal_hashcode() seems to give increased performance simp_lor.h: simplify_simp_lor can be called without scalar products list structure.pl: bug fix in regular expression normal.cpp: bug fix, a_numeric.compare(_ex0) --- diff --git a/ginac/container.pl b/ginac/container.pl index 0ef3b896..bab6a88c 100755 --- a/ginac/container.pl +++ b/ginac/container.pl @@ -1,7 +1,7 @@ #!/usr/bin/perl -w -if ($#ARGV!=0) { - die 'usage: container.pl type (type=lst or exprseq)'; +if (($#ARGV!=0) and ($#ARGV!=1)) { + die 'usage: container.pl type [maxargs] (type=lst or exprseq)'; } if ($ARGV[0] eq 'lst') { @@ -12,8 +12,11 @@ if ($ARGV[0] eq 'lst') { die 'only lst and exprseq supported'; } -#$type='lst'; -#$type='exprseq'; +if ($#ARGV==1) { + $maxargs=$ARGV[1]; +} else { + $maxargs=15; # must be greater or equal than the value used in function.pl +} if ($type eq 'exprseq') { @@ -86,6 +89,57 @@ END_OF_LET_OP_IMPLEMENTATION $LET_OP_IMPLEMENTATION="// ${CONTAINER}::let_op() will be implemented by user elsewhere"; } +sub generate_seq { + my ($seq_template,$n,$separator)=@_; + my ($res,$N); + + $res=''; + for ($N=1; $N<=$n; $N++) { + $res .= eval('"' . $seq_template . '"'); + if ($N!=$n) { + $res .= $separator; + } + } + return $res; +} + +sub generate_from_to { + my ($template,$seq_template1,$seq_separator1,$seq_template2, + $seq_separator2,$from,$to)=@_; + my ($res,$N,$SEQ); + + $res=''; + for ($N=$from; $N<=$to; $N++) { + $SEQ1=generate_seq($seq_template1,$N,$seq_separator1); + $SEQ2=generate_seq($seq_template2,$N,$seq_separator2); + $res .= eval('"' . $template . '"'); + $SEQ1=''; # to avoid main::SEQ1 used only once warning + $SEQ2=''; # same as above + } + return $res; +} + +sub generate { + my ($template,$seq_template1,$seq_separator1,$seq_template2, + $seq_separator2)=@_; + return generate_from_to($template,$seq_template1,$seq_separator1, + $seq_template2,$seq_separator2,1,$maxargs); +} + +$constructors_interface=generate( +' explicit ${CONTAINER}(${SEQ1});'."\n", +'const ex & param${N}',', ','',''); + +$constructors_implementation=generate( + <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}',', ',' seq.push_back(param${N});',"\n"); +${CONTAINER}::${CONTAINER}(${SEQ1}) : basic(TINFO_${CONTAINER}) +{ + debugmsg(\"${CONTAINER} constructor from ${N}*ex\",LOGLEVEL_CONSTRUCT); + RESERVE(seq,${N}); +${SEQ2} +} +END_OF_CONSTRUCTORS_IMPLEMENTATION + $interface=< & registered_functions(void); + static vector & registered_functions(void); + bool lookup_remember_table(ex & result) const; + void store_remember_table(ex const & result) const; public: - // the following lines have been generated for max. ${maxargs} parameters -$register_new_interface - // end of generated lines + static unsigned register_new(function_options const & opt); unsigned getserial(void) const {return serial;} // member variables @@ -381,6 +564,7 @@ $implementation=< #include +#include #include "function.h" #include "ex.h" @@ -393,6 +577,204 @@ $implementation=< { +public: + remember_table_list() + { + max_assoc_size=0; + delete_strategy=0; + } + remember_table_list(unsigned as, unsigned strat) + { + max_assoc_size=as; + delete_strategy=strat; + } + void add_entry(function const & f, ex const & result) + { + push_back(remember_table_entry(f,result)); + } + bool lookup_entry(function const & f, ex & result) const + { + for (const_iterator cit=begin(); cit!=end(); ++cit) { + if (cit->is_equal(f)) { + result=cit->result; + return true; + } + } + return false; + } +protected: + unsigned max_assoc_size; + unsigned delete_strategy; +}; + + +class remember_table : public vector { +public: + remember_table() + { + } + remember_table(unsigned s, unsigned as, unsigned strat) + { + calc_size(s); + reserve(table_size); + for (unsigned i=0; i=size()) { + cerr << "entry=" << entry << ",size=" << size() << endl; + } + GINAC_ASSERT(entry & remember_tables(void) +{ + static vector * rt=new vector; + return *rt; +} + GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq) ////////// @@ -491,7 +873,7 @@ function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym string s; if (n.find_string("name", s)) { unsigned int ser = 0; - vector::const_iterator i = registered_functions().begin(), iend = registered_functions().end(); + vector::const_iterator i = registered_functions().begin(), iend = registered_functions().end(); while (i != iend) { if (s == i->name) { serial = ser; @@ -605,17 +987,32 @@ ex function::eval(int level) const { GINAC_ASSERT(serial1) { + // first evaluate children, then we will end up here again + return function(serial,evalchildren(level)); + } - if (registered_functions()[serial].e==0) { - return function(serial,eseq).hold(); + if (registered_functions()[serial].eval_f==0) { + return this->hold(); + } + + bool use_remember=registered_functions()[serial].use_remember; + ex eval_result; + if (use_remember && lookup_remember_table(eval_result)) { + return eval_result; } + switch (registered_functions()[serial].nparams) { // the following lines have been generated for max. ${maxargs} parameters ${eval_switch_statement} // end of generated lines + default: + throw(std::logic_error("function::eval(): invalid nparams")); + } + if (use_remember) { + store_remember_table(eval_result); } - throw(std::logic_error("function::eval(): invalid nparams")); + return eval_result; } ex function::evalf(int level) const @@ -624,7 +1021,7 @@ ex function::evalf(int level) const exvector eseq=evalfchildren(level); - if (registered_functions()[serial].ef==0) { + if (registered_functions()[serial].evalf_f==0) { return function(serial,eseq).hold(); } switch (registered_functions()[serial].nparams) { @@ -651,7 +1048,7 @@ ex function::series(const symbol & s, const ex & point, int order) const { GINAC_ASSERT(serial & function::registered_functions(void) +vector & function::registered_functions(void) { - static vector * rf=new vector; + static vector * rf=new vector; return *rf; } +bool function::lookup_remember_table(ex & result) const +{ + return remember_tables()[serial].lookup_entry(*this,result); +} + +void function::store_remember_table(ex const & result) const +{ + remember_tables()[serial].add_entry(*this,result); +} + // public -// the following lines have been generated for max. ${maxargs} parameters -$register_new_implementation -// end of generated lines +unsigned function::register_new(function_options const & opt) +{ + unsigned same_name=0; + for (unsigned i=0; i=opt.functions_with_same_name) { + // we do not throw an exception here because this code is + // usually executed before main(), so the exception could not + // caught anyhow + cerr << "WARNING: function name " << opt.name + << " already in use!" << endl; + } + registered_functions().push_back(opt); + if (opt.use_remember) { + remember_tables().push_back(remember_table(opt.remember_size, + opt.remember_assoc_size, + opt.remember_strategy)); + } else { + remember_tables().push_back(remember_table()); + } + return registered_functions().size()-1; +} ////////// // static member variables diff --git a/ginac/inifcns.cpp b/ginac/inifcns.cpp index 70eaf758..b3527e9c 100644 --- a/ginac/inifcns.cpp +++ b/ginac/inifcns.cpp @@ -62,7 +62,8 @@ static ex abs_eval(const ex & x) return abs(x).hold(); } -REGISTER_FUNCTION(abs, abs_eval, abs_evalf, NULL, NULL); +REGISTER_FUNCTION(abs, evalf_func(abs_eval). + evalf_func(abs_evalf)); ////////// // dilogarithm @@ -79,7 +80,7 @@ static ex Li2_eval(const ex & x) return Li2(x).hold(); } -REGISTER_FUNCTION(Li2, Li2_eval, NULL, NULL, NULL); +REGISTER_FUNCTION(Li2, eval_func(Li2_eval)); ////////// // trilogarithm @@ -92,7 +93,7 @@ static ex Li3_eval(const ex & x) return Li3(x).hold(); } -REGISTER_FUNCTION(Li3, Li3_eval, NULL, NULL, NULL); +REGISTER_FUNCTION(Li3, eval_func(Li3_eval)); ////////// // factorial @@ -111,7 +112,8 @@ static ex factorial_eval(const ex & x) return factorial(x).hold(); } -REGISTER_FUNCTION(factorial, factorial_eval, factorial_evalf, NULL, NULL); +REGISTER_FUNCTION(factorial, eval_func(factorial_eval). + evalf_func(factorial_evalf)); ////////// // binomial @@ -130,7 +132,8 @@ static ex binomial_eval(const ex & x, const ex &y) return binomial(x, y).hold(); } -REGISTER_FUNCTION(binomial, binomial_eval, binomial_evalf, NULL, NULL); +REGISTER_FUNCTION(binomial, eval_func(binomial_eval). + evalf_func(binomial_evalf)); ////////// // Order term function (for truncated power series) @@ -163,7 +166,8 @@ static ex Order_series(const ex & x, const symbol & s, const ex & point, int ord return pseries(s, point, new_seq); } -REGISTER_FUNCTION(Order, Order_eval, NULL, NULL, Order_series); +REGISTER_FUNCTION(Order, eval_func(Order_eval). + series_func(Order_series)); ////////// // Solve linear system diff --git a/ginac/inifcns_gamma.cpp b/ginac/inifcns_gamma.cpp index 9e96fda8..7480bf20 100644 --- a/ginac/inifcns_gamma.cpp +++ b/ginac/inifcns_gamma.cpp @@ -126,7 +126,10 @@ static ex gamma_series(const ex & x, const symbol & s, const ex & pt, int order) } -REGISTER_FUNCTION(gamma, gamma_eval, gamma_evalf, gamma_deriv, gamma_series); +REGISTER_FUNCTION(gamma, eval_func(gamma_eval). + evalf_func(gamma_evalf). + derivative_func(gamma_deriv). + series_func(gamma_series)); ////////// @@ -229,7 +232,10 @@ static ex beta_series(const ex & x, const ex & y, const symbol & s, const ex & p } -REGISTER_FUNCTION(beta, beta_eval, beta_evalf, beta_deriv, beta_series); +REGISTER_FUNCTION(beta, eval_func(beta_eval). + evalf_func(beta_evalf). + derivative_func(beta_deriv). + series_func(beta_series)); ////////// @@ -319,7 +325,13 @@ static ex psi1_series(const ex & x, const symbol & s, const ex & pt, int order) return (psi(x+m+_ex1())-recur).series(s, pt, order); } -const unsigned function_index_psi1 = function::register_new("psi", psi1_eval, psi1_evalf, psi1_deriv, psi1_series); +const unsigned function_index_psi1 = + function::register_new(function_options("psi"). + eval_func(psi1_eval). + evalf_func(psi1_evalf). + derivative_func(psi1_deriv). + series_func(psi1_series). + overloaded(2)); ////////// // Psi-functions (aka polygamma-functions) psi(0,x)==psi(x) @@ -435,7 +447,14 @@ static ex psi2_series(const ex & n, const ex & x, const symbol & s, const ex & p return (psi(n, x+m+_ex1())-recur).series(s, pt, order); } -const unsigned function_index_psi2 = function::register_new("psi", psi2_eval, psi2_evalf, psi2_deriv, psi2_series); +const unsigned function_index_psi2 = + function::register_new(function_options("psi"). + eval_func(psi2_eval). + evalf_func(psi2_evalf). + derivative_func(psi2_deriv). + series_func(psi2_series). + overloaded(2)); + #ifndef NO_NAMESPACE_GINAC } // namespace GiNaC diff --git a/ginac/inifcns_trans.cpp b/ginac/inifcns_trans.cpp index e0d0999b..14921f46 100644 --- a/ginac/inifcns_trans.cpp +++ b/ginac/inifcns_trans.cpp @@ -88,7 +88,9 @@ static ex exp_deriv(const ex & x, unsigned deriv_param) return exp(x); } -REGISTER_FUNCTION(exp, exp_eval, exp_evalf, exp_deriv, NULL); +REGISTER_FUNCTION(exp, eval_func(exp_eval). + evalf_func(exp_evalf). + derivative_func(exp_deriv)); ////////// // natural logarithm @@ -141,7 +143,9 @@ static ex log_deriv(const ex & x, unsigned deriv_param) return power(x, _ex_1()); } -REGISTER_FUNCTION(log, log_eval, log_evalf, log_deriv, NULL); +REGISTER_FUNCTION(log, eval_func(log_eval). + evalf_func(log_evalf). + derivative_func(log_deriv)); ////////// // sine (trigonometric function) @@ -220,7 +224,9 @@ static ex sin_deriv(const ex & x, unsigned deriv_param) return cos(x); } -REGISTER_FUNCTION(sin, sin_eval, sin_evalf, sin_deriv, NULL); +REGISTER_FUNCTION(sin, eval_func(sin_eval). + evalf_func(sin_evalf). + derivative_func(sin_deriv)); ////////// // cosine (trigonometric function) @@ -299,7 +305,9 @@ static ex cos_deriv(const ex & x, unsigned deriv_param) return _ex_1()*sin(x); } -REGISTER_FUNCTION(cos, cos_eval, cos_evalf, cos_deriv, NULL); +REGISTER_FUNCTION(cos, eval_func(cos_eval). + evalf_func(cos_evalf). + derivative_func(cos_deriv)); ////////// // tangent (trigonometric function) @@ -387,7 +395,10 @@ static ex tan_series(const ex & x, const symbol & s, const ex & pt, int order) return (sin(x)/cos(x)).series(s, pt, order+2); } -REGISTER_FUNCTION(tan, tan_eval, tan_evalf, tan_deriv, tan_series); +REGISTER_FUNCTION(tan, eval_func(tan_eval). + evalf_func(tan_evalf). + derivative_func(tan_deriv). + series_func(tan_series)); ////////// // inverse sine (arc sine) @@ -436,7 +447,9 @@ static ex asin_deriv(const ex & x, unsigned deriv_param) return power(1-power(x,_ex2()),_ex_1_2()); } -REGISTER_FUNCTION(asin, asin_eval, asin_evalf, asin_deriv, NULL); +REGISTER_FUNCTION(asin, eval_func(asin_eval). + evalf_func(asin_evalf). + derivative_func(asin_deriv)); ////////// // inverse cosine (arc cosine) @@ -485,7 +498,9 @@ static ex acos_deriv(const ex & x, unsigned deriv_param) return _ex_1()*power(1-power(x,_ex2()),_ex_1_2()); } -REGISTER_FUNCTION(acos, acos_eval, acos_evalf, acos_deriv, NULL); +REGISTER_FUNCTION(acos, eval_func(acos_eval). + evalf_func(acos_evalf). + derivative_func(acos_deriv)); ////////// // inverse tangent (arc tangent) @@ -522,7 +537,9 @@ static ex atan_deriv(const ex & x, unsigned deriv_param) return power(_ex1()+power(x,_ex2()), _ex_1()); } -REGISTER_FUNCTION(atan, atan_eval, atan_evalf, atan_deriv, NULL); +REGISTER_FUNCTION(atan, eval_func(atan_eval). + evalf_func(atan_evalf). + derivative_func(atan_deriv)); ////////// // inverse tangent (atan2(y,x)) @@ -560,7 +577,9 @@ static ex atan2_deriv(const ex & y, const ex & x, unsigned deriv_param) return -y*power(power(x,_ex2())+power(y,_ex2()),_ex_1()); } -REGISTER_FUNCTION(atan2, atan2_eval, atan2_evalf, atan2_deriv, NULL); +REGISTER_FUNCTION(atan2, eval_func(atan2_eval). + evalf_func(atan2_evalf). + derivative_func(atan2_deriv)); ////////// // hyperbolic sine (trigonometric function) @@ -612,7 +631,9 @@ static ex sinh_deriv(const ex & x, unsigned deriv_param) return cosh(x); } -REGISTER_FUNCTION(sinh, sinh_eval, sinh_evalf, sinh_deriv, NULL); +REGISTER_FUNCTION(sinh, eval_func(sinh_eval). + evalf_func(sinh_evalf). + derivative_func(sinh_deriv)); ////////// // hyperbolic cosine (trigonometric function) @@ -664,7 +685,10 @@ static ex cosh_deriv(const ex & x, unsigned deriv_param) return sinh(x); } -REGISTER_FUNCTION(cosh, cosh_eval, cosh_evalf, cosh_deriv, NULL); +REGISTER_FUNCTION(cosh, eval_func(cosh_eval). + evalf_func(cosh_evalf). + derivative_func(cosh_deriv)); + ////////// // hyperbolic tangent (trigonometric function) @@ -728,7 +752,10 @@ static ex tanh_series(const ex & x, const symbol & s, const ex & pt, int order) return (sinh(x)/cosh(x)).series(s, pt, order+2); } -REGISTER_FUNCTION(tanh, tanh_eval, tanh_evalf, tanh_deriv, tanh_series); +REGISTER_FUNCTION(tanh, eval_func(tanh_eval). + evalf_func(tanh_evalf). + derivative_func(tanh_deriv). + series_func(tanh_series)); ////////// // inverse hyperbolic sine (trigonometric function) @@ -765,7 +792,9 @@ static ex asinh_deriv(const ex & x, unsigned deriv_param) return power(_ex1()+power(x,_ex2()),_ex_1_2()); } -REGISTER_FUNCTION(asinh, asinh_eval, asinh_evalf, asinh_deriv, NULL); +REGISTER_FUNCTION(asinh, eval_func(asinh_eval). + evalf_func(asinh_evalf). + derivative_func(asinh_deriv)); ////////// // inverse hyperbolic cosine (trigonometric function) @@ -808,7 +837,9 @@ static ex acosh_deriv(const ex & x, unsigned deriv_param) return power(x+_ex_1(),_ex_1_2())*power(x+_ex1(),_ex_1_2()); } -REGISTER_FUNCTION(acosh, acosh_eval, acosh_evalf, acosh_deriv, NULL); +REGISTER_FUNCTION(acosh, eval_func(acosh_eval). + evalf_func(acosh_evalf). + derivative_func(acosh_deriv)); ////////// // inverse hyperbolic tangent (trigonometric function) @@ -848,7 +879,9 @@ static ex atanh_deriv(const ex & x, unsigned deriv_param) return power(_ex1()-power(x,_ex2()),_ex_1()); } -REGISTER_FUNCTION(atanh, atanh_eval, atanh_evalf, atanh_deriv, NULL); +REGISTER_FUNCTION(atanh, eval_func(atanh_eval). + evalf_func(atanh_evalf). + derivative_func(atanh_deriv)); #ifndef NO_NAMESPACE_GINAC } // namespace GiNaC diff --git a/ginac/inifcns_zeta.cpp b/ginac/inifcns_zeta.cpp index 63637374..7a8b089a 100644 --- a/ginac/inifcns_zeta.cpp +++ b/ginac/inifcns_zeta.cpp @@ -81,7 +81,12 @@ static ex zeta1_deriv(const ex & x, unsigned deriv_param) return zeta(_ex1(), x); } -const unsigned function_index_zeta1 = function::register_new("zeta", zeta1_eval, zeta1_evalf, zeta1_deriv, NULL); +const unsigned function_index_zeta1 = + function::register_new(function_options("zeta"). + eval_func(zeta1_eval). + evalf_func(zeta1_evalf). + derivative_func(zeta1_deriv). + overloaded(2)); ////////// // Derivatives of Riemann's Zeta-function zeta(0,x)==zeta(x) @@ -110,7 +115,11 @@ static ex zeta2_deriv(const ex & n, const ex & x, unsigned deriv_param) return zeta(n+1,x); } -const unsigned function_index_zeta2 = function::register_new("zeta", zeta2_eval, NULL, zeta2_deriv, NULL); +const unsigned function_index_zeta2 = + function::register_new(function_options("zeta"). + eval_func(zeta2_eval). + derivative_func(zeta2_deriv). + overloaded(2)); #ifndef NO_NAMESPACE_GINAC } // namespace GiNaC diff --git a/ginac/matrix.cpp b/ginac/matrix.cpp index 97b47362..e15feb6d 100644 --- a/ginac/matrix.cpp +++ b/ginac/matrix.cpp @@ -726,6 +726,12 @@ matrix matrix::fraction_free_elim(const matrix & vars, matrix a(*this); // make a copy of the matrix matrix b(rhs); // make a copy of the rhs vector + + /* + cout << "before" << endl; + cout << "a=" << a << endl; + cout << "b=" << b << endl; + */ // given an m x n matrix a, reduce it to upper echelon form unsigned m=a.row; @@ -793,6 +799,12 @@ matrix matrix::fraction_free_elim(const matrix & vars, zero_in_last_row=zero_in_this_row; } #endif // def DO_GINAC_ASSERT + + /* + cout << "after" << endl; + cout << "a=" << a << endl; + cout << "b=" << b << endl; + */ // assemble solution matrix sol(n,1); @@ -833,6 +845,8 @@ matrix matrix::fraction_free_elim(const matrix & vars, cout << vars.ffe_get(c,1) << "->" << sol.ffe_get(c,1) << endl; } */ + + // cout << "sol=" << sol << endl; #ifdef DO_GINAC_ASSERT // test solution with echelon matrix diff --git a/ginac/normal.cpp b/ginac/normal.cpp index 90726181..d7557bdc 100644 --- a/ginac/normal.cpp +++ b/ginac/normal.cpp @@ -1076,7 +1076,7 @@ static ex heur_gcd(const ex &a, const ex &b, ex *ca, ex *cb, sym_desc_vec::const if (divide_in_z(p, g, ca ? *ca : dummy, var) && divide_in_z(q, g, cb ? *cb : dummy, var)) { g *= gc; ex lc = g.lcoeff(*x); - if (is_ex_exactly_of_type(lc, numeric) && lc.compare(_ex0()) < 0) + if (is_ex_exactly_of_type(lc, numeric) && ex_to_numeric(lc).is_negative()) return -g; else return g; @@ -1442,7 +1442,8 @@ static ex frac_cancel(const ex &n, const ex &d) // as defined by get_first_symbol() is made positive) const symbol *x; if (get_first_symbol(den, x)) { - if (den.unit(*x).compare(_ex0()) < 0) { + GINAC_ASSERT(is_ex_exactly_of_type(den.unit(*x),numeric)); + if (ex_to_numeric(den.unit(*x)).is_negative()) { num *= _ex_1(); den *= _ex_1(); } diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp index 21562de9..be9df1cf 100644 --- a/ginac/numeric.cpp +++ b/ginac/numeric.cpp @@ -608,6 +608,16 @@ bool numeric::is_equal_same_type(const basic & other) const return this->is_equal(*o); } +unsigned numeric::calchash(void) const +{ + return (hashvalue=cl_equal_hashcode(*value) | 0x80000000U); + /* + cout << *value << "->" << hashvalue << endl; + hashvalue=HASHVALUE_NUMERIC+1000U; + return HASHVALUE_NUMERIC+1000U; + */ +} + /* unsigned numeric::calchash(void) const { diff --git a/ginac/numeric.h b/ginac/numeric.h index 332f7552..0d2ab166 100644 --- a/ginac/numeric.h +++ b/ginac/numeric.h @@ -138,10 +138,7 @@ protected: ex derivative(const symbol & s) const; int compare_same_type(const basic & other) const; bool is_equal_same_type(const basic & other) const; - unsigned calchash(void) const { - hashvalue=HASHVALUE_NUMERIC; - return HASHVALUE_NUMERIC; - } + unsigned calchash(void) const; // new virtual functions which can be overridden by derived classes // (none) @@ -210,9 +207,12 @@ extern const numeric I; extern const type_info & typeid_numeric; extern _numeric_digits Digits; -#define is_a_numeric_hash(x) ((x)==HASHVALUE_NUMERIC) +//#define is_a_numeric_hash(x) ((x)==HASHVALUE_NUMERIC) // may have to be changed to ((x)>=0x80000000U) +// has been changed +//#define is_a_numeric_hash(x) ((x)&0x80000000U) + // global functions const numeric exp(const numeric & x); diff --git a/ginac/simp_lor.h b/ginac/simp_lor.h index 10186fdf..77e7c4d9 100644 --- a/ginac/simp_lor.h +++ b/ginac/simp_lor.h @@ -169,7 +169,7 @@ inline simp_lor &ex_to_nonconst_simp_lor(const ex &e) simp_lor lor_g(const ex & mu, const ex & nu); simp_lor lor_vec(const string & n, const ex & mu); ex simplify_simp_lor_mul(const ex & m, const scalar_products & sp); -ex simplify_simp_lor(const ex & e, const scalar_products & sp); +ex simplify_simp_lor(const ex & e, const scalar_products & sp=scalar_products()); ex Dim(void); #ifndef NO_NAMESPACE_GINAC diff --git a/ginac/structure.pl b/ginac/structure.pl index c7ec0b27..41989148 100755 --- a/ginac/structure.pl +++ b/ginac/structure.pl @@ -32,7 +32,7 @@ while ($decl =~ /^ ?(\w+) ([\w \,]+)\; ?((\/\*.*?\*\/)?)(.*)$/) { } $member=$2; } - if ($member !~ /^\w$/) { + if ($member !~ /^\w+$/) { die "illegal struct, must match 'struct name { type var; /*comment*/ ...};': $input_structure"; } push @TYPES,$type;