X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fnumeric.cpp;h=59d61ab4320a877c2cc49e631849c6a7e6ac7935;hp=e1156f061eb6409b017b9d19eed761999a413b12;hb=0633ed8082961673eedc092689e06fa39d6bc322;hpb=a8617f6e1705e980b7a5f6500f6a2c42563d3f6c diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp index e1156f06..59d61ab4 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-2003 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2005 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 @@ -21,7 +21,7 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" @@ -34,7 +34,7 @@ #include "numeric.h" #include "ex.h" -#include "print.h" +#include "operators.h" #include "archive.h" #include "tostring.h" #include "utils.h" @@ -60,10 +60,16 @@ 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 ctor, dtor, copy ctor, assignment operator and helpers +// default constructor ////////// /** default ctor. Numerically it initializes to an integer zero. */ @@ -73,16 +79,8 @@ numeric::numeric() : basic(TINFO_numeric) setflag(status_flags::evaluated | status_flags::expanded); } -void numeric::copy(const numeric &other) -{ - inherited::copy(other); - value = other.value; -} - -DEFAULT_DESTROY(numeric) - ////////// -// other ctors +// other constructors ////////// // public @@ -94,10 +92,10 @@ numeric::numeric(int i) : basic(TINFO_numeric) // emphasizes efficiency. However, if the integer is small enough // we save space and dereferences by using an immediate type. // (C.f. ) - if (i < (1U<= -(1L << (cl_value_len-1))) value = cln::cl_I(i); else - value = cln::cl_I((long) i); + value = cln::cl_I(static_cast(i)); setflag(status_flags::evaluated | status_flags::expanded); } @@ -109,10 +107,10 @@ numeric::numeric(unsigned int i) : basic(TINFO_numeric) // emphasizes efficiency. However, if the integer is small enough // we save space and dereferences by using an immediate type. // (C.f. ) - if (i < (1U<(i)); setflag(status_flags::evaluated | status_flags::expanded); } @@ -130,7 +128,8 @@ numeric::numeric(unsigned long i) : basic(TINFO_numeric) 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) @@ -243,7 +242,7 @@ numeric::numeric(const cln::cl_N &z) : basic(TINFO_numeric) // archiving ////////// -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) { cln::cl_N ctorval = 0; @@ -282,7 +281,7 @@ void numeric::archive(archive_node &n) const // Write number as string std::ostringstream s; if (this->is_crational()) - s << cln::the(value); + s << value; else { // Non-rational numbers are written in an integer-decoded format // to preserve the precision @@ -416,140 +415,148 @@ static void print_real_cl_N(const print_context & c, const cln::cl_R & x) } } -/** 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(const print_context & c, unsigned level) const +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 { - if (is_a(c)) { + const cln::cl_R r = cln::realpart(value); + const cln::cl_R i = cln::imagpart(value); - c.s << std::string(level, ' ') << cln::the(value) - << " (" << class_name() << ")" - << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec - << std::endl; + if (cln::zerop(i)) { - } else if (is_a(c)) { + // case 1, real: x or -x + if ((precedence() <= level) && (!this->is_nonneg_integer())) { + c.s << par_open; + print_real_number(c, r); + c.s << par_close; + } else { + print_real_number(c, r); + } - // CLN output - if (this->is_real()) { + } else { + if (cln::zerop(r)) { - // Real number - print_real_cl_N(c, cln::the(value)); + // case 2, imaginary: y*I or -y*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 { - // 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 << ")"; + // case 3, complex: x+y*I or x-y*I or -x+y*I or -x-y*I + if (precedence() <= level) + c.s << par_open; + print_real_number(c, r); + if (i < 0) { + if (i == -1) { + c.s << "-" << imag_sym; + } else { + print_real_number(c, i); + c.s << mul_sym << imag_sym; + } + } else { + if (i == 1) { + c.s << "+" << imag_sym; + } else { + c.s << "+"; + print_real_number(c, i); + c.s << mul_sym << imag_sym; + } + } + if (precedence() <= level) + c.s << par_close; } + } +} + +void numeric::do_print(const print_context & c, unsigned level) const +{ + print_numeric(c, "(", ")", "I", "*", level); +} - } else if (is_a(c)) { +void numeric::do_print_latex(const print_latex & c, unsigned level) const +{ + print_numeric(c, "{(", ")}", "i", " ", level); +} - // C++ source output - std::ios::fmtflags oldflags = c.s.flags(); - c.s.setf(std::ios::scientific); - int oldprec = c.s.precision(); +void numeric::do_print_csrc(const print_csrc & c, unsigned level) const +{ + 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); + // 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()) { + if (this->is_real()) { - // Real number - print_real_csrc(c, cln::the(value)); + // Real number + print_real_csrc(c, cln::the(value)); - } else { + } else { - // Complex number - c.s << "std::complex<"; - if (is_a(c)) - c.s << "double>("; - else - c.s << "float>("; + // Complex number + c.s << "std::complex<"; + if (is_a(c)) + c.s << "double>("; + else + 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 << ")"; - } + print_real_csrc(c, cln::realpart(value)); + c.s << ","; + print_real_csrc(c, cln::imagpart(value)); + c.s << ")"; + } - c.s.flags(oldflags); - c.s.precision(oldprec); + 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 { - const std::string par_open = is_a(c) ? "{(" : "("; - const std::string par_close = is_a(c) ? ")}" : ")"; - const std::string imag_sym = is_a(c) ? "i" : "I"; - const std::string mul_sym = is_a(c) ? " " : "*"; - const cln::cl_R r = cln::realpart(cln::the(value)); - const cln::cl_R i = cln::imagpart(cln::the(value)); - - if (is_a(c)) - c.s << class_name() << "('"; - if (cln::zerop(i)) { - // case 1, real: x or -x - if ((precedence() <= level) && (!this->is_nonneg_integer())) { - c.s << par_open; - print_real_number(c, r); - c.s << par_close; - } else { - print_real_number(c, r); - } - } else { - if (cln::zerop(r)) { - // case 2, imaginary: y*I or -y*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() <= level) - c.s << par_open; - print_real_number(c, r); - if (i < 0) { - if (i == -1) { - c.s << "-"+imag_sym; - } else { - print_real_number(c, i); - c.s << mul_sym+imag_sym; - } - } else { - if (i == 1) { - c.s << "+"+imag_sym; - } else { - c.s << "+"; - print_real_number(c, i); - c.s << mul_sym+imag_sym; - } - } - if (precedence() <= level) - c.s << par_close; - } - } - if (is_a(c)) - c.s << "')"; + // Complex number + c.s << "cln::complex("; + print_real_cl_N(c, cln::realpart(value)); + c.s << ","; + print_real_cl_N(c, cln::imagpart(value)); + c.s << ")"; } } +void numeric::do_print_tree(const print_tree & c, unsigned level) const +{ + c.s << std::string(level, ' ') << 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 { switch (inf) { @@ -618,7 +625,7 @@ ex numeric::coeff(const ex & s, int n) const * sign as a multiplicative factor. */ bool numeric::has(const ex &other) const { - if (!is_ex_exactly_of_type(other, numeric)) + if (!is_exactly_a(other)) return false; const numeric &o = ex_to(other); if (this->is_equal(o) || this->is_equal(-o)) @@ -656,8 +663,15 @@ ex numeric::eval(int level) const 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))); + return numeric(cln::cl_float(1.0, cln::default_float_format) * value); +} + +ex numeric::conjugate() const +{ + if (is_real()) { + return *this; + } + return numeric(cln::conjugate(this->value)); } // protected @@ -680,13 +694,15 @@ bool numeric::is_equal_same_type(const basic &other) const } -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. + // 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); - return (hashvalue = cln::equal_hashcode(cln::the(value)) | 0x80000000U); + hashvalue = golden_ratio_hash(cln::equal_hashcode(value)); + return hashvalue; } @@ -706,13 +722,7 @@ unsigned numeric::calchash(void) const * a numeric object. */ const numeric numeric::add(const numeric &other) const { - // Efficiency shortcut: trap the neutral element by pointer. - if (this==_num0_p) - return other; - else if (&other==_num0_p) - return *this; - - return numeric(cln::the(value)+cln::the(other.value)); + return numeric(value + other.value); } @@ -720,7 +730,7 @@ const numeric numeric::add(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)); + return numeric(value - other.value); } @@ -728,13 +738,7 @@ const numeric numeric::sub(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. - if (this==_num1_p) - return other; - else if (&other==_num1_p) - return *this; - - return numeric(cln::the(value)*cln::the(other.value)); + return numeric(value * other.value); } @@ -744,9 +748,9 @@ const numeric numeric::mul(const numeric &other) const * @exception overflow_error (division by zero) */ const numeric numeric::div(const numeric &other) const { - if (cln::zerop(cln::the(other.value))) + if (cln::zerop(other.value)) throw std::overflow_error("numeric::div(): division by zero"); - return numeric(cln::the(value)/cln::the(other.value)); + return numeric(value / other.value); } @@ -754,83 +758,119 @@ const numeric numeric::div(const numeric &other) const * returns result as a numeric object. */ const numeric numeric::power(const numeric &other) const { - // Efficiency shortcut: trap the neutral exponent by pointer. - if (&other==_num1_p) + // Shortcut for efficiency and numeric stability (as in 1.0 exponent): + // trap the neutral exponent. + if (&other==_num1_p || cln::equal(other.value,_num1.value)) return *this; - if (cln::zerop(cln::the(value))) { - if (cln::zerop(cln::the(other.value))) + if (cln::zerop(value)) { + if (cln::zerop(other.value)) throw std::domain_error("numeric::eval(): pow(0,0) is undefined"); - else if (cln::zerop(cln::realpart(cln::the(other.value)))) + else if (cln::zerop(cln::realpart(other.value))) throw std::domain_error("numeric::eval(): pow(0,I) is undefined"); - else if (cln::minusp(cln::realpart(cln::the(other.value)))) + else if (cln::minusp(cln::realpart(other.value))) throw std::overflow_error("numeric::eval(): division by zero"); else return _num0; } - return numeric(cln::expt(cln::the(value),cln::the(other.value))); + return numeric(cln::expt(value, other.value)); } + +/** 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. + // 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==_num0_p) return *this; - return static_cast((new numeric(cln::the(value)+cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + return static_cast((new numeric(value + other.value))-> + setflag(status_flags::dynallocated)); } +/** 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 { - return static_cast((new numeric(cln::the(value)-cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + // 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(other.value)) + return *this; + + return static_cast((new numeric(value - other.value))-> + setflag(status_flags::dynallocated)); } +/** 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. + // 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==_num1_p) return *this; - return static_cast((new numeric(cln::the(value)*cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + return static_cast((new numeric(value * other.value))-> + setflag(status_flags::dynallocated)); } +/** 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)); + return static_cast((new numeric(value / other.value))-> + setflag(status_flags::dynallocated)); } +/** 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. - if (&other==_num1_p) + // 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(other.value, _num1.value)) return *this; - if (cln::zerop(cln::the(value))) { - if (cln::zerop(cln::the(other.value))) + if (cln::zerop(value)) { + if (cln::zerop(other.value)) throw std::domain_error("numeric::eval(): pow(0,0) is undefined"); - else if (cln::zerop(cln::realpart(cln::the(other.value)))) + else if (cln::zerop(cln::realpart(other.value))) throw std::domain_error("numeric::eval(): pow(0,I) is undefined"); - else if (cln::minusp(cln::realpart(cln::the(other.value)))) + else if (cln::minusp(cln::realpart(other.value))) throw std::overflow_error("numeric::eval(): division by zero"); else return _num0; } - return static_cast((new numeric(cln::expt(cln::the(value),cln::the(other.value))))-> + return static_cast((new numeric(cln::expt(value, other.value)))-> setflag(status_flags::dynallocated)); } @@ -872,11 +912,11 @@ const numeric &numeric::operator=(const char * s) /** Inverse of a number. */ -const numeric numeric::inverse(void) const +const numeric numeric::inverse() const { - if (cln::zerop(cln::the(value))) + if (cln::zerop(value)) throw std::overflow_error("numeric::inverse(): division by zero"); - return numeric(cln::recip(cln::the(value))); + return numeric(cln::recip(value)); } @@ -885,18 +925,18 @@ const numeric numeric::inverse(void) const * 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 +int numeric::csgn() const { - if (cln::zerop(cln::the(value))) + if (cln::zerop(value)) return 0; - cln::cl_R r = cln::realpart(cln::the(value)); + cln::cl_R r = cln::realpart(value); if (!cln::zerop(r)) { if (cln::plusp(r)) return 1; else return -1; } else { - if (cln::plusp(cln::imagpart(cln::the(value)))) + if (cln::plusp(cln::imagpart(value))) return 1; else return -1; @@ -910,7 +950,7 @@ int numeric::csgn(void) const * to be compatible with our method csgn. * * @return csgn(*this-other) - * @see numeric::csgn(void) */ + * @see numeric::csgn() */ int numeric::compare(const numeric &other) const { // Comparing two real numbers? @@ -920,100 +960,102 @@ int numeric::compare(const numeric &other) const return cln::compare(cln::the(value), cln::the(other.value)); else { // No, first cln::compare real parts... - cl_signean real_cmp = cln::compare(cln::realpart(cln::the(value)), cln::realpart(cln::the(other.value))); + cl_signean real_cmp = cln::compare(cln::realpart(value), cln::realpart(other.value)); if (real_cmp) return real_cmp; // ...and then the imaginary parts. - return cln::compare(cln::imagpart(cln::the(value)), cln::imagpart(cln::the(other.value))); + return cln::compare(cln::imagpart(value), cln::imagpart(other.value)); } } bool numeric::is_equal(const numeric &other) const { - return cln::equal(cln::the(value),cln::the(other.value)); + return cln::equal(value, other.value); } /** True if object is zero. */ -bool numeric::is_zero(void) const +bool numeric::is_zero() const { - return cln::zerop(cln::the(value)); + return cln::zerop(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); } @@ -1021,25 +1063,25 @@ bool numeric::is_real(void) const bool numeric::operator==(const numeric &other) const { - return cln::equal(cln::the(value), cln::the(other.value)); + return cln::equal(value, other.value); } bool numeric::operator!=(const numeric &other) const { - return !cln::equal(cln::the(value), cln::the(other.value)); + return !cln::equal(value, 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; else if (!this->is_real()) { // complex case, handle n+m*I - if (cln::instanceof(cln::realpart(cln::the(value)), cln::cl_I_ring) && - cln::instanceof(cln::imagpart(cln::the(value)), cln::cl_I_ring)) + if (cln::instanceof(cln::realpart(value), cln::cl_I_ring) && + cln::instanceof(cln::imagpart(value), cln::cl_I_ring)) return true; } return false; @@ -1048,13 +1090,13 @@ 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; else if (!this->is_real()) { // complex case, handle Q(i): - if (cln::instanceof(cln::realpart(cln::the(value)), cln::cl_RA_ring) && - cln::instanceof(cln::imagpart(cln::the(value)), cln::cl_RA_ring)) + if (cln::instanceof(cln::realpart(value), cln::cl_RA_ring) && + cln::instanceof(cln::imagpart(value), cln::cl_RA_ring)) return true; } return false; @@ -1108,7 +1150,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)); @@ -1118,7 +1160,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)); @@ -1127,33 +1169,33 @@ 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))); + return cln::double_approx(cln::realpart(value)); } /** 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)); + return value; } /** Real part of a number. */ -const numeric numeric::real(void) const +const numeric numeric::real() const { - return numeric(cln::realpart(cln::the(value))); + return numeric(cln::realpart(value)); } /** Imaginary part of a number. */ -const numeric numeric::imag(void) const +const numeric numeric::imag() const { - return numeric(cln::imagpart(cln::the(value))); + return numeric(cln::imagpart(value)); } @@ -1161,17 +1203,17 @@ 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))); else 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))); + const cln::cl_RA r = cln::the(cln::realpart(value)); + const cln::cl_RA i = cln::the(cln::imagpart(value)); if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_I_ring)) return numeric(*this); if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_RA_ring)) @@ -1192,17 +1234,17 @@ 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 (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))); + const cln::cl_RA r = cln::the(cln::realpart(value)); + const cln::cl_RA i = cln::the(cln::imagpart(value)); if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_I_ring)) return _num1; if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_RA_ring)) @@ -1223,9 +1265,9 @@ 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; @@ -1252,14 +1294,14 @@ 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()); } @@ -1310,8 +1352,8 @@ 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) { @@ -1480,7 +1522,7 @@ const numeric Li2(const numeric &x) else if (!x.imag().is_rational()) prec = cln::float_format(cln::the(cln::imagpart(value))); - if (cln::the(value)==1) // may cause trouble with log(1-x) + if (value==1) // may cause trouble with log(1-x) return cln::zeta(2, prec); if (cln::abs(value) > 1) @@ -1586,8 +1628,8 @@ const numeric binomial(const numeric &n, const numeric &k) } } - // should really be gamma(n+1)/gamma(r+1)/gamma(n-r+1) or a suitable limit - throw std::range_error("numeric::binomial(): don´t know how to evaluate that."); + // should really be gamma(n+1)/gamma(k+1)/gamma(n-k+1) or a suitable limit + throw std::range_error("numeric::binomial(): don't know how to evaluate that."); } @@ -1641,7 +1683,7 @@ const numeric bernoulli(const numeric &nn) if (n & 1) return (n==1) ? _num_1_2 : _num0; if (!n) - return _num1; + return _num1; // store nonvanishing Bernoulli numbers here static std::vector< cln::cl_RA > results; @@ -1768,7 +1810,7 @@ const numeric mod(const numeric &a, const numeric &b) /** Modulus (in symmetric representation). * Equivalent to Maple's mods. * - * @return a mod b in the range [-iquo(abs(m)-1,2), iquo(abs(m),2)]. */ + * @return a mod b in the range [-iquo(abs(b)-1,2), iquo(abs(b),2)]. */ const numeric smod(const numeric &a, const numeric &b) { if (a.is_integer() && b.is_integer()) { @@ -1802,7 +1844,7 @@ const numeric irem(const numeric &a, const numeric &b) /** 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. @@ -1892,16 +1934,16 @@ 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()); } @@ -1918,21 +1960,21 @@ const numeric isqrt(const numeric &x) /** 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)); }