X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fnumeric.cpp;h=582bfdcfb5be19229c56e7239217c3a3c0ff93b0;hp=545d87428ed59ee9836db929fcd36ef5317e84c4;hb=a9909685b1ea5014a81a2d2e5963203637bdb3ce;hpb=dbd9c306a74f1cb258c0d15a346b973b39deaad2

diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp
index 545d8742..582bfdcf 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-2006 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"
@@ -30,10 +30,11 @@
 #include <stdexcept>
 #include <string>
 #include <sstream>
+#include <limits>
 
 #include "numeric.h"
 #include "ex.h"
-#include "print.h"
+#include "operators.h"
 #include "archive.h"
 #include "tostring.h"
 #include "utils.h"
@@ -59,80 +60,91 @@
 
 namespace GiNaC {
 
-GINAC_IMPLEMENT_REGISTERED_CLASS(numeric, basic)
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(numeric, basic,
+  print_func<print_context>(&numeric::do_print).
+  print_func<print_latex>(&numeric::do_print_latex).
+  print_func<print_csrc>(&numeric::do_print_csrc).
+  print_func<print_csrc_cl_N>(&numeric::do_print_csrc_cl_N).
+  print_func<print_tree>(&numeric::do_print_tree).
+  print_func<print_python_repr>(&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. */
-numeric::numeric() : basic(TINFO_numeric)
+numeric::numeric() : basic(&numeric::tinfo_static)
 {
 	value = cln::cl_I(0);
 	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
 
-numeric::numeric(int i) : basic(TINFO_numeric)
+numeric::numeric(int i) : basic(&numeric::tinfo_static)
 {
 	// 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
 	// we save space and dereferences by using an immediate type.
 	// (C.f. <cln/object.h>)
-	if (i < (1U<<cl_value_len-1))
+	// The #if clause prevents compiler warnings on 64bit machines where the
+	// comparision is always true.
+#if cl_value_len >= 32
+	value = cln::cl_I(i);
+#else
+	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<long>(i));
+#endif
 	setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 
-numeric::numeric(unsigned int i) : basic(TINFO_numeric)
+numeric::numeric(unsigned int i) : basic(&numeric::tinfo_static)
 {
 	// 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
 	// we save space and dereferences by using an immediate type.
 	// (C.f. <cln/object.h>)
-	if (i < (1U<<cl_value_len-1))
+	// The #if clause prevents compiler warnings on 64bit machines where the
+	// comparision is always true.
+#if cl_value_len >= 32
+	value = cln::cl_I(i);
+#else
+	if (i < (1UL << (cl_value_len-1)))
 		value = cln::cl_I(i);
 	else
-		value = cln::cl_I((unsigned long) i);
+		value = cln::cl_I(static_cast<unsigned long>(i));
+#endif
 	setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 
-numeric::numeric(long i) : basic(TINFO_numeric)
+numeric::numeric(long i) : basic(&numeric::tinfo_static)
 {
 	value = cln::cl_I(i);
 	setflag(status_flags::evaluated | status_flags::expanded);
 }
 
 
-numeric::numeric(unsigned long i) : basic(TINFO_numeric)
+numeric::numeric(unsigned long i) : basic(&numeric::tinfo_static)
 {
 	value = cln::cl_I(i);
 	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)
+numeric::numeric(long numer, long denom) : basic(&numeric::tinfo_static)
 {
 	if (!denom)
 		throw std::overflow_error("division by zero");
@@ -141,7 +153,7 @@ numeric::numeric(long numer, long denom) : basic(TINFO_numeric)
 }
 
 
-numeric::numeric(double d) : basic(TINFO_numeric)
+numeric::numeric(double d) : basic(&numeric::tinfo_static)
 {
 	// 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
@@ -153,7 +165,7 @@ numeric::numeric(double d) : basic(TINFO_numeric)
 
 /** 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)
+numeric::numeric(const char *s) : basic(&numeric::tinfo_static)
 {
 	cln::cl_N ctorval = 0;
 	// parse complex numbers (functional but not completely safe, unfortunately
@@ -232,17 +244,18 @@ numeric::numeric(const char *s) : basic(TINFO_numeric)
 
 /** 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(&numeric::tinfo_static)
 {
 	value = z;
 	setflag(status_flags::evaluated | status_flags::expanded);
 }
 
+
 //////////
 // 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;
 
@@ -281,7 +294,7 @@ void numeric::archive(archive_node &n) const
 	// Write number as string
 	std::ostringstream s;
 	if (this->is_crational())
-		s << cln::the<cln::cl_N>(value);
+		s << value;
 	else {
 		// Non-rational numbers are written in an integer-decoded format
 		// to preserve the precision
@@ -313,7 +326,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)) {
@@ -339,127 +352,224 @@ static void print_real_number(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
+/** 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)
 {
-	if (is_a<print_tree>(c)) {
+	// 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);
+}
 
-		c.s << std::string(level, ' ') << cln::the<cln::cl_N>(value)
-		    << " (" << class_name() << ")"
-		    << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
-		    << std::endl;
+/** 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)) {
 
-	} else if (is_a<print_csrc>(c)) {
+		// Integer number
+		print_integer_csrc(c, cln::the<cln::cl_I>(x));
 
-		std::ios::fmtflags oldflags = c.s.flags();
-		c.s.setf(std::ios::scientific);
-		int oldprec = c.s.precision();
-		if (is_a<print_csrc_double>(c))
-			c.s.precision(16);
-		else
-			c.s.precision(7);
-		if (is_a<print_csrc_cl_N>(c) && this->is_integer()) {
-			c.s << "cln::cl_I(\"";
-			const cln::cl_R r = cln::realpart(cln::the<cln::cl_N>(value));
-			print_real_number(c,r);
-			c.s << "\")";
-		} else if (this->is_rational() && !this->is_integer()) {
-			if (compare(_num0) > 0) {
-				c.s << "(";
-				if (is_a<print_csrc_cl_N>(c))
-					c.s << "cln::cl_F(\"" << numer().evalf() << "\")";
-				else
-					c.s << numer().to_double();
-			} else {
-				c.s << "-(";
-				if (is_a<print_csrc_cl_N>(c))
-					c.s << "cln::cl_F(\"" << -numer().evalf() << "\")";
-				else
-					c.s << -numer().to_double();
-			}
-			c.s << "/";
-			if (is_a<print_csrc_cl_N>(c))
-				c.s << "cln::cl_F(\"" << denom().evalf() << "\")";
-			else
-				c.s << denom().to_double();
-			c.s << ")";
+	} else if (cln::instanceof(x, cln::cl_RA_ring)) {
+
+		// Rational number
+		const cln::cl_I numer = cln::numerator(cln::the<cln::cl_RA>(x));
+		const cln::cl_I denom = cln::denominator(cln::the<cln::cl_RA>(x));
+		if (cln::plusp(x) > 0) {
+			c.s << "(";
+			print_integer_csrc(c, numer);
 		} else {
-			if (is_a<print_csrc_cl_N>(c))
-				c.s << "cln::cl_F(\"" << evalf() << "_" << Digits << "\")";
-			else
-				c.s << to_double();
+			c.s << "-(";
+			print_integer_csrc(c, -numer);
 		}
-		c.s.flags(oldflags);
-		c.s.precision(oldprec);
+		c.s << "/";
+		print_integer_csrc(c, denom);
+		c.s << ")";
 
 	} else {
-		const std::string par_open  = is_a<print_latex>(c) ? "{(" : "(";
-		const std::string par_close = is_a<print_latex>(c) ? ")}" : ")";
-		const std::string imag_sym  = is_a<print_latex>(c) ? "i" : "I";
-		const std::string mul_sym   = is_a<print_latex>(c) ? " " : "*";
-		const cln::cl_R r = cln::realpart(cln::the<cln::cl_N>(value));
-		const cln::cl_R i = cln::imagpart(cln::the<cln::cl_N>(value));
-		if (is_a<print_python_repr>(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);
-			}
+
+		// 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<cln::cl_RA>(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(value);
+	const cln::cl_R i = cln::imagpart(value);
+
+	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 {
-			if (cln::zerop(r)) {
-				// case 2, imaginary:  y*I  or  -y*I
-				if (i==1)
-					c.s << imag_sym;
+			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 {
-					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;
+					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 {
-				// 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;
-					}
+				if (i == 1) {
+					c.s << "+" << imag_sym;
 				} else {
-					if (i == 1) {
-						c.s << "+"+imag_sym;
-					} else {
-						c.s << "+";
-						print_real_number(c, i);
-						c.s << mul_sym+imag_sym;
-					}
+					c.s << "+";
+					print_real_number(c, i);
+					c.s << mul_sym << imag_sym;
 				}
-				if (precedence() <= level)
-					c.s << par_close;
 			}
+			if (precedence() <= level)
+				c.s << par_close;
 		}
-		if (is_a<print_python_repr>(c))
-			c.s << "')";
 	}
 }
 
+void numeric::do_print(const print_context & c, unsigned level) const
+{
+	print_numeric(c, "(", ")", "I", "*", level);
+}
+
+void numeric::do_print_latex(const print_latex & c, unsigned level) const
+{
+	print_numeric(c, "{(", ")}", "i", " ", level);
+}
+
+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<print_csrc_double>(c))
+		c.s.precision(std::numeric_limits<double>::digits10 + 1);
+	else
+		c.s.precision(std::numeric_limits<float>::digits10 + 1);
+
+	if (this->is_real()) {
+
+		// Real number
+		print_real_csrc(c, cln::the<cln::cl_R>(value));
+
+	} else {
+
+		// Complex number
+		c.s << "std::complex<";
+		if (is_a<print_csrc_double>(c))
+			c.s << "double>(";
+		else
+			c.s << "float>(";
+
+		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);
+}
+
+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<cln::cl_R>(value));
+
+	} else {
+
+		// 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) {
@@ -505,6 +615,11 @@ bool numeric::info(unsigned inf) const
 	return false;
 }
 
+bool numeric::is_polynomial(const ex & var) const
+{
+	return true;
+}
+
 int numeric::degree(const ex & s) const
 {
 	return 0;
@@ -526,22 +641,29 @@ ex numeric::coeff(const ex & s, int n) const
  *  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, unsigned options) const
 {
-	if (!is_ex_exactly_of_type(other, numeric))
+	if (!is_exactly_a<numeric>(other))
 		return false;
 	const numeric &o = ex_to<numeric>(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
-		return (this->real().is_equal(o) || this->imag().is_equal(o) ||
-		        this->real().is_equal(-o) || this->imag().is_equal(-o));
+	if (o.imag().is_zero()) {   // e.g. scan for 3 in -3*I
+		if (!this->real().is_equal(*_num0_p))
+			if (this->real().is_equal(o) || this->real().is_equal(-o))
+				return true;
+		if (!this->imag().is_equal(*_num0_p))
+			if (this->imag().is_equal(o) || this->imag().is_equal(-o))
+				return true;
+		return false;
+	}
 	else {
 		if (o.is_equal(I))  // e.g scan for I in 42*I
 			return !this->is_real();
 		if (o.real().is_zero())  // e.g. scan for 2*I in 2*I+1
-			return (this->real().has(o*I) || this->imag().has(o*I) ||
-			        this->real().has(-o*I) || this->imag().has(-o*I));
+			if (!this->imag().is_equal(*_num0_p))
+				if (this->imag().is_equal(o*I) || this->imag().is_equal(-o*I))
+					return true;
 	}
 	return false;
 }
@@ -566,8 +688,25 @@ 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<cln::cl_N>(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));
+}
+
+ex numeric::real_part() const
+{
+	return numeric(cln::realpart(value));
+}
+
+ex numeric::imag_part() const
+{
+	return numeric(cln::imagpart(value));
 }
 
 // protected
@@ -590,13 +729,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<cln::cl_N>(value)) | 0x80000000U);
+	hashvalue = golden_ratio_hash(cln::equal_hashcode(value));
+	return hashvalue;
 }
 
 
@@ -616,13 +757,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<cln::cl_N>(value)+cln::the<cln::cl_N>(other.value));
+	return numeric(value + other.value);
 }
 
 
@@ -630,7 +765,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<cln::cl_N>(value)-cln::the<cln::cl_N>(other.value));
+	return numeric(value - other.value);
 }
 
 
@@ -638,13 +773,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<cln::cl_N>(value)*cln::the<cln::cl_N>(other.value));
+	return numeric(value * other.value);
 }
 
 
@@ -654,9 +783,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<cln::cl_N>(other.value)))
+	if (cln::zerop(other.value))
 		throw std::overflow_error("numeric::div(): division by zero");
-	return numeric(cln::the<cln::cl_N>(value)/cln::the<cln::cl_N>(other.value));
+	return numeric(value / other.value);
 }
 
 
@@ -664,83 +793,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_p->value))
 		return *this;
 	
-	if (cln::zerop(cln::the<cln::cl_N>(value))) {
-		if (cln::zerop(cln::the<cln::cl_N>(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<cln::cl_N>(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<cln::cl_N>(other.value))))
+		else if (cln::minusp(cln::realpart(other.value)))
 			throw std::overflow_error("numeric::eval(): division by zero");
 		else
-			return _num0;
+			return *_num0_p;
 	}
-	return numeric(cln::expt(cln::the<cln::cl_N>(value),cln::the<cln::cl_N>(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<const numeric &>((new numeric(cln::the<cln::cl_N>(value)+cln::the<cln::cl_N>(other.value)))->
-										setflag(status_flags::dynallocated));
+	return static_cast<const numeric &>((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<const numeric &>((new numeric(cln::the<cln::cl_N>(value)-cln::the<cln::cl_N>(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<const numeric &>((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<const numeric &>((new numeric(cln::the<cln::cl_N>(value)*cln::the<cln::cl_N>(other.value)))->
-										setflag(status_flags::dynallocated));
+	return static_cast<const numeric &>((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<cln::cl_N>(other.value)))
 		throw std::overflow_error("division by zero");
-	return static_cast<const numeric &>((new numeric(cln::the<cln::cl_N>(value)/cln::the<cln::cl_N>(other.value)))->
-										setflag(status_flags::dynallocated));
+	return static_cast<const numeric &>((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_p->value))
 		return *this;
 	
-	if (cln::zerop(cln::the<cln::cl_N>(value))) {
-		if (cln::zerop(cln::the<cln::cl_N>(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<cln::cl_N>(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<cln::cl_N>(other.value))))
+		else if (cln::minusp(cln::realpart(other.value)))
 			throw std::overflow_error("numeric::eval(): division by zero");
 		else
-			return _num0;
+			return *_num0_p;
 	}
-	return static_cast<const numeric &>((new numeric(cln::expt(cln::the<cln::cl_N>(value),cln::the<cln::cl_N>(other.value))))->
+	return static_cast<const numeric &>((new numeric(cln::expt(value, other.value)))->
 	                                     setflag(status_flags::dynallocated));
 }
 
@@ -782,31 +947,43 @@ 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<cln::cl_N>(value)))
+	if (cln::zerop(value))
 		throw std::overflow_error("numeric::inverse(): division by zero");
-	return numeric(cln::recip(cln::the<cln::cl_N>(value)));
+	return numeric(cln::recip(value));
 }
 
+/** Return the step function of a numeric. The imaginary part of it is
+ *  ignored because the step function is generally considered real but
+ *  a numeric may develop a small imaginary part due to rounding errors.
+ */
+numeric numeric::step() const
+{	cln::cl_R r = cln::realpart(value);
+	if(cln::zerop(r))
+		return numeric(1,2);
+	if(cln::plusp(r))
+		return 1;
+	return 0;
+}
 
 /** Return the complex half-plane (left or right) in which the number lies.
  *  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
+int numeric::csgn() const
 {
-	if (cln::zerop(cln::the<cln::cl_N>(value)))
+	if (cln::zerop(value))
 		return 0;
-	cln::cl_R r = cln::realpart(cln::the<cln::cl_N>(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<cln::cl_N>(value))))
+		if (cln::plusp(cln::imagpart(value)))
 			return 1;
 		else
 			return -1;
@@ -820,7 +997,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?
@@ -830,100 +1007,102 @@ int numeric::compare(const numeric &other) const
 		return cln::compare(cln::the<cln::cl_R>(value), cln::the<cln::cl_R>(other.value));
 	else {
 		// No, first cln::compare real parts...
-		cl_signean real_cmp = cln::compare(cln::realpart(cln::the<cln::cl_N>(value)), cln::realpart(cln::the<cln::cl_N>(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<cln::cl_N>(value)), cln::imagpart(cln::the<cln::cl_N>(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<cln::cl_N>(value),cln::the<cln::cl_N>(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<cln::cl_N>(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<cln::cl_R>(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<cln::cl_R>(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<cln::cl_I>(value)));
+	return (cln::instanceof(value, cln::cl_I_ring) && cln::plusp(cln::the<cln::cl_I>(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<cln::cl_I>(value)));
+	return (cln::instanceof(value, cln::cl_I_ring) && !cln::minusp(cln::the<cln::cl_I>(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<cln::cl_I>(value)));
+	return (cln::instanceof(value, cln::cl_I_ring) && cln::evenp(cln::the<cln::cl_I>(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<cln::cl_I>(value)));
+	return (cln::instanceof(value, cln::cl_I_ring) && cln::oddp(cln::the<cln::cl_I>(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<cln::cl_I>(value)));
+	return (cln::instanceof(value, cln::cl_I_ring)  // integer?
+	     && cln::plusp(cln::the<cln::cl_I>(value))  // positive?
+	     && cln::isprobprime(cln::the<cln::cl_I>(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);
 }
@@ -931,25 +1110,25 @@ bool numeric::is_real(void) const
 
 bool numeric::operator==(const numeric &other) const
 {
-	return cln::equal(cln::the<cln::cl_N>(value), cln::the<cln::cl_N>(other.value));
+	return cln::equal(value, other.value);
 }
 
 
 bool numeric::operator!=(const numeric &other) const
 {
-	return !cln::equal(cln::the<cln::cl_N>(value), cln::the<cln::cl_N>(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<cln::cl_N>(value)), cln::cl_I_ring) &&
-		    cln::instanceof(cln::imagpart(cln::the<cln::cl_N>(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;
@@ -958,13 +1137,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<cln::cl_N>(value)), cln::cl_RA_ring) &&
-		    cln::instanceof(cln::imagpart(cln::the<cln::cl_N>(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;
@@ -1018,7 +1197,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<cln::cl_I>(value));
@@ -1028,7 +1207,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<cln::cl_I>(value));
@@ -1037,33 +1216,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<cln::cl_N>(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<cln::cl_N>(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<cln::cl_N>(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<cln::cl_N>(value)));
+	return numeric(cln::imagpart(value));
 }
 
 
@@ -1071,17 +1250,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<cln::cl_RA>(value)));
 	
 	else if (!this->is_real()) {  // complex case, handle Q(i):
-		const cln::cl_RA r = cln::the<cln::cl_RA>(cln::realpart(cln::the<cln::cl_N>(value)));
-		const cln::cl_RA i = cln::the<cln::cl_RA>(cln::imagpart(cln::the<cln::cl_N>(value)));
+		const cln::cl_RA r = cln::the<cln::cl_RA>(cln::realpart(value));
+		const cln::cl_RA i = cln::the<cln::cl_RA>(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))
@@ -1102,19 +1281,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_p;  // integer case
 	
 	if (cln::instanceof(value, cln::cl_RA_ring))
 		return numeric(cln::denominator(cln::the<cln::cl_RA>(value)));
 	
 	if (!this->is_real()) {  // complex case, handle Q(i):
-		const cln::cl_RA r = cln::the<cln::cl_RA>(cln::realpart(cln::the<cln::cl_N>(value)));
-		const cln::cl_RA i = cln::the<cln::cl_RA>(cln::imagpart(cln::the<cln::cl_N>(value)));
+		const cln::cl_RA r = cln::the<cln::cl_RA>(cln::realpart(value));
+		const cln::cl_RA i = cln::the<cln::cl_RA>(cln::imagpart(value));
 		if (cln::instanceof(r, cln::cl_I_ring) && cln::instanceof(i, cln::cl_I_ring))
-			return _num1;
+			return *_num1_p;
 		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))
@@ -1123,7 +1302,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_p;
 }
 
 
@@ -1133,9 +1312,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<cln::cl_I>(value));
 	else
 		return 0;
@@ -1162,14 +1341,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());
 }
 
 
@@ -1220,14 +1399,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)
 {
 	if (!x.is_real() &&
 	    x.real().is_zero() &&
-	    abs(x.imag()).is_equal(_num1))
+	    abs(x.imag()).is_equal(*_num1_p))
 		throw pole_error("atan(): logarithmic pole",0);
 	return cln::atan(x.to_cl_N());
 }
@@ -1378,7 +1557,7 @@ static cln::cl_N Li2_projection(const cln::cl_N &x,
 const numeric Li2(const numeric &x)
 {
 	if (x.is_zero())
-		return _num0;
+		return *_num0_p;
 	
 	// what is the desired float format?
 	// first guess: default format
@@ -1390,7 +1569,7 @@ const numeric Li2(const numeric &x)
 	else if (!x.imag().is_rational())
 		prec = cln::float_format(cln::the<cln::cl_F>(cln::imagpart(value)));
 	
-	if (cln::the<cln::cl_N>(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)
@@ -1469,8 +1648,8 @@ const numeric factorial(const numeric &n)
  *  @exception range_error (argument must be integer >= -1) */
 const numeric doublefactorial(const numeric &n)
 {
-	if (n.is_equal(_num_1))
-		return _num1;
+	if (n.is_equal(*_num_1_p))
+		return *_num1_p;
 	
 	if (!n.is_nonneg_integer())
 		throw std::range_error("numeric::doublefactorial(): argument must be integer >= -1");
@@ -1487,17 +1666,17 @@ 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_p)!=-1)
 				return numeric(cln::binomial(n.to_int(),k.to_int()));
 			else
-				return _num0;
+				return *_num0_p;
 		} else {
-			return _num_1.power(k)*binomial(k-n-_num1,k);
+			return _num_1_p->power(k)*binomial(k-n-(*_num1_p),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.");
 }
 
 
@@ -1549,9 +1728,9 @@ const numeric bernoulli(const numeric &nn)
 
 	// the special cases not covered by the algorithm below
 	if (n & 1)
-		return (n==1) ? _num_1_2 : _num0;
+		return (n==1) ? (*_num_1_2_p) : (*_num0_p);
 	if (!n)
-		 return _num1;
+		return *_num1_p;
 
 	// store nonvanishing Bernoulli numbers here
 	static std::vector< cln::cl_RA > results;
@@ -1568,20 +1747,20 @@ const numeric bernoulli(const numeric &nn)
 	results.reserve(n/2);
 	for (unsigned p=next_r; p<=n;  p+=2) {
 		cln::cl_I  c = 1;  // seed for binonmial coefficients
-		cln::cl_RA b = cln::cl_RA(1-p)/2;
-		const unsigned p3 = p+3;
-		const unsigned pm = p-2;
-		unsigned i, k, p_2;
-		// test if intermediate unsigned int can be represented by immediate
-		// objects by CLN (i.e. < 2^29 for 32 Bit machines, see <cln/object.h>)
+		cln::cl_RA b = cln::cl_RA(p-1)/-2;
+		// The CLN manual says: "The conversion from `unsigned int' works only
+		// if the argument is < 2^29" (This is for 32 Bit machines. More
+		// generally, cl_value_len is the limiting exponent of 2. We must make
+		// sure that no intermediates are created which exceed this value. The
+		// largest intermediate is (p+3-2*k)*(p/2-k+1) <= (p^2+p)/2.
 		if (p < (1UL<<cl_value_len/2)) {
-			for (i=2, k=1, p_2=p/2; i<=pm; i+=2, ++k, --p_2) {
-				c = cln::exquo(c * ((p3-i) * p_2), (i-1)*k);
+			for (unsigned k=1; k<=p/2-1; ++k) {
+				c = cln::exquo(c * ((p+3-2*k) * (p/2-k+1)), (2*k-1)*k);
 				b = b + c*results[k-1];
 			}
 		} else {
-			for (i=2, k=1, p_2=p/2; i<=pm; i+=2, ++k, --p_2) {
-				c = cln::exquo((c * (p3-i)) * p_2, cln::cl_I(i-1)*k);
+			for (unsigned k=1; k<=p/2-1; ++k) {
+				c = cln::exquo((c * (p+3-2*k)) * (p/2-k+1), cln::cl_I(2*k-1)*k);
 				b = b + c*results[k-1];
 			}
  		}
@@ -1619,7 +1798,7 @@ const numeric fibonacci(const numeric &n)
 	// hence
 	//      F(2n+2) = F(n+1)*(2*F(n) + F(n+1))
 	if (n.is_zero())
-		return _num0;
+		return *_num0_p;
 	if (n.is_negative())
 		if (n.is_even())
 			return -fibonacci(-n);
@@ -1671,14 +1850,14 @@ const numeric mod(const numeric &a, const numeric &b)
 		return cln::mod(cln::the<cln::cl_I>(a.to_cl_N()),
 		                cln::the<cln::cl_I>(b.to_cl_N()));
 	else
-		return _num0;
+		return *_num0_p;
 }
 
 
 /** 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()) {
@@ -1686,7 +1865,7 @@ const numeric smod(const numeric &a, const numeric &b)
 		return cln::mod(cln::the<cln::cl_I>(a.to_cl_N()) + b2,
 		                cln::the<cln::cl_I>(b.to_cl_N())) - b2;
 	} else
-		return _num0;
+		return *_num0_p;
 }
 
 
@@ -1705,14 +1884,14 @@ const numeric irem(const numeric &a, const numeric &b)
 		return cln::rem(cln::the<cln::cl_I>(a.to_cl_N()),
 		                cln::the<cln::cl_I>(b.to_cl_N()));
 	else
-		return _num0;
+		return *_num0_p;
 }
 
 
 /** 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.
@@ -1727,8 +1906,8 @@ const numeric irem(const numeric &a, const numeric &b, numeric &q)
 		q = rem_quo.quotient;
 		return rem_quo.remainder;
 	} else {
-		q = _num0;
-		return _num0;
+		q = *_num0_p;
+		return *_num0_p;
 	}
 }
 
@@ -1746,7 +1925,7 @@ const numeric iquo(const numeric &a, const numeric &b)
 		return cln::truncate1(cln::the<cln::cl_I>(a.to_cl_N()),
 	                          cln::the<cln::cl_I>(b.to_cl_N()));
 	else
-		return _num0;
+		return *_num0_p;
 }
 
 
@@ -1767,8 +1946,8 @@ const numeric iquo(const numeric &a, const numeric &b, numeric &r)
 		r = rem_quo.remainder;
 		return rem_quo.quotient;
 	} else {
-		r = _num0;
-		return _num0;
+		r = *_num0_p;
+		return *_num0_p;
 	}
 }
 
@@ -1783,7 +1962,7 @@ const numeric gcd(const numeric &a, const numeric &b)
 		return cln::gcd(cln::the<cln::cl_I>(a.to_cl_N()),
 		                cln::the<cln::cl_I>(b.to_cl_N()));
 	else
-		return _num1;
+		return *_num1_p;
 }
 
 
@@ -1802,16 +1981,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());
 }
 
 
@@ -1823,26 +2002,26 @@ const numeric isqrt(const numeric &x)
 		cln::isqrt(cln::the<cln::cl_I>(x.to_cl_N()), &root);
 		return root;
 	} else
-		return _num0;
+		return *_num0_p;
 }
 
 
 /** 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));
 }
@@ -1859,14 +2038,25 @@ _numeric_digits::_numeric_digits()
 		throw(std::runtime_error("I told you not to do instantiate me!"));
 	too_late = true;
 	cln::default_float_format = cln::float_format(17);
+
+	// add callbacks for built-in functions
+	// like ... add_callback(Li_lookuptable);
 }
 
 
 /** Assign a native long to global Digits object. */
 _numeric_digits& _numeric_digits::operator=(long prec)
 {
+	long digitsdiff = prec - digits;
 	digits = prec;
-	cln::default_float_format = cln::float_format(prec); 
+	cln::default_float_format = cln::float_format(prec);
+
+	// call registered callbacks
+	std::vector<digits_changed_callback>::const_iterator it = callbacklist.begin(),	end = callbacklist.end();
+	for (; it != end; ++it) {
+		(*it)(digitsdiff);
+	}
+
 	return *this;
 }
 
@@ -1886,6 +2076,13 @@ void _numeric_digits::print(std::ostream &os) const
 }
 
 
+/** Add a new callback function. */
+void _numeric_digits::add_callback(digits_changed_callback callback)
+{
+	callbacklist.push_back(callback);
+}
+
+
 std::ostream& operator<<(std::ostream &os, const _numeric_digits &e)
 {
 	e.print(os);