- GiNaC-devel - ginac.de

[SCM] GiNaC -- a C++ library for symbolic computations branch, master, updated. release_1-4-0-62-g37c418c
by git＠ginac.de 20 Aug '08

20 Aug '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 37c418c602485be9b023378a1b60ebdb4a592f2a (commit) from f3eefbda588318e09dcb3180c6f039dc3fc30f87 (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 37c418c602485be9b023378a1b60ebdb4a592f2a Author: Jens Vollinga <jensv(a)nikhef.nl> Date: Wed Aug 20 22:16:13 2008 +0200 Fixed bug in the Q matrix calculation and the univariate factorization function. ----------------------------------------------------------------------- Summary of changes: check/exam_factor.cpp | 9 +++++++- ginac/factor.cpp | 51 +++++++++++++++++++++++++++++++++--------------- 2 files changed, 43 insertions(+), 17 deletions(-) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0

[PATCH] [BUGFIX] Reclaiming the memory allocated for static objects *is* necessary.
by Alexei Sheplyakov 19 Aug '08

19 Aug '08

GiNaC allocates memory for static objects (i.e. flyweights, remember tables, etc), but doesn't free it. This is OK if the program lifetime matches libginac lifetime, since the OS will reclaim that memory anyway. However, if the program lifetime is different from that of libginac, this turns into a memory leak. This happens if someone dlopen's libginac.so, and dlclose's it later on (read: if someone uses GiNaC via scripting language bindings). symbol::autoname_prefix(): there's no need for dynamical memory allocation. remember_table::remember_tables(): likewise. function::registered_functions(): likewise. lib_init::~lib_init(): if library usage count drops to 0, reclaim the memory allocated for flyweights. --- ginac/function.pl | 4 +- ginac/remember.cpp | 4 +- ginac/symbol.cpp | 6 ++-- ginac/utils.cpp | 55 +++++++++++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 59 insertions(+), 10 deletions(-) diff --git a/ginac/function.pl b/ginac/function.pl index 3e44735..7a4d5e7 100644 --- a/ginac/function.pl +++ b/ginac/function.pl @@ -1330,8 +1330,8 @@ ${power_switch_statement} std::vector<function_options> & function::registered_functions() { - static std::vector<function_options> * rf = new std::vector<function_options>; - return *rf; + static std::vector<function_options> rf = std::vector<function_options>(); + return rf; } bool function::lookup_remember_table(ex & result) const diff --git a/ginac/remember.cpp b/ginac/remember.cpp index faa89d3..701a27e 100644 --- a/ginac/remember.cpp +++ b/ginac/remember.cpp @@ -183,8 +183,8 @@ void remember_table::init_table() std::vector<remember_table> & remember_table::remember_tables() { - static std::vector<remember_table> * rt = new std::vector<remember_table>; - return *rt; + static std::vector<remember_table> rt = std::vector<remember_table>(); + return rt; } } // namespace GiNaC diff --git a/ginac/symbol.cpp b/ginac/symbol.cpp index f1b2be6..e56ade3 100644 --- a/ginac/symbol.cpp +++ b/ginac/symbol.cpp @@ -340,10 +340,10 @@ void symbol::unassign() /** Symbols not constructed with a string get one assigned using this * prefix and a number. */ -std::string & symbol::autoname_prefix() +std::string& symbol::autoname_prefix() { - static std::string *s = new std::string("symbol"); - return *s; + static std::string s("symbol"); + return s; } /** Return default TeX name for symbol. This recognizes some greek letters. */ diff --git a/ginac/utils.cpp b/ginac/utils.cpp index b55948b..f44ed9f 100644 --- a/ginac/utils.cpp +++ b/ginac/utils.cpp @@ -388,9 +388,58 @@ library_init::library_init() library_init::~library_init() { if (--count==0) { - // In theory, we would have to clean up here. But since we were - // only initializing memory in the ctor and that memory is reclaimed - // anyways by the OS when the program exits, we skip this. + // It's really necessary to clean up, since the program + // lifetime might not be the same as libginac.{so,dll} one + // (e.g. consider // dlopen/dlsym/dlclose sequence). + delete _num120_p; + delete _num_120_p; + delete _num60_p; + delete _num_60_p; + delete _num48_p; + delete _num_48_p; + delete _num30_p; + delete _num_30_p; + delete _num25_p; + delete _num_25_p; + delete _num24_p; + delete _num_24_p; + delete _num20_p; + delete _num_20_p; + delete _num18_p; + delete _num_18_p; + delete _num15_p; + delete _num_15_p; + delete _num12_p; + delete _num_12_p; + delete _num11_p; + delete _num_11_p; + delete _num10_p; + delete _num_10_p; + delete _num9_p; + delete _num_9_p; + delete _num8_p; + delete _num_8_p; + delete _num7_p; + delete _num_7_p; + delete _num6_p; + delete _num_6_p; + delete _num5_p; + delete _num_5_p; + delete _num4_p; + delete _num_4_p; + delete _num3_p; + delete _num_3_p; + delete _num2_p; + delete _num_2_p; + delete _num1_p; + delete _num_1_p; + delete _num1_2_p; + delete _num_1_2_p; + delete _num1_3_p; + delete _num_1_3_p; + delete _num1_4_p; + delete _num_1_4_p; + delete _num0_p; } } -- 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-61-gf3eefbd
by git＠ginac.de 18 Aug '08

18 Aug '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 f3eefbda588318e09dcb3180c6f039dc3fc30f87 (commit) from d08150300eb98c6435a4c464c057ba2967a19c8f (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 f3eefbda588318e09dcb3180c6f039dc3fc30f87 Author: Jens Vollinga <jensv(a)nikhef.nl> Date: Mon Aug 18 21:10:48 2008 +0200 Fixed bug in modular square-free factorization. ----------------------------------------------------------------------- Summary of changes: ginac/factor.cpp | 5 +++-- 1 files changed, 3 insertions(+), 2 deletions(-) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0

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

17 Aug '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 e6caa2040557bdaaf2262afc0bb47dddd88e38cd (commit) from 1043ee1e38b7a70e737870e6b87f07607c0e9639 (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 e6caa2040557bdaaf2262afc0bb47dddd88e38cd Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Jul 30 20:32:46 2008 +0400 Any complex number can be (un)archived properly. 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. ----------------------------------------------------------------------- Summary of changes: 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 hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0

[SCM] GiNaC -- a C++ library for symbolic computations branch, master, updated. release_1-4-0-60-gd081503
by git＠ginac.de 09 Aug '08

09 Aug '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 d08150300eb98c6435a4c464c057ba2967a19c8f (commit) via 114449ae6f2cd3151d9b8342c570db021a9e892c (commit) via 5e9875d5f67a68d2cb680454ff4de480bad1b6f1 (commit) from a7693a0f710b49494f95ce5a4a0953752e69c7f9 (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 d08150300eb98c6435a4c464c057ba2967a19c8f Author: Jens Vollinga <jensv(a)nikhef.nl> Date: Sat Aug 9 10:14:02 2008 +0200 Added polynomial factorization (univariate case). commit 114449ae6f2cd3151d9b8342c570db021a9e892c Author: Jens Vollinga <jensv(a)nikhef.nl> Date: Sat Aug 9 10:11:40 2008 +0200 Added polynomial factorization (univariate case). commit 5e9875d5f67a68d2cb680454ff4de480bad1b6f1 Author: Alexei Sheplyakov <varg(a)theor.jinr.ru> Date: Wed Jul 30 20:32:46 2008 +0400 Any complex number can be (un)archived properly. 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. ----------------------------------------------------------------------- Summary of changes: check/Makefile.am | 8 + check/exam_factor.cpp | 102 ++++ check/numeric_archive.cpp | 48 ++ configure.ac | 4 +- ginac/Makefile.am | 4 +- ginac/factor.cpp | 1221 ++++++++++++++++++++++++++++++++++++++++ ginac/{tostring.h => factor.h} | 25 +- ginac/ginac.h | 2 + ginac/numeric.cpp | 118 +++- ginsh/ginsh.1.in | 3 + ginsh/ginsh_parser.yy | 2 + 11 files changed, 1489 insertions(+), 48 deletions(-) create mode 100644 check/exam_factor.cpp create mode 100644 check/numeric_archive.cpp create mode 100644 ginac/factor.cpp copy ginac/{tostring.h => factor.h} (71%) hooks/post-receive -- GiNaC -- a C++ library for symbolic computations

1 0

[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