simplify_indexed() raises/lowers dummy indices to canonicalize their variance

[ginac.git] / ginac / numeric.cpp

diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp
index f1be0bcbe960d0df61609a9809e70b931c01efff..000e15f8eb53acbb71277692a103dc28ca95b949 100644 (file)
--- a/ginac/numeric.cpp
+++ b/ginac/numeric.cpp
@@ -7,7 +7,7 @@
  *  of special functions or implement the interface to the bignum package. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2002 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
@@ -403,25 +403,19 @@ void numeric::print(const print_context & c, unsigned level) const
                } else {
                        if (cln::zerop(r)) {
                                // case 2, imaginary:  y*I  or  -y*I
-                               if ((precedence() <= level) && (i < 0)) {
-                                       if (i == -1) {
-                                               c.s << par_open+imag_sym+par_close;
-                                       } else {
+                               if (i==1)
+                                       c.s << imag_sym;
+                               else {
+                                       if (precedence()<=level)
                                                c.s << par_open;
+                                       if (i == -1)
+                                               c.s << "-" << imag_sym;
+                                       else {
                                                print_real_number(c, i);
-                                               c.s << mul_sym+imag_sym+par_close;
-                                       }
-                               } else {
-                                       if (i == 1) {
-                                               c.s << imag_sym;
-                                       } else {
-                                               if (i == -1) {
-                                                       c.s << "-" << imag_sym;
-                                               } else {
-                                                       print_real_number(c, i);
-                                                       c.s << mul_sym+imag_sym;
-                                               }
+                                               c.s << mul_sym+imag_sym;
                                        }
+                                       if (precedence()<=level)
+                                               c.s << par_close;
                                }
                        } else {
                                // case 3, complex:  x+y*I  or  x-y*I  or  -x+y*I  or  -x-y*I
@@ -498,6 +492,21 @@ bool numeric::info(unsigned inf) const
        return false;
 }
 
+int numeric::degree(const ex & s) const
+{
+       return 0;
+}
+
+int numeric::ldegree(const ex & s) const
+{
+       return 0;
+}
+
+ex numeric::coeff(const ex & s, int n) const
+{
+       return n==0 ? *this : _ex0;
+}
+
 /** Disassemble real part and imaginary part to scan for the occurrence of a
  *  single number.  Also handles the imaginary unit.  It ignores the sign on
  *  both this and the argument, which may lead to what might appear as funny
@@ -1537,14 +1546,13 @@ const numeric bernoulli(const numeric &nn)
 
        // algorithm not applicable to B(2), so just store it
        if (!next_r) {
-               results.push_back(); // results[0] is not used
                results.push_back(cln::recip(cln::cl_RA(6)));
                next_r = 4;
        }
        if (n<next_r)
-               return results[n/2];
+               return results[n/2-1];
 
-       results.reserve(n/2 + 1);
+       results.reserve(n/2);
        for (unsigned p=next_r; p<=n;  p+=2) {
                cln::cl_I  c = 1;  // seed for binonmial coefficients
                cln::cl_RA b = cln::cl_RA(1-p)/2;
@@ -1556,18 +1564,18 @@ const numeric bernoulli(const numeric &nn)
                if (p < (1UL<<cl_value_len/2)) {
                        for (i=2, k=1, p_2=p/2; i<=pm; i+=2, ++k, --p_2) {
                                c = cln::exquo(c * ((p3-i) * p_2), (i-1)*k);
-                               b = b + c*results[k];
+                               b = b + c*results[k-1];
                        }
                } else {
                        for (i=2, k=1, p_2=p/2; i<=pm; i+=2, ++k, --p_2) {
                                c = cln::exquo((c * (p3-i)) * p_2, cln::cl_I(i-1)*k);
-                               b = b + c*results[k];
+                               b = b + c*results[k-1];
                        }
                }
                results.push_back(-b/(p+1));
        }
        next_r = n+2;
-       return results[n/2];
+       return results[n/2-1];
 }