July 2008 - GiNaC-devel

[PATCH] [BUGFIX]: Any complex number can be (un)archived properly.
by Alexei Sheplyakov 30 Jul '08

30 Jul '08

A complex number can have an exact real part and inexact (floating point) imaginary part, and vice a versa. Handle these cases properly in the archiving code instead of bailing out with a bizzare error message. Thanks to Chris Bouchard for reporting the bug. NOTE: this fix changes the format of GiNaC archives, so formally it breaks the binary compatibility. However, "mixed" complex numbers (i.e. ones with exact real part and inexact imaginary part) can not be archived with previous versions of GiNaC, so there's nothing to break. --- check/Makefile.am | 4 ++ check/numeric_archive.cpp | 48 ++++++++++++++++++ configure.ac | 4 +- ginac/numeric.cpp | 118 ++++++++++++++++++++++++++++++++++----------- 4 files changed, 143 insertions(+), 31 deletions(-) create mode 100644 check/numeric_archive.cpp diff --git a/check/Makefile.am b/check/Makefile.am index 8d2e451..a96dcfe 100644 --- a/check/Makefile.am +++ b/check/Makefile.am @@ -7,6 +7,7 @@ CHECKS = check_numeric \ EXAMS = exam_paranoia \ exam_heur_gcd \ + exam_numeric_archive \ exam_numeric \ exam_powerlaws \ exam_inifcns \ @@ -71,6 +72,9 @@ exam_paranoia_LDADD = ../ginac/libginac.la exam_heur_gcd_SOURCES = heur_gcd_bug.cpp exam_heur_gcd_LDADD = ../ginac/libginac.la +exam_numeric_archive_SOURCES = numeric_archive.cpp +exam_numeric_archive_LDADD = ../ginac/libginac.la + exam_numeric_SOURCES = exam_numeric.cpp exam_numeric_LDADD = ../ginac/libginac.la diff --git a/check/numeric_archive.cpp b/check/numeric_archive.cpp new file mode 100644 index 0000000..8f69a7b --- /dev/null +++ b/check/numeric_archive.cpp @@ -0,0 +1,48 @@ +/** + * @file numeric_archive.cpp Check for a bug in numeric::archive + * + * numeric::archive used to fail if the real part of a complex number + * is a rational number and the imaginary part is a floating point one. + */ +#include <cln/cln.h> +#include <iostream> +#include <stdexcept> +#include <vector> +#include <iterator> +#include <algorithm> +#include <sstream> +#include "ginac.h" +using namespace cln; +using namespace GiNaC; + +struct archive_unarchive_check +{ + cl_N operator()(const cl_N& n) const + { + ex e = numeric(n); + archive ar; + ar.archive_ex(e, "test"); + lst l; + ex check = ar.unarchive_ex(l, "test"); + if (!check.is_equal(e)) { + std::ostringstream s; + s << __FILE__ << ':' << __LINE__ << ": expected: " << e << ", got " << check; + throw std::logic_error(s.str()); + } + return n; + } +}; + +int main(int argc, char** argv) +{ + const cl_I one(1); + std::cout << "checking if numeric::archive handles complex numbers properly" << std::endl; + const cl_R three_fp = cl_float(3.0, default_float_format); + std::vector<cl_N> numbers; + numbers.push_back(complex(one, three_fp)); + numbers.push_back(complex(three_fp, one)); + numbers.push_back(complex(three_fp, three_fp)); + numbers.push_back(complex(one, one)); + std::for_each(numbers.begin(), numbers.end(), archive_unarchive_check()); + return 0; +} diff --git a/configure.ac b/configure.ac index a0adef0..2518057 100644 --- a/configure.ac +++ b/configure.ac @@ -44,8 +44,8 @@ dnl The version number in newly created archives will be ARCHIVE_VERSION. dnl Archives version (ARCHIVE_VERSION-ARCHIVE_AGE) thru ARCHIVE_VERSION can dnl be read by this version of the GiNaC library. -ARCHIVE_VERSION=2 -ARCHIVE_AGE=2 +ARCHIVE_VERSION=3 +ARCHIVE_AGE=3 AC_SUBST(ARCHIVE_VERSION) AC_SUBST(ARCHIVE_AGE) diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp index 502b0ea..32839e7 100644 --- a/ginac/numeric.cpp +++ b/ginac/numeric.cpp @@ -255,60 +255,120 @@ numeric::numeric(const cln::cl_N &z) : basic(&numeric::tinfo_static) // archiving ////////// -numeric::numeric(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst) +/** + * Construct a floating point number from sign, mantissa, and exponent + */ +static const cln::cl_F make_real_float(const cln::cl_idecoded_float& dec) { - cln::cl_N ctorval = 0; + cln::cl_F x = cln::cl_float(dec.mantissa, cln::default_float_format); + x = cln::scale_float(x, dec.exponent); + cln::cl_F sign = cln::cl_float(dec.sign, cln::default_float_format); + x = cln::float_sign(sign, x); + return x; +} + +/** + * Read serialized floating point number + */ +static const cln::cl_F read_real_float(std::istream& s) +{ + cln::cl_idecoded_float dec; + s >> dec.sign >> dec.mantissa >> dec.exponent; + const cln::cl_F x = make_real_float(dec); + return x; +} +numeric::numeric(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst) +{ + value = 0; + // Read number as string std::string str; if (n.find_string("number", str)) { std::istringstream s(str); - cln::cl_idecoded_float re, im; + cln::cl_R re, im; char c; s.get(c); switch (c) { - case 'R': // Integer-decoded real number - s >> re.sign >> re.mantissa >> re.exponent; - ctorval = re.sign * re.mantissa * cln::expt(cln::cl_float(2.0, cln::default_float_format), re.exponent); + case 'R': + // real FP (floating point) number + re = read_real_float(s); + value = re; + break; + case 'C': + // both real and imaginary part are FP numbers + re = read_real_float(s); + im = read_real_float(s); + value = cln::complex(re, im); + break; + case 'H': + // real part is a rational number, + // imaginary part is a FP number + s >> re; + im = read_real_float(s); + value = cln::complex(re, im); break; - case 'C': // Integer-decoded complex number - s >> re.sign >> re.mantissa >> re.exponent; - s >> im.sign >> im.mantissa >> im.exponent; - ctorval = cln::complex(re.sign * re.mantissa * cln::expt(cln::cl_float(2.0, cln::default_float_format), re.exponent), - im.sign * im.mantissa * cln::expt(cln::cl_float(2.0, cln::default_float_format), im.exponent)); + case 'J': + // real part is a FP number, + // imaginary part is a rational number + re = read_real_float(s); + s >> im; + value = cln::complex(re, im); break; - default: // Ordinary number + default: + // both real and imaginary parts are rational s.putback(c); - s >> ctorval; + s >> value; break; } } - value = ctorval; setflag(status_flags::evaluated | status_flags::expanded); } +static void write_real_float(std::ostream& s, const cln::cl_R& n) +{ + const cln::cl_idecoded_float dec = cln::integer_decode_float(cln::the<cln::cl_F>(n)); + s << dec.sign << ' ' << dec.mantissa << ' ' << dec.exponent; +} + void numeric::archive(archive_node &n) const { inherited::archive(n); // Write number as string + + const cln::cl_R re = cln::realpart(value); + const cln::cl_R im = cln::imagpart(value); + const bool re_rationalp = cln::instanceof(re, cln::cl_RA_ring); + const bool im_rationalp = cln::instanceof(im, cln::cl_RA_ring); + + // Non-rational numbers are written in an integer-decoded format + // to preserve the precision std::ostringstream s; - if (this->is_crational()) + if (re_rationalp && im_rationalp) s << value; - else { - // Non-rational numbers are written in an integer-decoded format - // to preserve the precision - if (this->is_real()) { - cln::cl_idecoded_float re = cln::integer_decode_float(cln::the<cln::cl_F>(value)); - s << "R"; - s << re.sign << " " << re.mantissa << " " << re.exponent; - } else { - cln::cl_idecoded_float re = cln::integer_decode_float(cln::the<cln::cl_F>(cln::realpart(cln::the<cln::cl_N>(value)))); - cln::cl_idecoded_float im = cln::integer_decode_float(cln::the<cln::cl_F>(cln::imagpart(cln::the<cln::cl_N>(value)))); - s << "C"; - s << re.sign << " " << re.mantissa << " " << re.exponent << " "; - s << im.sign << " " << im.mantissa << " " << im.exponent; - } + else if (zerop(im)) { + // real FP (floating point) number + s << 'R'; + write_real_float(s, re); + } else if (re_rationalp) { + s << 'H'; // just any unique character + // real part is a rational number, + // imaginary part is a FP number + s << re << ' '; + write_real_float(s, im); + } else if (im_rationalp) { + s << 'J'; + // real part is a FP number, + // imaginary part is a rational number + write_real_float(s, re); + s << ' ' << im; + } else { + // both real and imaginary parts are floating point + s << 'C'; + write_real_float(s, re); + s << ' '; + write_real_float(s, im); } n.add_string("number", s.str()); } -- 1.5.6 Best regards, Alexei -- All science is either physics or stamp collecting.

1 0

[SCM] GiNaC -- a C++ library for symbolic computations branch, master, updated. release_1-4-0-57-ga7693a0
by git＠ginac.de 28 Jul '08

28 Jul '08

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GiNaC -- a C++ library for symbolic computations". The branch, master has been updated via a7693a0f710b49494f95ce5a4a0953752e69c7f9 (commit) via 2d52c00438cde2c47f43620d26d78022f0d60746 (commit) via a297391b22c1a4ec3464d13191f8cb33332c9863 (commit) via 5ea14a22768031a1cd4abce2926d5359c5d0c15f (commit) via 7bc327c75aaa3118de14dfcee59bcf0fd40e3f4a (commit) via 58aaaf83c55c5784e1d94c2a794af96d7769165b (commit) via 6335b2cfb6f3f9ec339ff683bed415a5879d7909 (commit) via 2406529f5ceb193a46b1b5a07a8810880a8ceceb (commit) from e20fd5e760136cf343f4d2d73d0f3dfc6573ac49 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit a7693a0f710b49494f95ce5a4a0953752e69c7f9 Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:28:34 2008 +0300 define lgamma and tgamma taking cl_N as an argument. The actual code is the same. These functions are OK since cl_N is not automatically converted to numeric any more. commit 2d52c00438cde2c47f43620d26d78022f0d60746 Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:28:10 2008 +0300 Implicit conversion from cl_N to numeric considered harmful. Finally, mark the numeric(const cl_N&) ctor as explicit. This allows one to mix the code using GiNaC and CLN, i.e. cl_N x, y; // initialize them cl_N z = sin(x) + y*exp(y); symbol a("a"); ex e = exp(a); commit a297391b22c1a4ec3464d13191f8cb33332c9863 Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:27:27 2008 +0300 bernoulli, fibonacci, iquo: explicitly convert return values to numeric. Implicit conversion from cl_N to numeric considered harmful, part 6. commit 5ea14a22768031a1cd4abce2926d5359c5d0c15f Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:27:07 2008 +0300 tgamma, lgamma: convert to take cl_N as an argument; provide wrappers for GiNaC::numeric Implicit conversion from cl_N to numeric considered harmful, part 5. commit 7bc327c75aaa3118de14dfcee59bcf0fd40e3f4a Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:26:52 2008 +0300 Li2, zeta, sqrt, abs, gcd, etc.: explicitly convert return value to numeric. Implicit conversion from cl_N to numeric considered harmful, part 4. commit 58aaaf83c55c5784e1d94c2a794af96d7769165b Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:26:23 2008 +0300 elementary functions: explicitly convert return values from cl_N to numeric. Implicit conversion from cl_N to numeric considered harmful, part 3. commit 6335b2cfb6f3f9ec339ff683bed415a5879d7909 Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:25:55 2008 +0300 inifcns_nstdsums.cpp: Lin_numeric takes cl_N as an argument instead of numeric. Implicit conversion from cl_N to numeric considered harmful, part 2. commit 2406529f5ceb193a46b1b5a07a8810880a8ceceb Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Mar 19 12:24:36 2008 +0300 inifcns_nstdsums.cpp: S_num takes cl_N as an argument instead of numeric. Implicit conversion from cl_N to numeric considered harmful. Using GiNaC::numeric for numerical computations incurs significant overhead, so one might want to do these computations using proper CLN types. Unfortunately, it's not easy due to automatic conversion from cln::cl_N to GiNaC::numeric. Here is a simple example: cl_N x, y; // initialize them return sin(x) + y*exp(y); The compiler complains about ambigously overloaded of functions, i.e. cl_N cln::sin(const cl_N&) versus numeric GiNaC::sin(const numeric&). Hence, I propose to disable *implicit* conversion from cl_N to numeric (this can be done by marking the numeric ctor as `explicit'). However, this change happens to be a bit nontrivial, because that evil conversion is used in GiNaC itself. So, I decided to rewrite those fragments of code. ----------------------------------------------------------------------- Summary of changes: ginac/inifcns_nstdsums.cpp | 87 ++++++++++++++---------- ginac/numeric.cpp | 163 ++++++++++++++++++++++++++----------------- ginac/numeric.h | 2 +- 3 files changed, 151 insertions(+), 101 deletions(-) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0

[PATCH 1/8] inifcns_nstdsums.cpp: S_num takes cl_N as an argument instead of numeric.
by Alexei Sheplyakov 28 Jul '08

28 Jul '08

Implicit conversion from cl_N to numeric considered harmful. Using GiNaC::numeric for numerical computations incurs significant overhead, so one might want to do these computations using proper CLN types. Unfortunately, it's not easy due to automatic conversion from cln::cl_N to GiNaC::numeric. Here is a simple example: cl_N x, y; // initialize them return sin(x) + y*exp(y); The compiler complains about ambigously overloaded of functions, i.e. cl_N cln::sin(const cl_N&) versus numeric GiNaC::sin(const numeric&). Hence, I propose to disable *implicit* conversion from cl_N to numeric (this can be done by marking the numeric ctor as `explicit'). However, this change happens to be a bit nontrivial, because that evil conversion is used in GiNaC itself. So, I decided to rewrite those fragments of code. --- ginac/inifcns_nstdsums.cpp | 50 ++++++++++++++++++++++++++----------------- 1 files changed, 30 insertions(+), 20 deletions(-) diff --git a/ginac/inifcns_nstdsums.cpp b/ginac/inifcns_nstdsums.cpp index cd3511a..ea42a6e 100644 --- a/ginac/inifcns_nstdsums.cpp +++ b/ginac/inifcns_nstdsums.cpp @@ -320,7 +320,7 @@ cln::cl_N Lin_do_sum_Xn(int n, const cln::cl_N& x) // forward declaration needed by function Li_projection and C below -numeric S_num(int n, int p, const numeric& x); +const cln::cl_N S_num(int n, int p, const cln::cl_N& x); // helper function for classical polylog Li @@ -371,7 +371,7 @@ cln::cl_N Li_projection(int n, const cln::cl_N& x, const cln::float_format_t& pr } else { cln::cl_N result = -cln::expt(cln::log(x), n-1) * cln::log(1-x) / cln::factorial(n-1); for (int j=0; j<n-1; j++) { - result = result + (S_num(n-j-1, 1, 1).to_cl_N() - S_num(1, n-j-1, 1-x).to_cl_N()) + result = result + (S_num(n-j-1, 1, 1) - S_num(1, n-j-1, 1-x)) * cln::expt(cln::log(x), j) / cln::factorial(j); } return result; @@ -402,7 +402,7 @@ numeric Lin_numeric(int n, const numeric& x) cln::cl_N x_ = ex_to<numeric>(x).to_cl_N(); cln::cl_N result = -cln::expt(cln::log(x_), n-1) * cln::log(1-x_) / cln::factorial(n-1); for (int j=0; j<n-1; j++) { - result = result + (S_num(n-j-1, 1, 1).to_cl_N() - S_num(1, n-j-1, 1-x_).to_cl_N()) + result = result + (S_num(n-j-1, 1, 1) - S_num(1, n-j-1, 1-x_)) * cln::expt(cln::log(x_), j) / cln::factorial(j); } return result; @@ -1715,10 +1715,10 @@ cln::cl_N C(int n, int p) if (k == 0) { if (n & 1) { if (j & 1) { - result = result - 2 * cln::expt(cln::pi(),2*j) * S_num(n-2*j,p,1).to_cl_N() / cln::factorial(2*j); + result = result - 2 * cln::expt(cln::pi(),2*j) * S_num(n-2*j,p,1) / cln::factorial(2*j); } else { - result = result + 2 * cln::expt(cln::pi(),2*j) * S_num(n-2*j,p,1).to_cl_N() / cln::factorial(2*j); + result = result + 2 * cln::expt(cln::pi(),2*j) * S_num(n-2*j,p,1) / cln::factorial(2*j); } } } @@ -1726,23 +1726,23 @@ cln::cl_N C(int n, int p) if (k & 1) { if (j & 1) { result = result + cln::factorial(n+k-1) - * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1).to_cl_N() + * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1) / (cln::factorial(k) * cln::factorial(n-1) * cln::factorial(2*j)); } else { result = result - cln::factorial(n+k-1) - * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1).to_cl_N() + * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1) / (cln::factorial(k) * cln::factorial(n-1) * cln::factorial(2*j)); } } else { if (j & 1) { - result = result - cln::factorial(n+k-1) * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1).to_cl_N() + result = result - cln::factorial(n+k-1) * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1) / (cln::factorial(k) * cln::factorial(n-1) * cln::factorial(2*j)); } else { result = result + cln::factorial(n+k-1) - * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1).to_cl_N() + * cln::expt(cln::pi(),2*j) * S_num(n+k-2*j,p-k,1) / (cln::factorial(k) * cln::factorial(n-1) * cln::factorial(2*j)); } } @@ -1855,7 +1855,7 @@ cln::cl_N S_projection(int n, int p, const cln::cl_N& x, const cln::float_format res2 = res2 + cln::expt(cln::cl_I(-1),r) * cln::expt(cln::log(1-x),r) * S_do_sum(p-r,n-s,1-x,prec) / cln::factorial(r); } - result = result + cln::expt(cln::log(x),s) * (S_num(n-s,p,1).to_cl_N() - res2) / cln::factorial(s); + result = result + cln::expt(cln::log(x),s) * (S_num(n-s,p,1) - res2) / cln::factorial(s); } return result; @@ -1866,7 +1866,7 @@ cln::cl_N S_projection(int n, int p, const cln::cl_N& x, const cln::float_format // helper function for S(n,p,x) -numeric S_num(int n, int p, const numeric& x) +const cln::cl_N S_num(int n, int p, const cln::cl_N& x) { if (x == 1) { if (n == 1) { @@ -1902,11 +1902,11 @@ numeric S_num(int n, int p, const numeric& x) // what is the desired float format? // first guess: default format cln::float_format_t prec = cln::default_float_format; - const cln::cl_N value = x.to_cl_N(); + const cln::cl_N value = x; // second guess: the argument's format - if (!x.real().is_rational()) + if (!instanceof(realpart(value), cln::cl_RA_ring)) prec = cln::float_format(cln::the<cln::cl_F>(cln::realpart(value))); - else if (!x.imag().is_rational()) + else if (!instanceof(imagpart(value), cln::cl_RA_ring)) prec = cln::float_format(cln::the<cln::cl_F>(cln::imagpart(value))); // [Kol] (5.3) @@ -1919,9 +1919,9 @@ numeric S_num(int n, int p, const numeric& x) cln::cl_N res2; for (int r=0; r<p; r++) { res2 = res2 + cln::expt(cln::cl_I(-1),r) * cln::expt(cln::log(1-value),r) - * S_num(p-r,n-s,1-value).to_cl_N() / cln::factorial(r); + * S_num(p-r,n-s,1-value) / cln::factorial(r); } - result = result + cln::expt(cln::log(value),s) * (S_num(n-s,p,1).to_cl_N() - res2) / cln::factorial(s); + result = result + cln::expt(cln::log(value),s) * (S_num(n-s,p,1) - res2) / cln::factorial(s); } return result; @@ -1936,7 +1936,7 @@ numeric S_num(int n, int p, const numeric& x) for (int r=0; r<=s; r++) { result = result + cln::expt(cln::cl_I(-1),s) * cln::expt(cln::log(-value),r) * cln::factorial(n+s-r-1) / cln::factorial(r) / cln::factorial(s-r) / cln::factorial(n-1) - * S_num(n+s-r,p-s,cln::recip(value)).to_cl_N(); + * S_num(n+s-r,p-s,cln::recip(value)); } } result = result * cln::expt(cln::cl_I(-1),n); @@ -1972,12 +1972,18 @@ numeric S_num(int n, int p, const numeric& x) static ex S_evalf(const ex& n, const ex& p, const ex& x) { if (n.info(info_flags::posint) && p.info(info_flags::posint)) { + const int n_ = ex_to<numeric>(n).to_int(); + const int p_ = ex_to<numeric>(p).to_int(); if (is_a<numeric>(x)) { - return S_num(ex_to<numeric>(n).to_int(), ex_to<numeric>(p).to_int(), ex_to<numeric>(x)); + const cln::cl_N x_ = ex_to<numeric>(x).to_cl_N(); + const cln::cl_N result = S_num(n_, p_, x_); + return numeric(result); } else { ex x_val = x.evalf(); if (is_a<numeric>(x_val)) { - return S_num(ex_to<numeric>(n).to_int(), ex_to<numeric>(p).to_int(), ex_to<numeric>(x_val)); + const cln::cl_N x_val_ = ex_to<numeric>(x_val).to_cl_N(); + const cln::cl_N result = S_num(n_, p_, x_val_); + return numeric(result); } } } @@ -2002,7 +2008,11 @@ static ex S_eval(const ex& n, const ex& p, const ex& x) return Li(n+1, x); } if (x.info(info_flags::numeric) && (!x.info(info_flags::crational))) { - return S_num(ex_to<numeric>(n).to_int(), ex_to<numeric>(p).to_int(), ex_to<numeric>(x)); + int n_ = ex_to<numeric>(n).to_int(); + int p_ = ex_to<numeric>(p).to_int(); + const cln::cl_N x_ = ex_to<numeric>(x).to_cl_N(); + const cln::cl_N result = S_num(n_, p_, x_); + return numeric(result); } } if (n.is_zero()) { -- 1.5.4.2 -- All science is either physics or stamp collecting.

3 6

[PATCH] clifford_unit: fix possible bugs due to wrong operator[!=]= usage.
by Alexei Sheplyakov 17 Jul '08

17 Jul '08

The condition like this one unsigned n /* = something */; if (n == ex_to<idx>(mu).get_dim) { // do something } is *always* true, because == creates an object of type `relational'. Likewise, this condition matrix M /* = something */; if (M(i, j) != M(j, i)) { // more code } is *always* true too. Frankly, I've got annoyed by that evil `relational' class. It doesn't do anything useful and forces everyone to write the code in a very unnatural, counter-intuitive way. I plan to remove it in the next version of GiNaC (1.5). --- ginac/clifford.cpp | 17 ++++++++++++++--- 1 files changed, 14 insertions(+), 3 deletions(-) diff --git a/ginac/clifford.cpp b/ginac/clifford.cpp index 100954d..4d73d50 100644 --- a/ginac/clifford.cpp +++ b/ginac/clifford.cpp @@ -716,6 +716,17 @@ ex dirac_ONE(unsigned char rl) return clifford(ONE, rl); } +static unsigned get_dim_uint(const ex& e) +{ + if (!is_a<idx>(e)) + throw std::invalid_argument("get_dim_uint: argument is not an index"); + ex dim = ex_to<idx>(e).get_dim(); + if (!dim.info(info_flags::posint)) + throw std::invalid_argument("get_dim_uint: dimension of index should be a positive integer"); + unsigned d = ex_to<numeric>(dim).to_int(); + return d; +} + ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl) { static ex unit = (new cliffordunit)->setflag(status_flags::dynallocated); @@ -734,10 +745,10 @@ ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl) static idx xi((new symbol)->setflag(status_flags::dynallocated), n), chi((new symbol)->setflag(status_flags::dynallocated), n); - if ((n == M.cols()) && (n == ex_to<idx>(mu).get_dim())) { + if ((n == M.cols()) && (n == get_dim_uint(mu))) { for (unsigned i = 0; i < n; i++) { for (unsigned j = i+1; j < n; j++) { - if (M(i, j) != M(j, i)) { + if (!M(i, j).is_equal(M(j, i))) { symmetric = false; } } @@ -1170,7 +1181,7 @@ ex lst_to_clifford(const ex & v, const ex & e) { ex mu = e.op(1); ex mu_toggle = is_a<varidx>(mu) ? ex_to<varidx>(mu).toggle_variance() : mu; - unsigned dim = (ex_to<numeric>(ex_to<idx>(mu).get_dim())).to_int(); + unsigned dim = get_dim_uint(mu); if (is_a<matrix>(v)) { if (ex_to<matrix>(v).cols() > ex_to<matrix>(v).rows()) { -- 1.5.6 Best regards, Alexei -- All science is either physics or stamp collecting.

3 10

[SCM] GiNaC -- a C++ library for symbolic computations branch, master, updated. release_1-4-0-49-ge20fd5e
by git＠ginac.de 17 Jul '08

17 Jul '08

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GiNaC -- a C++ library for symbolic computations". The branch, master has been updated via e20fd5e760136cf343f4d2d73d0f3dfc6573ac49 (commit) from cb078dba2a491d80a34924b29bd8d3992c18b7fe (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit e20fd5e760136cf343f4d2d73d0f3dfc6573ac49 Author: Richard B. Kreckel <kreckel(a)ginac.de> Date: Tue Jul 15 23:57:43 2008 +0200 documentation: it is get_dim(), not get_dimension() This was misdocumented ever since GiNaC-0.8.0. ----------------------------------------------------------------------- Summary of changes: doc/tutorial/ginac.texi | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

3 3

[SCM] GiNaC -- a C++ library for symbolic computations branch, ginac_1-4, updated. release_1-4-0-53-g1043ee1
by git＠ginac.de 17 Jul '08

17 Jul '08

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GiNaC -- a C++ library for symbolic computations". The branch, ginac_1-4 has been updated via 1043ee1e38b7a70e737870e6b87f07607c0e9639 (commit) from 165d6495d53e1af1073a88a3640a6f364dcb5e9b (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 1043ee1e38b7a70e737870e6b87f07607c0e9639 Author: Richard B. Kreckel <kreckel(a)ginac.de> Date: Tue Jul 15 23:57:43 2008 +0200 documentation: it is get_dim(), not get_dimension() This was misdocumented ever since GiNaC-0.8.0. ----------------------------------------------------------------------- Summary of changes: doc/tutorial/ginac.texi | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0

Questions about expairseq::match().
by Alexei Sheplyakov 15 Jul '08

15 Jul '08

Hi! I've stumbled upon the following code in ginac/exparseq.cpp:expairseq::match() 422 // Now, for every term of the pattern, look for a matching term in 423 // the expression and remove the match 424 for (size_t i=0; i<pattern.nops(); i++) { 425 ex p = pattern.op(i); 426 if (has_global_wildcard && p.is_equal(global_wildcard)) 427 continue; 428 exvector::iterator it = ops.begin(), itend = ops.end(); 429 while (it != itend) { So far so good... 430 lst::const_iterator last_el = repl_lst.end(); 431 --last_el; 432 if (it->match(p, repl_lst)) { 433 ops.erase(it); 434 goto found; 435 } This fragment looks a bit confusing. it->match(p, repl_lst) can change repl_lst, so iterators become invalid. Fortunately, in that case match returns true, so we jump out of the loop. So, we can initialize the iterator last_el *after* checking for possible matches, like this: if (it->match(p, repl_lst)) { ops.erase(it); goto found; } lst::const_iterator last_el = repl_lst.end(); --last_el; Unless I'm missing something this code is equivalent to the previous variant, but it's more readable (i.e. no confusion about possible invalidation of last_el iterator). 436 while(true) { 437 lst::const_iterator next_el = last_el; 438 ++next_el; 439 if(next_el == repl_lst.end()) 440 break; 441 else 442 repl_lst.remove_last(); 443 } There's definitely something fishy about this chunk. First of all, it seems like next_el at the line 439 is always repl_lst.end(), so this code doesn't do anything at all. Secondly, if it next_el ever changes its value from repl_lst.end(), repl_lst.remove_last() invalidates iterators (both next_el *and* last_el), so the result of next iteration is unpredictable. So, the questions are: 1. What I'm missing here? 2. What is the actual purpose of this code (lines 436 -- 443)? 3. According to git-blame, this (a little bit strange) code was introduced by commit 73f0ce4cf8d91f073f35a45443f5fbe886921c5c. The commit message says: "Fixed bug in ::match." What was the bug in first place? Could anyone please enlighten me? Best regards, Alexei -- All science is either physics or stamp collecting.

2 3

[SCM] GiNaC -- a C++ library for symbolic computations branch, master, updated. release_1-4-0-48-gcb078db
by git＠ginac.de 15 Jul '08

15 Jul '08

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GiNaC -- a C++ library for symbolic computations". The branch, master has been updated via cb078dba2a491d80a34924b29bd8d3992c18b7fe (commit) from 37d324b137fcb61384203b711e91d8919535f237 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit cb078dba2a491d80a34924b29bd8d3992c18b7fe Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Mon Jul 14 17:46:25 2008 +0400 clifford_unit: fix possible bugs due to wrong operator[!=]= usage. ----------------------------------------------------------------------- Summary of changes: ginac/clifford.cpp | 17 ++++++++++++++--- 1 files changed, 14 insertions(+), 3 deletions(-) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0