X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Fnumeric.cpp;h=1d4de9f5b416d4e997f6d590f0c96ef7edb57e4c;hb=e98841136efa88c951edafc0cd43ba1343f20b5b;hp=96543bb05e52272097a048b308b38d511b49521b;hpb=cfea748404dec5fb2f2e3310d36eeb6640f13824;p=ginac.git diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp index 96543bb0..1d4de9f5 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 @@ -30,10 +30,12 @@ #include #include #include +#include #include "numeric.h" #include "ex.h" #include "print.h" +#include "operators.h" #include "archive.h" #include "tostring.h" #include "utils.h" @@ -90,13 +92,13 @@ numeric::numeric(int i) : basic(TINFO_numeric) { // 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); + value = cln::cl_I(static_cast(i)); setflag(status_flags::evaluated | status_flags::expanded); } @@ -105,13 +107,13 @@ numeric::numeric(unsigned int i) : basic(TINFO_numeric) { // 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); + value = cln::cl_I(static_cast(i)); setflag(status_flags::evaluated | status_flags::expanded); } @@ -129,7 +131,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) @@ -159,35 +162,43 @@ numeric::numeric(const char *s) : basic(TINFO_numeric) // 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 @@ -198,7 +209,7 @@ 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"); @@ -210,13 +221,13 @@ numeric::numeric(const char *s) : basic(TINFO_numeric) 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; setflag(status_flags::evaluated | status_flags::expanded); } @@ -234,7 +245,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; @@ -305,7 +316,7 @@ DEFAULT_UNARCHIVE(numeric) * want to visibly distinguish from cl_LF. * * @see numeric::print() */ -static void print_real_number(const print_context & c, const cln::cl_R &x) +static void print_real_number(const print_context & c, const cln::cl_R & x) { cln::cl_print_flags ourflags; if (cln::instanceof(x, cln::cl_RA_ring)) { @@ -314,8 +325,10 @@ static void print_real_number(const print_context & c, const cln::cl_R &x) !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::numerator(cln::the(x))); + 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 << '}'; @@ -329,6 +342,82 @@ static void print_real_number(const print_context & c, const cln::cl_R &x) } } +/** 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) +{ + // 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 << "\")"; + } +} + /** This method adds to the output so it blends more consistently together * with the other routines and produces something compatible to ginsh input. * @@ -342,45 +431,71 @@ void numeric::print(const print_context & c, unsigned level) const << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec << std::endl; + } else if (is_a(c)) { + + // CLN output + 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 << ")"; + } + } else if (is_a(c)) { + // C++ source output std::ios::fmtflags oldflags = c.s.flags(); c.s.setf(std::ios::scientific); - if (this->is_rational() && !this->is_integer()) { - if (compare(_num0) > 0) { - c.s << "("; - if (is_a(c)) - c.s << "cln::cl_F(\"" << numer().evalf() << "\")"; - else - c.s << numer().to_double(); - } else { - c.s << "-("; - if (is_a(c)) - c.s << "cln::cl_F(\"" << -numer().evalf() << "\")"; - else - c.s << -numer().to_double(); - } - c.s << "/"; - if (is_a(c)) - c.s << "cln::cl_F(\"" << denom().evalf() << "\")"; - else - c.s << denom().to_double(); - c.s << ")"; + 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 (is_a(c)) - c.s << "cln::cl_F(\"" << evalf() << "\")"; + + // Complex number + c.s << "std::complex<"; + if (is_a(c)) + c.s << "double>("; else - c.s << 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); } 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())) { @@ -393,25 +508,19 @@ void numeric::print(const print_context & c, unsigned level) const } else { if (cln::zerop(r)) { // case 2, imaginary: y*I or -y*I - if ((precedence() <= level) && (i < 0)) { - if (i == -1) { - c.s << par_open+imag_sym+par_close; - } else { + if (i==1) + c.s << imag_sym; + else { + if (precedence()<=level) c.s << par_open; + if (i == -1) + c.s << "-" << imag_sym; + else { print_real_number(c, i); - c.s << mul_sym+imag_sym+par_close; - } - } else { - if (i == 1) { - c.s << imag_sym; - } else { - if (i == -1) { - c.s << "-" << imag_sym; - } else { - print_real_number(c, i); - c.s << mul_sym+imag_sym; - } + c.s << mul_sym+imag_sym; } + if (precedence()<=level) + c.s << par_close; } } else { // case 3, complex: x+y*I or x-y*I or -x+y*I or -x-y*I @@ -438,6 +547,8 @@ void numeric::print(const print_context & c, unsigned level) const c.s << par_close; } } + if (is_a(c)) + c.s << "')"; } } @@ -486,6 +597,21 @@ bool numeric::info(unsigned inf) const return false; } +int numeric::degree(const ex & s) const +{ + return 0; +} + +int numeric::ldegree(const ex & s) const +{ + return 0; +} + +ex numeric::coeff(const ex & s, int n) const +{ + return n==0 ? *this : _ex0; +} + /** Disassemble real part and imaginary part to scan for the occurrence of a * single number. Also handles the imaginary unit. It ignores the sign on * both this and the argument, which may lead to what might appear as funny @@ -494,7 +620,7 @@ bool numeric::info(unsigned inf) 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)) @@ -558,11 +684,13 @@ bool numeric::is_equal_same_type(const basic &other) const unsigned numeric::calchash(void) 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(cln::the(value))); + return hashvalue; } @@ -630,8 +758,9 @@ 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(cln::the(other.value),cln::the(_num1.value))) return *this; if (cln::zerop(cln::the(value))) { @@ -648,26 +777,39 @@ const numeric numeric::power(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. + // 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)); + 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)); + 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. @@ -677,23 +819,35 @@ const numeric &numeric::mul_dyn(const numeric &other) const return *this; return static_cast((new numeric(cln::the(value)*cln::the(other.value)))-> - setflag(status_flags::dynallocated)); + 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 { 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)); } +/** 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(cln::the(other.value),cln::the(_num1.value))) return *this; if (cln::zerop(cln::the(value))) { @@ -821,7 +975,7 @@ bool numeric::is_zero(void) const /** True if object is not complex and greater than zero. */ bool numeric::is_positive(void) const { - if (this->is_real()) + if (cln::instanceof(value, cln::cl_R_ring)) // real? return cln::plusp(cln::the(value)); return false; } @@ -830,7 +984,7 @@ bool numeric::is_positive(void) const /** True if object is not complex and less than zero. */ bool numeric::is_negative(void) const { - if (this->is_real()) + if (cln::instanceof(value, cln::cl_R_ring)) // real? return cln::minusp(cln::the(value)); return false; } @@ -846,28 +1000,28 @@ bool numeric::is_integer(void) const /** True if object is an exact integer greater than zero. */ bool numeric::is_pos_integer(void) 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 { - 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 { - 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 { - return (this->is_integer() && cln::oddp(cln::the(value))); + return (cln::instanceof(value, cln::cl_I_ring) && cln::oddp(cln::the(value))); } @@ -876,7 +1030,9 @@ bool numeric::is_odd(void) const * @return true if object is exact integer and prime. */ bool numeric::is_prime(void) 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))); } @@ -1039,8 +1195,8 @@ const numeric numeric::imag(void) const * cases. */ const numeric numeric::numer(void) 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))); @@ -1070,8 +1226,8 @@ const numeric numeric::numer(void) const * (i.e denom(4/3+5/6*I) == 6), one in all other cases. */ const numeric numeric::denom(void) 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))); @@ -1101,7 +1257,7 @@ const numeric numeric::denom(void) const * in two's complement if it is an integer, 0 otherwise. */ int numeric::int_length(void) const { - if (this->is_integer()) + if (cln::instanceof(value, cln::cl_I_ring)) return cln::integer_length(cln::the(value)); else return 0; @@ -1476,7 +1632,7 @@ 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 @@ -1500,46 +1656,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.empty()) - 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; + } + if (n) + if (p < (1UL<(a.to_cl_N()), cln::the(b.to_cl_N())); @@ -1660,12 +1834,15 @@ 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. */ + * 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())); @@ -1681,9 +1858,12 @@ 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. */ + * @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 cln::truncate1(cln::the(a.to_cl_N()), cln::the(b.to_cl_N())); @@ -1697,9 +1877,12 @@ 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. */ + * 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()));