X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fnumeric.cpp;h=f8e4d93b406222046357042188ad12acb42ef9df;hp=358ad45d3f5df37d72a05ae8d08b041ce4b3f619;hb=c77b5c8466b3d0a007146b435c4635ccf3fbf373;hpb=1bd972bf8e4eeeb8aec6081100876e81a7f18450 diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp index 358ad45d..f8e4d93b 100644 --- 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-2003 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 @@ -29,19 +29,14 @@ #include #include #include - -#if defined(HAVE_SSTREAM) #include -#elif defined(HAVE_STRSTREAM) -#include -#else -#error Need either sstream or strstream -#endif +#include #include "numeric.h" #include "ex.h" +#include "operators.h" #include "archive.h" -#include "debugmsg.h" +#include "tostring.h" #include "utils.h" // CLN should pollute the global namespace as little as possible. Hence, we @@ -63,41 +58,25 @@ #include #include -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC -GINAC_IMPLEMENT_REGISTERED_CLASS(numeric, basic) +GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(numeric, basic, + print_func(&numeric::do_print). + print_func(&numeric::do_print_latex). + print_func(&numeric::do_print_csrc). + print_func(&numeric::do_print_csrc_cl_N). + print_func(&numeric::do_print_tree). + print_func(&numeric::do_print_python_repr)) ////////// -// default constructor, destructor, copy constructor assignment -// operator and helpers +// default constructor ////////// -// public - /** default ctor. Numerically it initializes to an integer zero. */ numeric::numeric() : basic(TINFO_numeric) { - debugmsg("numeric default constructor", LOGLEVEL_CONSTRUCT); value = cln::cl_I(0); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); -} - -// protected - -void numeric::copy(const numeric & other) -{ - basic::copy(other); - value = other.value; -} - -void numeric::destroy(bool call_parent) -{ - if (call_parent) basic::destroy(call_parent); + setflag(status_flags::evaluated | status_flags::expanded); } ////////// @@ -108,130 +87,115 @@ void numeric::destroy(bool call_parent) numeric::numeric(int i) : basic(TINFO_numeric) { - debugmsg("numeric constructor from int",LOGLEVEL_CONSTRUCT); // Not the whole int-range is available if we don't cast to long // first. This is due to the behaviour of the cl_I-ctor, which - // emphasizes efficiency. However, if the integer is small enough, - // i.e. satisfies cl_immediate_p(), we save space and dereferences by - // using an immediate type: - if (cln::cl_immediate_p(i)) + // emphasizes efficiency. However, if the integer is small enough + // we save space and dereferences by using an immediate type. + // (C.f. ) + if (i < (1L << (cl_value_len-1)) && i >= -(1L << (cl_value_len-1))) value = cln::cl_I(i); else - value = cln::cl_I((long) i); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + value = cln::cl_I(static_cast(i)); + setflag(status_flags::evaluated | status_flags::expanded); } numeric::numeric(unsigned int i) : basic(TINFO_numeric) { - debugmsg("numeric constructor from uint",LOGLEVEL_CONSTRUCT); // Not the whole uint-range is available if we don't cast to ulong // first. This is due to the behaviour of the cl_I-ctor, which - // emphasizes efficiency. However, if the integer is small enough, - // i.e. satisfies cl_immediate_p(), we save space and dereferences by - // using an immediate type: - if (cln::cl_immediate_p(i)) + // emphasizes efficiency. However, if the integer is small enough + // we save space and dereferences by using an immediate type. + // (C.f. ) + if (i < (1U << (cl_value_len-1))) value = cln::cl_I(i); else - value = cln::cl_I((unsigned long) i); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + value = cln::cl_I(static_cast(i)); + setflag(status_flags::evaluated | status_flags::expanded); } numeric::numeric(long i) : basic(TINFO_numeric) { - debugmsg("numeric constructor from long",LOGLEVEL_CONSTRUCT); value = cln::cl_I(i); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + setflag(status_flags::evaluated | status_flags::expanded); } numeric::numeric(unsigned long i) : basic(TINFO_numeric) { - debugmsg("numeric constructor from ulong",LOGLEVEL_CONSTRUCT); value = cln::cl_I(i); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + setflag(status_flags::evaluated | status_flags::expanded); } -/** Ctor for rational numerics a/b. + +/** Constructor for rational numerics a/b. * * @exception overflow_error (division by zero) */ numeric::numeric(long numer, long denom) : basic(TINFO_numeric) { - debugmsg("numeric constructor from long/long",LOGLEVEL_CONSTRUCT); if (!denom) throw std::overflow_error("division by zero"); value = cln::cl_I(numer) / cln::cl_I(denom); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + setflag(status_flags::evaluated | status_flags::expanded); } numeric::numeric(double d) : basic(TINFO_numeric) { - debugmsg("numeric constructor from double",LOGLEVEL_CONSTRUCT); // We really want to explicitly use the type cl_LF instead of the // more general cl_F, since that would give us a cl_DF only which // will not be promoted to cl_LF if overflow occurs: value = cln::cl_float(d, cln::default_float_format); - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + setflag(status_flags::evaluated | status_flags::expanded); } + /** ctor from C-style string. It also accepts complex numbers in GiNaC * notation like "2+5*I". */ numeric::numeric(const char *s) : basic(TINFO_numeric) { - debugmsg("numeric constructor from string",LOGLEVEL_CONSTRUCT); cln::cl_N ctorval = 0; // parse complex numbers (functional but not completely safe, unfortunately // std::string does not understand regexpese): // ss should represent a simple sum like 2+5*I - std::string ss(s); - // make it safe by adding explicit sign + std::string ss = s; + std::string::size_type delim; + + // make this implementation safe by adding explicit sign if (ss.at(0) != '+' && ss.at(0) != '-' && ss.at(0) != '#') ss = '+' + ss; - std::string::size_type delim; + + // We use 'E' as exponent marker in the output, but some people insist on + // writing 'e' at input, so let's substitute them right at the beginning: + while ((delim = ss.find("e"))!=std::string::npos) + ss.replace(delim,1,"E"); + + // main parser loop: do { // chop ss into terms from left to right std::string term; bool imaginary = false; delim = ss.find_first_of(std::string("+-"),1); // Do we have an exponent marker like "31.415E-1"? If so, hop on! - if ((delim != std::string::npos) && (ss.at(delim-1) == 'E')) + if (delim!=std::string::npos && ss.at(delim-1)=='E') delim = ss.find_first_of(std::string("+-"),delim+1); term = ss.substr(0,delim); - if (delim != std::string::npos) + if (delim!=std::string::npos) ss = ss.substr(delim); // is the term imaginary? - if (term.find("I") != std::string::npos) { + if (term.find("I")!=std::string::npos) { // erase 'I': - term = term.replace(term.find("I"),1,""); + term.erase(term.find("I"),1); // erase '*': - if (term.find("*") != std::string::npos) - term = term.replace(term.find("*"),1,""); + if (term.find("*")!=std::string::npos) + term.erase(term.find("*"),1); // correct for trivial +/-I without explicit factor on I: - if (term.size() == 1) - term += "1"; + if (term.size()==1) + term += '1'; imaginary = true; } - if (term.find(".") != std::string::npos) { + if (term.find('.')!=std::string::npos || term.find('E')!=std::string::npos) { // CLN's short type cl_SF is not very useful within the GiNaC // framework where we are mainly interested in the arbitrary // precision type cl_LF. Hence we go straight to the construction @@ -242,70 +206,50 @@ numeric::numeric(const char *s) : basic(TINFO_numeric) // 31.4E-1 --> 31.4e-1_ // and s on. // No exponent marker? Let's add a trivial one. - if (term.find("E") == std::string::npos) + if (term.find("E")==std::string::npos) term += "E0"; // E to lower case term = term.replace(term.find("E"),1,"e"); // append _ to term -#if defined(HAVE_SSTREAM) - std::ostringstream buf; - buf << unsigned(Digits) << std::ends; - term += "_" + buf.str(); -#else - char buf[14]; - std::ostrstream(buf,sizeof(buf)) << unsigned(Digits) << std::ends; - term += "_" + string(buf); -#endif + term += "_" + ToString((unsigned)Digits); // construct float using cln::cl_F(const char *) ctor. if (imaginary) ctorval = ctorval + cln::complex(cln::cl_I(0),cln::cl_F(term.c_str())); else ctorval = ctorval + cln::cl_F(term.c_str()); } else { - // not a floating point number... + // this is not a floating point number... if (imaginary) ctorval = ctorval + cln::complex(cln::cl_I(0),cln::cl_R(term.c_str())); else ctorval = ctorval + cln::cl_R(term.c_str()); } - } while(delim != std::string::npos); + } while (delim != std::string::npos); value = ctorval; - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + setflag(status_flags::evaluated | status_flags::expanded); } + /** Ctor from CLN types. This is for the initiated user or internal use * only. */ -numeric::numeric(const cln::cl_N & z) : basic(TINFO_numeric) +numeric::numeric(const cln::cl_N &z) : basic(TINFO_numeric) { - debugmsg("numeric constructor from cl_N", LOGLEVEL_CONSTRUCT); value = z; - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); + setflag(status_flags::evaluated | status_flags::expanded); } ////////// // archiving ////////// -/** Construct object from archive_node. */ -numeric::numeric(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +numeric::numeric(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("numeric constructor from archive_node", LOGLEVEL_CONSTRUCT); cln::cl_N ctorval = 0; // Read number as string std::string str; if (n.find_string("number", str)) { -#ifdef HAVE_SSTREAM std::istringstream s(str); -#else - std::istrstream s(str.c_str(), str.size() + 1); -#endif cln::cl_idecoded_float re, im; char c; s.get(c); @@ -327,30 +271,15 @@ numeric::numeric(const archive_node &n, const lst &sym_lst) : inherited(n, sym_l } } value = ctorval; - calchash(); - setflag(status_flags::evaluated | - status_flags::expanded | - status_flags::hash_calculated); -} - -/** Unarchive the object. */ -ex numeric::unarchive(const archive_node &n, const lst &sym_lst) -{ - return (new numeric(n, sym_lst))->setflag(status_flags::dynallocated); + setflag(status_flags::evaluated | status_flags::expanded); } -/** Archive the object. */ void numeric::archive(archive_node &n) const { inherited::archive(n); // Write number as string -#ifdef HAVE_SSTREAM std::ostringstream s; -#else - char buf[1024]; - std::ostrstream s(buf, 1024); -#endif if (this->is_crational()) s << cln::the(value); else { @@ -368,17 +297,13 @@ void numeric::archive(archive_node &n) const s << im.sign << " " << im.mantissa << " " << im.exponent; } } -#ifdef HAVE_SSTREAM n.add_string("number", s.str()); -#else - s << ends; - std::string str(buf); - n.add_string("number", str); -#endif } +DEFAULT_UNARCHIVE(numeric) + ////////// -// functions overriding virtual functions from bases classes +// functions overriding virtual functions from base classes ////////// /** Helper function to print a real number in a nicer way than is CLN's @@ -388,145 +313,249 @@ void numeric::archive(archive_node &n) const * want to visibly distinguish from cl_LF. * * @see numeric::print() */ -static void print_real_number(std::ostream & os, const cln::cl_R & num) +static void print_real_number(const print_context & c, const cln::cl_R & x) { cln::cl_print_flags ourflags; - if (cln::instanceof(num, cln::cl_RA_ring)) { - // case 1: integer or rational, nothing special to do: - cln::print_real(os, ourflags, num); + if (cln::instanceof(x, cln::cl_RA_ring)) { + // case 1: integer or rational + if (cln::instanceof(x, cln::cl_I_ring) || + !is_a(c)) { + cln::print_real(c.s, ourflags, x); + } else { // rational output in LaTeX context + if (x < 0) + c.s << "-"; + c.s << "\\frac{"; + cln::print_real(c.s, ourflags, cln::abs(cln::numerator(cln::the(x)))); + c.s << "}{"; + cln::print_real(c.s, ourflags, cln::denominator(cln::the(x))); + c.s << '}'; + } } else { // case 2: float // make CLN believe this number has default_float_format, so it prints // 'E' as exponent marker instead of 'L': - ourflags.default_float_format = cln::float_format(cln::the(num)); - cln::print_real(os, ourflags, num); + ourflags.default_float_format = cln::float_format(cln::the(x)); + cln::print_real(c.s, ourflags, x); } - return; } -/** This method adds to the output so it blends more consistently together - * with the other routines and produces something compatible to ginsh input. - * - * @see print_real_number() */ -void numeric::print(std::ostream & os, unsigned upper_precedence) const +/** Helper function to print integer number in C++ source format. + * + * @see numeric::print() */ +static void print_integer_csrc(const print_context & c, const cln::cl_I & x) { - debugmsg("numeric print", LOGLEVEL_PRINT); - cln::cl_R r = cln::realpart(cln::the(value)); - cln::cl_R i = cln::imagpart(cln::the(value)); + // Print small numbers in compact float format, but larger numbers in + // scientific format + const int max_cln_int = 536870911; // 2^29-1 + if (x >= cln::cl_I(-max_cln_int) && x <= cln::cl_I(max_cln_int)) + c.s << cln::cl_I_to_int(x) << ".0"; + else + c.s << cln::double_approx(x); +} + +/** Helper function to print real number in C++ source format. + * + * @see numeric::print() */ +static void print_real_csrc(const print_context & c, const cln::cl_R & x) +{ + if (cln::instanceof(x, cln::cl_I_ring)) { + + // Integer number + print_integer_csrc(c, cln::the(x)); + + } else if (cln::instanceof(x, cln::cl_RA_ring)) { + + // Rational number + const cln::cl_I numer = cln::numerator(cln::the(x)); + const cln::cl_I denom = cln::denominator(cln::the(x)); + if (cln::plusp(x) > 0) { + c.s << "("; + print_integer_csrc(c, numer); + } else { + c.s << "-("; + print_integer_csrc(c, -numer); + } + c.s << "/"; + print_integer_csrc(c, denom); + c.s << ")"; + + } else { + + // Anything else + c.s << cln::double_approx(x); + } +} + +/** Helper function to print real number in C++ source format using cl_N types. + * + * @see numeric::print() */ +static void print_real_cl_N(const print_context & c, const cln::cl_R & x) +{ + if (cln::instanceof(x, cln::cl_I_ring)) { + + // Integer number + c.s << "cln::cl_I(\""; + print_real_number(c, x); + c.s << "\")"; + + } else if (cln::instanceof(x, cln::cl_RA_ring)) { + + // Rational number + cln::cl_print_flags ourflags; + c.s << "cln::cl_RA(\""; + cln::print_rational(c.s, ourflags, cln::the(x)); + c.s << "\")"; + + } else { + + // Anything else + c.s << "cln::cl_F(\""; + print_real_number(c, cln::cl_float(1.0, cln::default_float_format) * x); + c.s << "_" << Digits << "\")"; + } +} + +void numeric::print_numeric(const print_context & c, const char *par_open, const char *par_close, const char *imag_sym, const char *mul_sym, unsigned level) const +{ + const cln::cl_R r = cln::realpart(cln::the(value)); + const cln::cl_R i = cln::imagpart(cln::the(value)); + if (cln::zerop(i)) { + // case 1, real: x or -x - if ((precedence<=upper_precedence) && (!this->is_nonneg_integer())) { - os << "("; - print_real_number(os, r); - os << ")"; + if ((precedence() <= level) && (!this->is_nonneg_integer())) { + c.s << par_open; + print_real_number(c, r); + c.s << par_close; } else { - print_real_number(os, r); + print_real_number(c, r); } + } else { if (cln::zerop(r)) { + // case 2, imaginary: y*I or -y*I - if ((precedence<=upper_precedence) && (i < 0)) { - if (i == -1) { - os << "(-I)"; - } else { - os << "("; - print_real_number(os, i); - os << "*I)"; - } - } else { - if (i == 1) { - os << "I"; - } else { - if (i == -1) { - os << "-I"; - } else { - print_real_number(os, i); - os << "*I"; - } + 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; } + 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 - if (precedence <= upper_precedence) - os << "("; - print_real_number(os, r); + if (precedence() <= level) + c.s << par_open; + print_real_number(c, r); if (i < 0) { if (i == -1) { - os << "-I"; + c.s << "-" << imag_sym; } else { - print_real_number(os, i); - os << "*I"; + print_real_number(c, i); + c.s << mul_sym << imag_sym; } } else { if (i == 1) { - os << "+I"; + c.s << "+" << imag_sym; } else { - os << "+"; - print_real_number(os, i); - os << "*I"; + c.s << "+"; + print_real_number(c, i); + c.s << mul_sym << imag_sym; } } - if (precedence <= upper_precedence) - os << ")"; + if (precedence() <= level) + c.s << par_close; } } } - -void numeric::printraw(std::ostream & os) const +void numeric::do_print(const print_context & c, unsigned level) const { - // The method printraw doesn't do much, it simply uses CLN's operator<<() - // for output, which is ugly but reliable. e.g: 2+2i - debugmsg("numeric printraw", LOGLEVEL_PRINT); - os << "numeric(" << cln::the(value) << ")"; + print_numeric(c, "(", ")", "I", "*", level); } - -void numeric::printtree(std::ostream & os, unsigned indent) const +void numeric::do_print_latex(const print_latex & c, unsigned level) const { - debugmsg("numeric printtree", LOGLEVEL_PRINT); - os << std::string(indent,' ') << cln::the(value) - << " (numeric): " - << "hash=" << hashvalue - << " (0x" << std::hex << hashvalue << std::dec << ")" - << ", flags=" << flags << std::endl; + print_numeric(c, "{(", ")}", "i", " ", level); } - -void numeric::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const +void numeric::do_print_csrc(const print_csrc & c, unsigned level) const { - debugmsg("numeric print csrc", LOGLEVEL_PRINT); - std::ios::fmtflags oldflags = os.flags(); - os.setf(std::ios::scientific); - if (this->is_rational() && !this->is_integer()) { - if (compare(_num0()) > 0) { - os << "("; - if (type == csrc_types::ctype_cl_N) - os << "cln::cl_F(\"" << numer().evalf() << "\")"; - else - os << numer().to_double(); - } else { - os << "-("; - if (type == csrc_types::ctype_cl_N) - os << "cln::cl_F(\"" << -numer().evalf() << "\")"; - else - os << -numer().to_double(); - } - os << "/"; - if (type == csrc_types::ctype_cl_N) - os << "cln::cl_F(\"" << denom().evalf() << "\")"; - else - os << denom().to_double(); - os << ")"; + std::ios::fmtflags oldflags = c.s.flags(); + c.s.setf(std::ios::scientific); + int oldprec = c.s.precision(); + + // Set precision + if (is_a(c)) + c.s.precision(std::numeric_limits::digits10 + 1); + else + c.s.precision(std::numeric_limits::digits10 + 1); + + if (this->is_real()) { + + // Real number + print_real_csrc(c, cln::the(value)); + } else { - if (type == csrc_types::ctype_cl_N) - os << "cln::cl_F(\"" << evalf() << "\")"; + + // Complex number + c.s << "std::complex<"; + if (is_a(c)) + c.s << "double>("; else - os << to_double(); + c.s << "float>("; + + print_real_csrc(c, cln::realpart(cln::the(value))); + c.s << ","; + print_real_csrc(c, cln::imagpart(cln::the(value))); + c.s << ")"; + } + + c.s.flags(oldflags); + c.s.precision(oldprec); +} + +void numeric::do_print_csrc_cl_N(const print_csrc_cl_N & c, unsigned level) const +{ + if (this->is_real()) { + + // Real number + print_real_cl_N(c, cln::the(value)); + + } else { + + // Complex number + c.s << "cln::complex("; + print_real_cl_N(c, cln::realpart(cln::the(value))); + c.s << ","; + print_real_cl_N(c, cln::imagpart(cln::the(value))); + c.s << ")"; } - os.flags(oldflags); } +void numeric::do_print_tree(const print_tree & c, unsigned level) const +{ + c.s << std::string(level, ' ') << cln::the(value) + << " (" << class_name() << ")" << " @" << this + << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec + << std::endl; +} + +void numeric::do_print_python_repr(const print_python_repr & c, unsigned level) const +{ + c.s << class_name() << "('"; + print_numeric(c, "(", ")", "I", "*", level); + c.s << "')"; +} bool numeric::info(unsigned inf) const { @@ -573,17 +602,32 @@ 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 * results: (2+I).has(-2) -> true. But this is consistent, since we also * would like to have (-2+I).has(2) -> true and we want to think about the * sign as a multiplicative factor. */ -bool numeric::has(const ex & other) const +bool numeric::has(const ex &other) const { - if (!is_exactly_of_type(*other.bp, numeric)) + if (!is_exactly_a(other)) return false; - const numeric & o = static_cast(const_cast(*other.bp)); + const numeric &o = ex_to(other); if (this->is_equal(o) || this->is_equal(-o)) return true; if (o.imag().is_zero()) // e.g. scan for 3 in -3*I @@ -620,44 +664,38 @@ ex numeric::evalf(int level) const { // level can safely be discarded for numeric objects. return numeric(cln::cl_float(1.0, cln::default_float_format) * - (cln::the(value))); + (cln::the(value))); } // protected -/** Implementation of ex::diff() for a numeric. It always returns 0. - * - * @see ex::diff */ -ex numeric::derivative(const symbol & s) const -{ - return _ex0(); -} - - -int numeric::compare_same_type(const basic & other) const +int numeric::compare_same_type(const basic &other) const { - GINAC_ASSERT(is_exactly_of_type(other, numeric)); - const numeric & o = static_cast(const_cast(other)); + GINAC_ASSERT(is_exactly_a(other)); + const numeric &o = static_cast(other); return this->compare(o); } -bool numeric::is_equal_same_type(const basic & other) const +bool numeric::is_equal_same_type(const basic &other) const { - GINAC_ASSERT(is_exactly_of_type(other,numeric)); - const numeric *o = static_cast(&other); + GINAC_ASSERT(is_exactly_a(other)); + const numeric &o = static_cast(other); - return this->is_equal(*o); + return this->is_equal(o); } -unsigned numeric::calchash(void) const +unsigned numeric::calchash() const { - // Use CLN's hashcode. Warning: It depends only on the number's value, not - // its type or precision (i.e. a true equivalence relation on numbers). As - // a consequence, 3 and 3.0 share the same hashvalue. - return (hashvalue = cln::equal_hashcode(cln::the(value)) | 0x80000000U); + // Base computation of hashvalue on CLN's hashcode. Note: That depends + // only on the number's value, not its type or precision (i.e. a true + // equivalence relation on numbers). As a consequence, 3 and 3.0 share + // the same hashvalue. That shouldn't really matter, though. + setflag(status_flags::hash_calculated); + hashvalue = golden_ratio_hash(cln::equal_hashcode(cln::the(value))); + return hashvalue; } @@ -674,48 +712,34 @@ unsigned numeric::calchash(void) const // public /** Numerical addition method. Adds argument to *this and returns result as - * a new numeric object. */ -const numeric numeric::add(const numeric & other) const + * a numeric object. */ +const numeric numeric::add(const numeric &other) const { - // Efficiency shortcut: trap the neutral element by pointer. - static const numeric * _num0p = &_num0(); - if (this==_num0p) - return other; - else if (&other==_num0p) - return *this; - return numeric(cln::the(value)+cln::the(other.value)); } /** Numerical subtraction method. Subtracts argument from *this and returns - * result as a new numeric object. */ -const numeric numeric::sub(const numeric & other) const + * result as a numeric object. */ +const numeric numeric::sub(const numeric &other) const { return numeric(cln::the(value)-cln::the(other.value)); } /** Numerical multiplication method. Multiplies *this and argument and returns - * result as a new numeric object. */ -const numeric numeric::mul(const numeric & other) const + * result as a numeric object. */ +const numeric numeric::mul(const numeric &other) const { - // Efficiency shortcut: trap the neutral element by pointer. - static const numeric * _num1p = &_num1(); - if (this==_num1p) - return other; - else if (&other==_num1p) - return *this; - return numeric(cln::the(value)*cln::the(other.value)); } /** Numerical division method. Divides *this by argument and returns result as - * a new numeric object. + * a numeric object. * * @exception overflow_error (division by zero) */ -const numeric numeric::div(const numeric & other) const +const numeric numeric::div(const numeric &other) const { if (cln::zerop(cln::the(other.value))) throw std::overflow_error("numeric::div(): division by zero"); @@ -723,11 +747,13 @@ const numeric numeric::div(const numeric & other) const } -const numeric numeric::power(const numeric & other) const +/** Numerical exponentiation. Raises *this to the power given as argument and + * returns result as a numeric object. */ +const numeric numeric::power(const numeric &other) const { - // Efficiency shortcut: trap the neutral exponent by pointer. - static const numeric * _num1p = &_num1(); - if (&other==_num1p) + // Shortcut for efficiency and numeric stability (as in 1.0 exponent): + // trap the neutral exponent. + if (&other==_num1_p || cln::equal(cln::the(other.value),cln::the(_num1.value))) return *this; if (cln::zerop(cln::the(value))) { @@ -738,61 +764,93 @@ const numeric numeric::power(const numeric & other) const else if (cln::minusp(cln::realpart(cln::the(other.value)))) throw std::overflow_error("numeric::eval(): division by zero"); else - return _num0(); + return _num0; } return numeric(cln::expt(cln::the(value),cln::the(other.value))); } -const numeric & numeric::add_dyn(const numeric & other) const + +/** Numerical addition method. Adds argument to *this and returns result as + * a numeric object on the heap. Use internally only for direct wrapping into + * an ex object, where the result would end up on the heap anyways. */ +const numeric &numeric::add_dyn(const numeric &other) const { - // Efficiency shortcut: trap the neutral element by pointer. - static const numeric * _num0p = &_num0(); - if (this==_num0p) + // Efficiency shortcut: trap the neutral element by pointer. This hack + // is supposed to keep the number of distinct numeric objects low. + if (this==_num0_p) return other; - else if (&other==_num0p) + else if (&other==_num0_p) return *this; return static_cast((new numeric(cln::the(value)+cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + setflag(status_flags::dynallocated)); } -const numeric & numeric::sub_dyn(const numeric & other) const -{ +/** Numerical subtraction method. Subtracts argument from *this and returns + * result as a numeric object on the heap. Use internally only for direct + * wrapping into an ex object, where the result would end up on the heap + * anyways. */ +const numeric &numeric::sub_dyn(const numeric &other) const +{ + // Efficiency shortcut: trap the neutral exponent (first by pointer). This + // hack is supposed to keep the number of distinct numeric objects low. + if (&other==_num0_p || cln::zerop(cln::the(other.value))) + return *this; + return static_cast((new numeric(cln::the(value)-cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + setflag(status_flags::dynallocated)); } -const numeric & numeric::mul_dyn(const numeric & other) const -{ - // Efficiency shortcut: trap the neutral element by pointer. - static const numeric * _num1p = &_num1(); - if (this==_num1p) +/** Numerical multiplication method. Multiplies *this and argument and returns + * result as a numeric object on the heap. Use internally only for direct + * wrapping into an ex object, where the result would end up on the heap + * anyways. */ +const numeric &numeric::mul_dyn(const numeric &other) const +{ + // Efficiency shortcut: trap the neutral element by pointer. This hack + // is supposed to keep the number of distinct numeric objects low. + if (this==_num1_p) return other; - else if (&other==_num1p) + else if (&other==_num1_p) return *this; return static_cast((new numeric(cln::the(value)*cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + setflag(status_flags::dynallocated)); } -const numeric & numeric::div_dyn(const numeric & other) const +/** Numerical division method. Divides *this by argument and returns result as + * a numeric object on the heap. Use internally only for direct wrapping + * into an ex object, where the result would end up on the heap + * anyways. + * + * @exception overflow_error (division by zero) */ +const numeric &numeric::div_dyn(const numeric &other) const { + // Efficiency shortcut: trap the neutral element by pointer. This hack + // is supposed to keep the number of distinct numeric objects low. + if (&other==_num1_p) + return *this; if (cln::zerop(cln::the(other.value))) throw std::overflow_error("division by zero"); return static_cast((new numeric(cln::the(value)/cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + setflag(status_flags::dynallocated)); } -const numeric & numeric::power_dyn(const numeric & other) const +/** Numerical exponentiation. Raises *this to the power given as argument and + * returns result as a numeric object on the heap. Use internally only for + * direct wrapping into an ex object, where the result would end up on the + * heap anyways. */ +const numeric &numeric::power_dyn(const numeric &other) const { - // Efficiency shortcut: trap the neutral exponent by pointer. - static const numeric * _num1p=&_num1(); - if (&other==_num1p) + // Efficiency shortcut: trap the neutral exponent (first try by pointer, then + // try harder, since calls to cln::expt() below may return amazing results for + // floating point exponent 1.0). + if (&other==_num1_p || cln::equal(cln::the(other.value),cln::the(_num1.value))) return *this; if (cln::zerop(cln::the(value))) { @@ -803,51 +861,51 @@ const numeric & numeric::power_dyn(const numeric & other) const else if (cln::minusp(cln::realpart(cln::the(other.value)))) throw std::overflow_error("numeric::eval(): division by zero"); else - return _num0(); + return _num0; } return static_cast((new numeric(cln::expt(cln::the(value),cln::the(other.value))))-> setflag(status_flags::dynallocated)); } -const numeric & numeric::operator=(int i) +const numeric &numeric::operator=(int i) { return operator=(numeric(i)); } -const numeric & numeric::operator=(unsigned int i) +const numeric &numeric::operator=(unsigned int i) { return operator=(numeric(i)); } -const numeric & numeric::operator=(long i) +const numeric &numeric::operator=(long i) { return operator=(numeric(i)); } -const numeric & numeric::operator=(unsigned long i) +const numeric &numeric::operator=(unsigned long i) { return operator=(numeric(i)); } -const numeric & numeric::operator=(double d) +const numeric &numeric::operator=(double d) { return operator=(numeric(d)); } -const numeric & numeric::operator=(const char * s) +const numeric &numeric::operator=(const char * s) { return operator=(numeric(s)); } /** Inverse of a number. */ -const numeric numeric::inverse(void) const +const numeric numeric::inverse() const { if (cln::zerop(cln::the(value))) throw std::overflow_error("numeric::inverse(): division by zero"); @@ -859,8 +917,8 @@ const numeric numeric::inverse(void) const * csgn(x)==0 for x==0, csgn(x)==1 for Re(x)>0 or Re(x)=0 and Im(x)>0, * csgn(x)==-1 for Re(x)<0 or Re(x)=0 and Im(x)<0. * - * @see numeric::compare(const numeric & other) */ -int numeric::csgn(void) const + * @see numeric::compare(const numeric &other) */ +int numeric::csgn() const { if (cln::zerop(cln::the(value))) return 0; @@ -885,8 +943,8 @@ int numeric::csgn(void) const * to be compatible with our method csgn. * * @return csgn(*this-other) - * @see numeric::csgn(void) */ -int numeric::compare(const numeric & other) const + * @see numeric::csgn() */ +int numeric::compare(const numeric &other) const { // Comparing two real numbers? if (cln::instanceof(value, cln::cl_R_ring) && @@ -904,111 +962,113 @@ int numeric::compare(const numeric & other) const } -bool numeric::is_equal(const numeric & other) const +bool numeric::is_equal(const numeric &other) const { return cln::equal(cln::the(value),cln::the(other.value)); } /** True if object is zero. */ -bool numeric::is_zero(void) const +bool numeric::is_zero() const { return cln::zerop(cln::the(value)); } /** True if object is not complex and greater than zero. */ -bool numeric::is_positive(void) const +bool numeric::is_positive() const { - if (this->is_real()) + if (cln::instanceof(value, cln::cl_R_ring)) // real? return cln::plusp(cln::the(value)); return false; } /** True if object is not complex and less than zero. */ -bool numeric::is_negative(void) const +bool numeric::is_negative() const { - if (this->is_real()) + if (cln::instanceof(value, cln::cl_R_ring)) // real? return cln::minusp(cln::the(value)); return false; } /** True if object is a non-complex integer. */ -bool numeric::is_integer(void) const +bool numeric::is_integer() const { return cln::instanceof(value, cln::cl_I_ring); } /** True if object is an exact integer greater than zero. */ -bool numeric::is_pos_integer(void) const +bool numeric::is_pos_integer() const { - return (this->is_integer() && cln::plusp(cln::the(value))); + return (cln::instanceof(value, cln::cl_I_ring) && cln::plusp(cln::the(value))); } /** True if object is an exact integer greater or equal zero. */ -bool numeric::is_nonneg_integer(void) const +bool numeric::is_nonneg_integer() const { - return (this->is_integer() && !cln::minusp(cln::the(value))); + return (cln::instanceof(value, cln::cl_I_ring) && !cln::minusp(cln::the(value))); } /** True if object is an exact even integer. */ -bool numeric::is_even(void) const +bool numeric::is_even() const { - return (this->is_integer() && cln::evenp(cln::the(value))); + return (cln::instanceof(value, cln::cl_I_ring) && cln::evenp(cln::the(value))); } /** True if object is an exact odd integer. */ -bool numeric::is_odd(void) const +bool numeric::is_odd() const { - return (this->is_integer() && cln::oddp(cln::the(value))); + return (cln::instanceof(value, cln::cl_I_ring) && cln::oddp(cln::the(value))); } /** Probabilistic primality test. * * @return true if object is exact integer and prime. */ -bool numeric::is_prime(void) const +bool numeric::is_prime() const { - return (this->is_integer() && cln::isprobprime(cln::the(value))); + return (cln::instanceof(value, cln::cl_I_ring) // integer? + && cln::plusp(cln::the(value)) // positive? + && cln::isprobprime(cln::the(value))); } /** True if object is an exact rational number, may even be complex * (denominator may be unity). */ -bool numeric::is_rational(void) const +bool numeric::is_rational() const { return cln::instanceof(value, cln::cl_RA_ring); } /** True if object is a real integer, rational or float (but not complex). */ -bool numeric::is_real(void) const +bool numeric::is_real() const { return cln::instanceof(value, cln::cl_R_ring); } -bool numeric::operator==(const numeric & other) const +bool numeric::operator==(const numeric &other) const { - return equal(cln::the(value), cln::the(other.value)); + return cln::equal(cln::the(value), cln::the(other.value)); } -bool numeric::operator!=(const numeric & other) const +bool numeric::operator!=(const numeric &other) const { - return !equal(cln::the(value), cln::the(other.value)); + return !cln::equal(cln::the(value), cln::the(other.value)); } /** True if object is element of the domain of integers extended by I, i.e. is * of the form a+b*I, where a and b are integers. */ -bool numeric::is_cinteger(void) const +bool numeric::is_cinteger() const { if (cln::instanceof(value, cln::cl_I_ring)) return true; @@ -1023,7 +1083,7 @@ bool numeric::is_cinteger(void) const /** True if object is an exact rational number, may even be complex * (denominator may be unity). */ -bool numeric::is_crational(void) const +bool numeric::is_crational() const { if (cln::instanceof(value, cln::cl_RA_ring)) return true; @@ -1039,7 +1099,7 @@ bool numeric::is_crational(void) const /** Numerical comparison: less. * * @exception invalid_argument (complex inequality) */ -bool numeric::operator<(const numeric & other) const +bool numeric::operator<(const numeric &other) const { if (this->is_real() && other.is_real()) return (cln::the(value) < cln::the(other.value)); @@ -1050,7 +1110,7 @@ bool numeric::operator<(const numeric & other) const /** Numerical comparison: less or equal. * * @exception invalid_argument (complex inequality) */ -bool numeric::operator<=(const numeric & other) const +bool numeric::operator<=(const numeric &other) const { if (this->is_real() && other.is_real()) return (cln::the(value) <= cln::the(other.value)); @@ -1061,7 +1121,7 @@ bool numeric::operator<=(const numeric & other) const /** Numerical comparison: greater. * * @exception invalid_argument (complex inequality) */ -bool numeric::operator>(const numeric & other) const +bool numeric::operator>(const numeric &other) const { if (this->is_real() && other.is_real()) return (cln::the(value) > cln::the(other.value)); @@ -1072,7 +1132,7 @@ bool numeric::operator>(const numeric & other) const /** Numerical comparison: greater or equal. * * @exception invalid_argument (complex inequality) */ -bool numeric::operator>=(const numeric & other) const +bool numeric::operator>=(const numeric &other) const { if (this->is_real() && other.is_real()) return (cln::the(value) >= cln::the(other.value)); @@ -1083,7 +1143,7 @@ bool numeric::operator>=(const numeric & other) const /** Converts numeric types to machine's int. You should check with * is_integer() if the number is really an integer before calling this method. * You may also consider checking the range first. */ -int numeric::to_int(void) const +int numeric::to_int() const { GINAC_ASSERT(this->is_integer()); return cln::cl_I_to_int(cln::the(value)); @@ -1093,7 +1153,7 @@ int numeric::to_int(void) const /** Converts numeric types to machine's long. You should check with * is_integer() if the number is really an integer before calling this method. * You may also consider checking the range first. */ -long numeric::to_long(void) const +long numeric::to_long() const { GINAC_ASSERT(this->is_integer()); return cln::cl_I_to_long(cln::the(value)); @@ -1102,7 +1162,7 @@ long numeric::to_long(void) const /** Converts numeric types to machine's double. You should check with is_real() * if the number is really not complex before calling this method. */ -double numeric::to_double(void) const +double numeric::to_double() const { GINAC_ASSERT(this->is_real()); return cln::double_approx(cln::realpart(cln::the(value))); @@ -1112,21 +1172,21 @@ double numeric::to_double(void) const /** Returns a new CLN object of type cl_N, representing the value of *this. * This method may be used when mixing GiNaC and CLN in one project. */ -cln::cl_N numeric::to_cl_N(void) const +cln::cl_N numeric::to_cl_N() const { return cln::cl_N(cln::the(value)); } /** Real part of a number. */ -const numeric numeric::real(void) const +const numeric numeric::real() const { return numeric(cln::realpart(cln::the(value))); } /** Imaginary part of a number. */ -const numeric numeric::imag(void) const +const numeric numeric::imag() const { return numeric(cln::imagpart(cln::the(value))); } @@ -1136,10 +1196,10 @@ const numeric numeric::imag(void) const * numerator of complex if real and imaginary part are both rational numbers * (i.e numer(4/3+5/6*I) == 8+5*I), the number carrying the sign in all other * cases. */ -const numeric numeric::numer(void) const +const numeric numeric::numer() const { - if (this->is_integer()) - return numeric(*this); + if (cln::instanceof(value, cln::cl_I_ring)) + return numeric(*this); // integer case else if (cln::instanceof(value, cln::cl_RA_ring)) return numeric(cln::numerator(cln::the(value))); @@ -1167,19 +1227,19 @@ const numeric numeric::numer(void) const /** Denominator. Computes the denominator of rational numbers, common integer * denominator of complex if real and imaginary part are both rational numbers * (i.e denom(4/3+5/6*I) == 6), one in all other cases. */ -const numeric numeric::denom(void) const +const numeric numeric::denom() const { - if (this->is_integer()) - return _num1(); + if (cln::instanceof(value, cln::cl_I_ring)) + return _num1; // integer case - if (instanceof(value, cln::cl_RA_ring)) + if (cln::instanceof(value, cln::cl_RA_ring)) return numeric(cln::denominator(cln::the(value))); if (!this->is_real()) { // complex case, handle Q(i): const cln::cl_RA r = cln::the(cln::realpart(cln::the(value))); const cln::cl_RA i = cln::the(cln::imagpart(cln::the(value))); if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_I_ring)) - return _num1(); + return _num1; if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_RA_ring)) return numeric(cln::denominator(i)); if (cln::instanceof(r, cln::cl_RA_ring) && cln::instanceof(i, cln::cl_I_ring)) @@ -1188,7 +1248,7 @@ const numeric numeric::denom(void) const return numeric(cln::lcm(cln::denominator(r), cln::denominator(i))); } // at least one float encountered - return _num1(); + return _num1; } @@ -1198,36 +1258,28 @@ const numeric numeric::denom(void) const * * @return number of bits (excluding sign) needed to represent that number * in two's complement if it is an integer, 0 otherwise. */ -int numeric::int_length(void) const +int numeric::int_length() const { - if (this->is_integer()) + if (cln::instanceof(value, cln::cl_I_ring)) return cln::integer_length(cln::the(value)); else return 0; } - -////////// -// static member variables -////////// - -// protected - -unsigned numeric::precedence = 30; - ////////// // global constants ////////// /** Imaginary unit. This is not a constant but a numeric since we are - * natively handing complex numbers anyways. */ + * natively handing complex numbers anyways, so in each expression containing + * an I it is automatically eval'ed away anyhow. */ const numeric I = numeric(cln::complex(cln::cl_I(0),cln::cl_I(1))); /** Exponential function. * * @return arbitrary precision numerical exp(x). */ -const numeric exp(const numeric & x) +const numeric exp(const numeric &x) { return cln::exp(x.to_cl_N()); } @@ -1235,21 +1287,21 @@ const numeric exp(const numeric & x) /** Natural logarithm. * - * @param z complex number + * @param x complex number * @return arbitrary precision numerical log(x). * @exception pole_error("log(): logarithmic pole",0) */ -const numeric log(const numeric & z) +const numeric log(const numeric &x) { - if (z.is_zero()) + if (x.is_zero()) throw pole_error("log(): logarithmic pole",0); - return cln::log(z.to_cl_N()); + return cln::log(x.to_cl_N()); } /** Numeric sine (trigonometric function). * * @return arbitrary precision numerical sin(x). */ -const numeric sin(const numeric & x) +const numeric sin(const numeric &x) { return cln::sin(x.to_cl_N()); } @@ -1258,7 +1310,7 @@ const numeric sin(const numeric & x) /** Numeric cosine (trigonometric function). * * @return arbitrary precision numerical cos(x). */ -const numeric cos(const numeric & x) +const numeric cos(const numeric &x) { return cln::cos(x.to_cl_N()); } @@ -1267,7 +1319,7 @@ const numeric cos(const numeric & x) /** Numeric tangent (trigonometric function). * * @return arbitrary precision numerical tan(x). */ -const numeric tan(const numeric & x) +const numeric tan(const numeric &x) { return cln::tan(x.to_cl_N()); } @@ -1276,7 +1328,7 @@ const numeric tan(const numeric & x) /** Numeric inverse sine (trigonometric function). * * @return arbitrary precision numerical asin(x). */ -const numeric asin(const numeric & x) +const numeric asin(const numeric &x) { return cln::asin(x.to_cl_N()); } @@ -1285,7 +1337,7 @@ const numeric asin(const numeric & x) /** Numeric inverse cosine (trigonometric function). * * @return arbitrary precision numerical acos(x). */ -const numeric acos(const numeric & x) +const numeric acos(const numeric &x) { return cln::acos(x.to_cl_N()); } @@ -1293,14 +1345,14 @@ const numeric acos(const numeric & x) /** Arcustangent. * - * @param z complex number - * @return atan(z) + * @param x complex number + * @return atan(x) * @exception pole_error("atan(): logarithmic pole",0) */ -const numeric atan(const numeric & x) +const numeric atan(const numeric &x) { if (!x.is_real() && x.real().is_zero() && - abs(x.imag()).is_equal(_num1())) + abs(x.imag()).is_equal(_num1)) throw pole_error("atan(): logarithmic pole",0); return cln::atan(x.to_cl_N()); } @@ -1311,7 +1363,7 @@ const numeric atan(const numeric & x) * @param x real number * @param y real number * @return atan(y/x) */ -const numeric atan(const numeric & y, const numeric & x) +const numeric atan(const numeric &y, const numeric &x) { if (x.is_real() && y.is_real()) return cln::atan(cln::the(x.to_cl_N()), @@ -1324,7 +1376,7 @@ const numeric atan(const numeric & y, const numeric & x) /** Numeric hyperbolic sine (trigonometric function). * * @return arbitrary precision numerical sinh(x). */ -const numeric sinh(const numeric & x) +const numeric sinh(const numeric &x) { return cln::sinh(x.to_cl_N()); } @@ -1333,7 +1385,7 @@ const numeric sinh(const numeric & x) /** Numeric hyperbolic cosine (trigonometric function). * * @return arbitrary precision numerical cosh(x). */ -const numeric cosh(const numeric & x) +const numeric cosh(const numeric &x) { return cln::cosh(x.to_cl_N()); } @@ -1342,7 +1394,7 @@ const numeric cosh(const numeric & x) /** Numeric hyperbolic tangent (trigonometric function). * * @return arbitrary precision numerical tanh(x). */ -const numeric tanh(const numeric & x) +const numeric tanh(const numeric &x) { return cln::tanh(x.to_cl_N()); } @@ -1351,7 +1403,7 @@ const numeric tanh(const numeric & x) /** Numeric inverse hyperbolic sine (trigonometric function). * * @return arbitrary precision numerical asinh(x). */ -const numeric asinh(const numeric & x) +const numeric asinh(const numeric &x) { return cln::asinh(x.to_cl_N()); } @@ -1360,7 +1412,7 @@ const numeric asinh(const numeric & x) /** Numeric inverse hyperbolic cosine (trigonometric function). * * @return arbitrary precision numerical acosh(x). */ -const numeric acosh(const numeric & x) +const numeric acosh(const numeric &x) { return cln::acosh(x.to_cl_N()); } @@ -1369,14 +1421,14 @@ const numeric acosh(const numeric & x) /** Numeric inverse hyperbolic tangent (trigonometric function). * * @return arbitrary precision numerical atanh(x). */ -const numeric atanh(const numeric & x) +const numeric atanh(const numeric &x) { return cln::atanh(x.to_cl_N()); } -/*static cln::cl_N Li2_series(const ::cl_N & x, - const ::float_format_t & prec) +/*static cln::cl_N Li2_series(const ::cl_N &x, + const ::float_format_t &prec) { // Note: argument must be in the unit circle // This is very inefficient unless we have fast floating point Bernoulli @@ -1403,8 +1455,8 @@ const numeric atanh(const numeric & x) /** Numeric evaluation of Dilogarithm within circle of convergence (unit * circle) using a power series. */ -static cln::cl_N Li2_series(const cln::cl_N & x, - const cln::float_format_t & prec) +static cln::cl_N Li2_series(const cln::cl_N &x, + const cln::float_format_t &prec) { // Note: argument must be in the unit circle cln::cl_N aug, acc; @@ -1422,8 +1474,8 @@ static cln::cl_N Li2_series(const cln::cl_N & x, } /** Folds Li2's argument inside a small rectangle to enhance convergence. */ -static cln::cl_N Li2_projection(const cln::cl_N & x, - const cln::float_format_t & prec) +static cln::cl_N Li2_projection(const cln::cl_N &x, + const cln::float_format_t &prec) { const cln::cl_R re = cln::realpart(x); const cln::cl_R im = cln::imagpart(x); @@ -1448,10 +1500,10 @@ static cln::cl_N Li2_projection(const cln::cl_N & x, * continuous with quadrant IV. * * @return arbitrary precision numerical Li2(x). */ -const numeric Li2(const numeric & x) +const numeric Li2(const numeric &x) { if (x.is_zero()) - return _num0(); + return _num0; // what is the desired float format? // first guess: default format @@ -1478,7 +1530,7 @@ const numeric Li2(const numeric & x) /** Numeric evaluation of Riemann's Zeta function. Currently works only for * integer arguments. */ -const numeric zeta(const numeric & x) +const numeric zeta(const numeric &x) { // A dirty hack to allow for things like zeta(3.0), since CLN currently // only knows about integer arguments and zeta(3).evalf() automatically @@ -1490,50 +1542,35 @@ const numeric zeta(const numeric & x) if (cln::zerop(x.to_cl_N()-aux)) return cln::zeta(aux); } - std::clog << "zeta(" << x - << "): Does anybody know good way to calculate this numerically?" - << std::endl; - return numeric(0); + throw dunno(); } /** The Gamma function. * This is only a stub! */ -const numeric lgamma(const numeric & x) +const numeric lgamma(const numeric &x) { - std::clog << "lgamma(" << x - << "): Does anybody know good way to calculate this numerically?" - << std::endl; - return numeric(0); + throw dunno(); } -const numeric tgamma(const numeric & x) +const numeric tgamma(const numeric &x) { - std::clog << "tgamma(" << x - << "): Does anybody know good way to calculate this numerically?" - << std::endl; - return numeric(0); + throw dunno(); } /** The psi function (aka polygamma function). * This is only a stub! */ -const numeric psi(const numeric & x) +const numeric psi(const numeric &x) { - std::clog << "psi(" << x - << "): Does anybody know good way to calculate this numerically?" - << std::endl; - return numeric(0); + throw dunno(); } /** The psi functions (aka polygamma functions). * This is only a stub! */ -const numeric psi(const numeric & n, const numeric & x) +const numeric psi(const numeric &n, const numeric &x) { - std::clog << "psi(" << n << "," << x - << "): Does anybody know good way to calculate this numerically?" - << std::endl; - return numeric(0); + throw dunno(); } @@ -1541,7 +1578,7 @@ const numeric psi(const numeric & n, const numeric & x) * * @param n integer argument >= 0 * @exception range_error (argument must be integer >= 0) */ -const numeric factorial(const numeric & n) +const numeric factorial(const numeric &n) { if (!n.is_nonneg_integer()) throw std::range_error("numeric::factorial(): argument must be integer >= 0"); @@ -1555,10 +1592,10 @@ const numeric factorial(const numeric & n) * @param n integer argument >= -1 * @return n!! == n * (n-2) * (n-4) * ... * ({1|2}) with 0!! == (-1)!! == 1 * @exception range_error (argument must be integer >= -1) */ -const numeric doublefactorial(const numeric & n) +const numeric doublefactorial(const numeric &n) { - if (n == numeric(-1)) - return _num1(); + if (n.is_equal(_num_1)) + return _num1; if (!n.is_nonneg_integer()) throw std::range_error("numeric::doublefactorial(): argument must be integer >= -1"); @@ -1571,16 +1608,16 @@ const numeric doublefactorial(const numeric & n) * integer n and k and positive n this is the number of ways of choosing k * objects from n distinct objects. If n is negative, the formula * binomial(n,k) == (-1)^k*binomial(k-n-1,k) is used to compute the result. */ -const numeric binomial(const numeric & n, const numeric & k) +const numeric binomial(const numeric &n, const numeric &k) { if (n.is_integer() && k.is_integer()) { if (n.is_nonneg_integer()) { - if (k.compare(n)!=1 && k.compare(_num0())!=-1) + if (k.compare(n)!=1 && k.compare(_num0)!=-1) return numeric(cln::binomial(n.to_int(),k.to_int())); else - return _num0(); + return _num0; } else { - return _num_1().power(k)*binomial(k-n-_num1(),k); + return _num_1.power(k)*binomial(k-n-_num1,k); } } @@ -1594,11 +1631,11 @@ const numeric binomial(const numeric & n, const numeric & k) * * @return the nth Bernoulli number (a rational number). * @exception range_error (argument must be integer >= 0) */ -const numeric bernoulli(const numeric & nn) +const numeric bernoulli(const numeric &nn) { if (!nn.is_integer() || nn.is_negative()) throw std::range_error("numeric::bernoulli(): argument must be integer >= 0"); - + // Method: // // The Bernoulli numbers are rational numbers that may be computed using @@ -1622,46 +1659,61 @@ const numeric bernoulli(const numeric & nn) // But if somebody works with the n'th Bernoulli number she is likely to // also need all previous Bernoulli numbers. So we need a complete remember // table and above divide and conquer algorithm is not suited to build one - // up. The code below is adapted from Pari's function bernvec(). + // up. The formula below accomplishes this. It is a modification of the + // defining formula above but the computation of the binomial coefficients + // is carried along in an inline fashion. It also honors the fact that + // B_n is zero when n is odd and greater than 1. // // (There is an interesting relation with the tangent polynomials described - // in `Concrete Mathematics', which leads to a program twice as fast as our - // implementation below, but it requires storing one such polynomial in + // in `Concrete Mathematics', which leads to a program a little faster as + // our implementation below, but it requires storing one such polynomial in // addition to the remember table. This doubles the memory footprint so // we don't use it.) - + + const unsigned n = nn.to_int(); + // the special cases not covered by the algorithm below - if (nn.is_equal(_num1())) - return _num_1_2(); - if (nn.is_odd()) - return _num0(); - + if (n & 1) + return (n==1) ? _num_1_2 : _num0; + if (!n) + return _num1; + // store nonvanishing Bernoulli numbers here static std::vector< cln::cl_RA > results; - static int highest_result = 0; - // algorithm not applicable to B(0), so just store it - if (results.size()==0) - results.push_back(cln::cl_RA(1)); - - int n = nn.to_long(); - for (int i=highest_result; i0; --j) { - B = cln::cl_I(n*m) * (B+results[j]) / (d1*d2); - n += 4; - m += 2; - d1 -= 1; - d2 -= 2; - } - B = (1 - ((B+1)/(2*i+3))) / (cln::cl_I(1)<<(2*i+2)); - results.push_back(B); - ++highest_result; + static unsigned next_r = 0; + + // algorithm not applicable to B(2), so just store it + if (!next_r) { + results.push_back(cln::recip(cln::cl_RA(6))); + next_r = 4; } - return results[n/2]; + if (n) + if (p < (1UL<(a.to_cl_N()), cln::the(b.to_cl_N())); else - return _num0(); + return _num0; } @@ -1752,14 +1804,14 @@ const numeric mod(const numeric & a, const numeric & b) * Equivalent to Maple's mods. * * @return a mod b in the range [-iquo(abs(m)-1,2), iquo(abs(m),2)]. */ -const numeric smod(const numeric & a, const numeric & b) +const numeric smod(const numeric &a, const numeric &b) { if (a.is_integer() && b.is_integer()) { const cln::cl_I b2 = cln::ceiling1(cln::the(b.to_cl_N()) >> 1) - 1; return cln::mod(cln::the(a.to_cl_N()) + b2, cln::the(b.to_cl_N())) - b2; } else - return _num0(); + return _num0; } @@ -1768,34 +1820,40 @@ const numeric smod(const numeric & a, const numeric & b) * In general, mod(a,b) has the sign of b or is zero, and irem(a,b) has the * sign of a or is zero. * - * @return remainder of a/b if both are integer, 0 otherwise. */ -const numeric irem(const numeric & a, const numeric & b) + * @return remainder of a/b if both are integer, 0 otherwise. + * @exception overflow_error (division by zero) if b is zero. */ +const numeric irem(const numeric &a, const numeric &b) { + if (b.is_zero()) + throw std::overflow_error("numeric::irem(): division by zero"); if (a.is_integer() && b.is_integer()) return cln::rem(cln::the(a.to_cl_N()), cln::the(b.to_cl_N())); else - return _num0(); + return _num0; } /** Numeric integer remainder. * Equivalent to Maple's irem(a,b,'q') it obeyes the relation * irem(a,b,q) == a - q*b. In general, mod(a,b) has the sign of b or is zero, - * and irem(a,b) has the sign of a or is zero. + * and irem(a,b) has the sign of a or is zero. * * @return remainder of a/b and quotient stored in q if both are integer, - * 0 otherwise. */ -const numeric irem(const numeric & a, const numeric & b, numeric & q) + * 0 otherwise. + * @exception overflow_error (division by zero) if b is zero. */ +const numeric irem(const numeric &a, const numeric &b, numeric &q) { + if (b.is_zero()) + throw std::overflow_error("numeric::irem(): division by zero"); if (a.is_integer() && b.is_integer()) { const cln::cl_I_div_t rem_quo = cln::truncate2(cln::the(a.to_cl_N()), cln::the(b.to_cl_N())); q = rem_quo.quotient; return rem_quo.remainder; } else { - q = _num0(); - return _num0(); + q = _num0; + return _num0; } } @@ -1803,14 +1861,17 @@ const numeric irem(const numeric & a, const numeric & b, numeric & q) /** Numeric integer quotient. * Equivalent to Maple's iquo as far as sign conventions are concerned. * - * @return truncated quotient of a/b if both are integer, 0 otherwise. */ -const numeric iquo(const numeric & a, const numeric & b) + * @return truncated quotient of a/b if both are integer, 0 otherwise. + * @exception overflow_error (division by zero) if b is zero. */ +const numeric iquo(const numeric &a, const numeric &b) { + if (b.is_zero()) + throw std::overflow_error("numeric::iquo(): division by zero"); if (a.is_integer() && b.is_integer()) - return truncate1(cln::the(a.to_cl_N()), - cln::the(b.to_cl_N())); + return cln::truncate1(cln::the(a.to_cl_N()), + cln::the(b.to_cl_N())); else - return _num0(); + return _num0; } @@ -1819,17 +1880,20 @@ const numeric iquo(const numeric & a, const numeric & b) * r == a - iquo(a,b,r)*b. * * @return truncated quotient of a/b and remainder stored in r if both are - * integer, 0 otherwise. */ -const numeric iquo(const numeric & a, const numeric & b, numeric & r) + * integer, 0 otherwise. + * @exception overflow_error (division by zero) if b is zero. */ +const numeric iquo(const numeric &a, const numeric &b, numeric &r) { + if (b.is_zero()) + throw std::overflow_error("numeric::iquo(): division by zero"); if (a.is_integer() && b.is_integer()) { const cln::cl_I_div_t rem_quo = cln::truncate2(cln::the(a.to_cl_N()), cln::the(b.to_cl_N())); r = rem_quo.remainder; return rem_quo.quotient; } else { - r = _num0(); - return _num0(); + r = _num0; + return _num0; } } @@ -1838,13 +1902,13 @@ const numeric iquo(const numeric & a, const numeric & b, numeric & r) * * @return The GCD of two numbers if both are integer, a numerical 1 * if they are not. */ -const numeric gcd(const numeric & a, const numeric & b) +const numeric gcd(const numeric &a, const numeric &b) { if (a.is_integer() && b.is_integer()) return cln::gcd(cln::the(a.to_cl_N()), cln::the(b.to_cl_N())); else - return _num1(); + return _num1; } @@ -1852,7 +1916,7 @@ const numeric gcd(const numeric & a, const numeric & b) * * @return The LCM of two numbers if both are integer, the product of those * two numbers if they are not. */ -const numeric lcm(const numeric & a, const numeric & b) +const numeric lcm(const numeric &a, const numeric &b) { if (a.is_integer() && b.is_integer()) return cln::lcm(cln::the(a.to_cl_N()), @@ -1863,59 +1927,61 @@ const numeric lcm(const numeric & a, const numeric & b) /** Numeric square root. - * If possible, sqrt(z) should respect squares of exact numbers, i.e. sqrt(4) + * If possible, sqrt(x) should respect squares of exact numbers, i.e. sqrt(4) * should return integer 2. * - * @param z numeric argument - * @return square root of z. Branch cut along negative real axis, the negative - * real axis itself where imag(z)==0 and real(z)<0 belongs to the upper part - * where imag(z)>0. */ -const numeric sqrt(const numeric & z) + * @param x numeric argument + * @return square root of x. Branch cut along negative real axis, the negative + * real axis itself where imag(x)==0 and real(x)<0 belongs to the upper part + * where imag(x)>0. */ +const numeric sqrt(const numeric &x) { - return cln::sqrt(z.to_cl_N()); + return cln::sqrt(x.to_cl_N()); } /** Integer numeric square root. */ -const numeric isqrt(const numeric & x) +const numeric isqrt(const numeric &x) { if (x.is_integer()) { cln::cl_I root; cln::isqrt(cln::the(x.to_cl_N()), &root); return root; } else - return _num0(); + return _num0; } /** Floating point evaluation of Archimedes' constant Pi. */ -ex PiEvalf(void) +ex PiEvalf() { return numeric(cln::pi(cln::default_float_format)); } /** Floating point evaluation of Euler's constant gamma. */ -ex EulerEvalf(void) +ex EulerEvalf() { return numeric(cln::eulerconst(cln::default_float_format)); } /** Floating point evaluation of Catalan's constant. */ -ex CatalanEvalf(void) +ex CatalanEvalf() { return numeric(cln::catalanconst(cln::default_float_format)); } +/** _numeric_digits default ctor, checking for singleton invariance. */ _numeric_digits::_numeric_digits() : digits(17) { // It initializes to 17 digits, because in CLN float_format(17) turns out // to be 61 (<64) while float_format(18)=65. The reason is we want to // have a cl_LF instead of cl_SF, cl_FF or cl_DF. - assert(!too_late); + if (too_late) + throw(std::runtime_error("I told you not to do instantiate me!")); too_late = true; cln::default_float_format = cln::float_format(17); } @@ -1939,14 +2005,13 @@ _numeric_digits::operator long() /** Append global Digits object to ostream. */ -void _numeric_digits::print(std::ostream & os) const +void _numeric_digits::print(std::ostream &os) const { - debugmsg("_numeric_digits print", LOGLEVEL_PRINT); os << digits; } -std::ostream& operator<<(std::ostream& os, const _numeric_digits & e) +std::ostream& operator<<(std::ostream &os, const _numeric_digits &e) { e.print(os); return os; @@ -1965,6 +2030,4 @@ bool _numeric_digits::too_late = false; * assignment from C++ unsigned ints and evaluated like any built-in type. */ _numeric_digits Digits; -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC