pspline 5.0.5 → 5.1.0

data/ext/pspline/real.cpp

@@ -0,0 +1,1607 @@
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include <math.h>
+#ifdef USE_RANDOM
+#include <random>
+#endif
+#include "real_config.h"
+#include "bspline_Config.h"
+#include "basis/real.h"
+
+namespace rios {
+	unsigned int fixed = 0x00000001;
+	unsigned int scientific = 0x00000002;
+};
+
+#define REAL(p) (p[N])
+#define DOUBLE(e) (e(N))
+
+const Real real_inv_fact (size_t n, int i) { return Real(n, real_inv_data[i]); }
+const Real real_cos_table(size_t n, int i) { return Real(n, real_cos_data[i]); }
+const Real real_sin_table(size_t n, int i) { return Real(n, real_sin_data[i]); }
+
+template <> Real& Real::operator = (const Real& p)
+{
+	if (this != &p) {
+		if (_f || w == NULL) {
+			delete[] w;
+			_size = 1; N = p.N; w = new double[N+1]; _st = _f = 1;
+		}
+		for (size_t i = 0; i <= N; ++i) w[i] = (i <= p.N) ? p.w[i] : 0.0;
+	}
+	return *this;
+}
+
+template <> Real& Real::operator = (const varray<double>& v)
+{
+	if (this != &v) {
+		size_t M = v.atom();
+		if (_f || w == NULL) {
+			delete[] w;
+			_size = 1; N = M; w = new double[N+1]; _st = _f = 1;
+		}
+		double *u = (double*)v;
+		for (size_t i = 0; i <= N; ++i) w[i] = (i <= M) ? u[i] : 0.0;
+	}
+	return *this;
+}
+
+template <> Real& Real::operator = (double a)
+{
+	if (w == NULL) { _size = 1; N = MAXN; w = new double[N+1]; _st = _f = 1; }
+	w[0] = a; for (size_t i = 1; i <= N; ++i) w[i] = 0.0;
+	return *this;
+}
+
+void qd_add(size_t N, double *s, double *a, double b)
+{
+	if (N == 0) { s[0] = a[0] + b; } else
+	if (N == 1) { s[0] = four_sum1(a[0], a[1], b, s[1]); } else
+	{
+		for (size_t i = 0; i <= N; ++i) s[i] = two_sum(a[i], b, b);
+		renorm(N, s, b);
+	}
+}
+
+void qd_minus(size_t N, double *s, double *a)
+{
+	for (size_t i = 0; i <= N; ++i) s[i] = -a[i];
+}
+
+void qd_sub(size_t N, double *s, double *a, double b)
+{
+	qd_add(N, s, a, -b);
+}
+
+void qd_add(size_t N, double *x, double *a, double *b)
+{
+	if (N == 0) { x[0] = a[0] + b[0]; } else
+	if (N == 1) {
+#ifdef IEEE_ADD
+		double s, e, t1, t2;
+		s = two_sum(a[0], b[0], e);
+		t1 = two_sum(a[1], b[1], t2);
+		e += t1;
+		s = quick_two_sum(s, e, e);
+		e += t2;
+		x[0] = quick_two_sum(s, e, x[1]);
+#else
+		x[0] = four_sum2(a[0], a[1], b[0], b[1], x[1]);
+#endif
+	} else {
+#ifdef IEEE_ADD
+		double s, t, u, v, w[N+1];	/* double-length accumulator */
+		size_t i = 0, j = 0, k = 0;
+		if (fabs(a[i]) > fabs(b[j]))
+			 u = a[i++];
+		else u = b[j++];
+		if (fabs(a[i]) > fabs(b[j]))
+			 v = a[i++];
+		else v = b[j++];
+		u = quick_two_sum(u, v, v);
+		while (k <= N) {
+			if (i > N && j > N) { w[k++] = u; if (k <= N) w[k++] = v; break; }
+			if (i > N) t = b[j++]; else
+			if (j > N) t = a[i++]; else
+			if (fabs(a[i]) > fabs(b[j]))
+				 t = a[i++];
+			else t = b[j++];
+			s = quick_three_accum(u, v, t);
+			if (s != 0.0) w[k++] = s;
+		}	for (; k <= N; ++k) w[k] = 0.0;
+		/* add the rest. */
+		for (k = i; k <= N; k++) w[N] += a[k];
+		for (k = j; k <= N; k++) w[N] += b[k];
+		for (k = 0; k <= N; ++k) x[k]  = w[k];
+		renorm(N, x);
+#else
+		double t[N+1], e = 0;
+		for (size_t i = 0; i <= N; ++i) x[i] = two_sum(a[i], b[i], t[i]);
+		x[1] = two_sum(x[1], t[0], t[0]);	// s1 = two_sum(s1, t0, t0);
+		for (size_t i = 2; i < N; ++i) {
+			three_sum(x[i], t[0], t[i-1]);	// three_sum(s2, t0, t1);
+			e += t[i-1];
+		}	three_sum2(x[N], t[0], t[N-1]);	// three_sum2(s3, t0, t2);
+			e += t[0] + t[N];				// t0 = t0 + t1 + t3;
+		/* renormalize */
+		renorm(N, x, e);
+#endif
+	}
+}
+
+void qd_sub(size_t N, double *x, double *a, double *b)
+{
+	double c[N+1];
+	for (size_t i = 0; i <= N; ++i) c[i] = -b[i];
+	qd_add(N, x, a, c);
+}
+
+void qd_mul(size_t N, double *s, double *a, double b)
+{
+	if (N == 0) { s[0] = a[0] * b; } else
+	if (N == 1) { s[0] = four_prod1(a[0], a[1], b, s[1]); } else
+	{
+		double p[2*N+1], *q = &p[N+1], e = 0;
+
+		for (size_t i = 0; i < N; ++i)
+			p[i] = two_prod(a[i], b, q[i]);
+			p[N] = a[N] * b;
+
+		s[0] = p[0];							// s0 = p0;
+		s[1] = two_sum(q[0], p[1], q[0]);		// s1 = two_sum(q0, p1, s2);
+		for (size_t i = 2; i < N; ++i) {
+			three_sum(q[i-2], q[i-1], p[i]);	// three_sum(s2, q1, p2);
+			s[i] = q[i-2]; e += p[i];
+		}	three_sum2(q[N-2], q[N-1], p[N]);	// three_sum2(q1, q2, p3);
+			s[N] = q[N-2]; e += q[N-1]; 		// s3 = q1;
+					  							// s4 = q2 + p2;
+		renorm(N, s, e);
+	}
+}
+
+/* Real * Real
+
+  p[0][0] = a0 * b0                 p0, q0
+  p[1][0] =      a0 * b1            p1, q1
+  p[1][1] =      a1 * b0            p2, q2
+  p[2][0] =           a0 * b2       p3, q3
+  p[2][1] =           a1 * b1       p4, q4
+  p[2][2] =           a2 * b0       p5, q5
+  p[3][0] =                a0 * b3  p6, q6
+  p[3][1] =                a1 * b2  p7, q7
+  p[3][2] =                a2 * b1  p8, q8
+  p[3][3] =                a3 * b0  p9, q9  */
+
+void qd_mul(size_t N, double *x, double *a, double *b)
+{
+	if (N == 0) { x[0] = a[0] * b[0]; } else
+	if (N == 1) { x[0] = four_prod2(a[0], a[1], b[0], b[1], x[1]); } else
+	{
+#ifdef ACCURATE
+		const size_t H = N + 1;
+#else
+		const size_t H = N;
+#endif
+		size_t K = 0, s[H];
+		for (size_t i = 0; i < H; ++i) {
+			s[i] = i + 1; K += s[i];
+		}
+		double m[K*2];
+		double **p = create_carray_view(m, H, s);
+		double **q = create_carray_view(m + K, H, s);
+		for (size_t i = 0; i < H; ++i)
+			for (size_t j = 0; j <= i; ++j)
+				p[i][j] = two_prod(a[j], b[i-j], q[i][j]);
+		double &q0 = q[0][0];	// O(eps^0)
+		double &q1 = q[1][0];	// O(eps^1)
+		double &q2 = q[1][1];
+		/* O(eps^0) Accumulation */
+		// m[0] = p0;
+		// O(eps^1) 3_sum of p1, (q0), (p1, p2)
+		three_sum(m[1], m[2], q0);
+		// m[1] = p1, m[2] = p2;
+		// O(eps^2) 6_sum of p2, (q1, q2), (p3, p4, p5).
+		for (size_t i = 2; i < H; ++i) {
+		/* compute (s0, s1, s2) = (p2, q1, q2) + (p3, p4, p5). */
+			three_sum(m[i], q1, q2); // three_sum(p2, q1, q2);
+			for (size_t j = 2; j < i; ++j)
+				four_sum3(m[i], q1, q2, q[i-1][j]);
+			for (size_t j = 0; j < i+1; ++j)
+				four_sum3(m[i], q1, q2, p[i][j]); // three_sum(p3, p4, p5);
+		/* H == L ? O(eps^3) : O(eps^4) order terms*/
+			m[i+1] = q1 + q0; q0 = q2;
+			if (i < H-1) { q1 = q[i][0]; q2 = q[i][1]; }
+		}
+		// H == L ? O(eps^3) 8_sum of p3, (q3, q4, q5), (p6, p7, p8, p9). m[3] = p3;
+		// H != L ? O(eps^4) 9_sum of q0, p4, (q6, q7, q8, q9), (p10, p11, p12)
+
+		// H == L ? (q3, q4, q5) : (q6, q7, q8, q9)
+		for (size_t j = 0; j < H; j++)  m[H] += q[H-1][j];
+		// H == L ? (p6, p7, p8, p9) : (p10, p11, p12)
+		for (size_t i = H-N; i <= N; ++i) m[H] += a[i] * b[H-i];
+#ifdef ACCURATE
+		q0 += m[H];
+#endif
+		for (size_t i = 0; i <= N; ++i) x[i] = m[i];
+		free((void*)q);
+		free((void*)p);
+		renorm(N, x, q0);
+	}
+}
+
+void qd_div(size_t N, double *q, double *a, double b)
+{
+	if (N == 0) { q[0] = a[0] / b; } else
+	if (N == 1) {
+		double q1, q2, p1, p2, s, e;
+
+		q1 = a[0] / b;   /* approximate quotient. */
+		/* Compute  this - q1 * d */
+		p1 = two_prod(q1, b, p2);
+		 s = two_diff(a[0], p1, e);
+		e += a[1];
+		e -= p2;
+		/* get next approximation. */
+		q2 = (s + e) / b;
+		/* renormalize */
+		q[0] = quick_two_sum(q1, q2, q[1]);
+	} else {
+/* Strategy:  compute approximate quotient using high order
+   doubles, and then correct it 3 times using the remainder.
+   (Analogous to long division.)                           */
+
+		double r[N+1], s[N+1], t[N+1];
+		for (size_t i = 0; i <= N; ++i) {
+			r[i] = a[i]; t[i] = 0.0;
+		}
+		for (size_t i = 0; i < N; ++i) {
+			q[i] = r[0] / b;				/* approximate quotient */
+			t[0] = two_prod(q[i], b, t[1]); /* Compute the remainder  a - q0 * b */
+			qd_sub(N, s, r, t);
+			for (size_t j = 0; j <= N; ++j) r[j] = s[j];
+		}	q[N] = r[0] / b;				/* Final correction to the quotient. */
+		renorm(N, q);
+	}
+
+}
+
+void qd_div(size_t N, double *q, double *a, double *b)
+{
+	if (N == 0) { q[0] = a[0] / b[0]; } else
+	if (N == 1) {
+#ifdef ACCURATE
+		double q0, q1, s[3], t[2];
+		
+		q0 = a[0]; q1 = a[1];
+		for (size_t i = 0; i < 3; ++i) {
+			s[i] = q0 / b[0];  /* approximate quotient */
+			if (i < 2) {
+			//	q -= s[i] * b;
+				t[0] = four_prod1(b[0], b[1], s[i], t[1]);
+				q0 = four_diff2(q0, q1, t[0], t[1], q1);
+			}
+		}
+		q0 = quick_two_sum(s[0], s[1], q1);
+		// q += s[2];
+		q[0] = four_sum1(q0, q1, s[2], q[1]);
+#else
+		double s1, s2, q0, q1, r[2];
+
+		q0 = a[0] / b[0];  /* approximate quotient */
+		/* compute  this - q0 * dd */
+//		Real r = b * q0;
+		r[0] = four_prod1(b[0], b[1], q0, r[1]);
+		s1 = two_diff(a[0], r[0], s2);
+		s2 -= r[1];
+		s2 += a[1];
+		/* get next approximation */
+		q1 = (s1 + s2) / b[0];
+		/* renormalize */
+		q[0] = quick_two_sum(q0, q1, q[1]);
+#endif
+	} else {
+		double r[N+1], s[N+1];
+		for (size_t i = 0; i <= N; ++i) r[i] = a[i];
+		for (size_t i = 0; i <= N; ++i) {
+			q[i] = r[0] / b[0];
+			if (i < N) {
+			//	r -= (b * q[i]);
+				qd_mul(N, s, b, q[i]);
+				qd_sub(N, s, r, s);
+				for (size_t i = 0; i <= N; ++i) r[i] = s[i];
+			}
+		}
+#ifdef ACCURATE
+//		r -= (b * q[N]);
+		qd_mul(N, s, b, q[N]);
+		qd_sub(N, s, r, s);
+		for (size_t i = 0; i <= N; ++i) r[i] = s[i];
+		double q4 = r[0] / b[0];
+		renorm(N, q, q4);
+#else
+		renorm(N, q);
+#endif
+	}
+}
+
+bool qd_eq(size_t N, double *a, double *b)
+{
+	size_t i;
+	for (i = 0; i <= N; ++i) if (a[i] != b[i]) break;
+	return (i > N);
+}
+
+bool qd_lt(size_t N, double *a, double *b)
+{
+	size_t i;
+	for (i = 0; i <= N; ++i) if (a[i] != b[i]) break;
+	return (i <= N) && (a[i] < b[i]);
+}
+
+bool qd_gt(size_t N, double *a, double *b)
+{
+	size_t i;
+	for (i = 0; i <= N; ++i) if (a[i] != b[i]) break;
+	return (i <= N) && (a[i] > b[i]);
+}
+
+bool qd_le(size_t N, double *a, double *b)
+{
+	size_t i;
+	for (i = 0; i <= N; ++i) if (a[i] != b[i]) break;
+	return (i > N) || (a[i] < b[i]);
+}
+
+bool qd_ge(size_t N, double *a, double *b)
+{
+	size_t i;
+	for (i = 0; i <= N; ++i) if (a[i] != b[i]) break;
+	return (i > N) || (a[i] > b[i]);
+}
+
+bool qd_eq(size_t N, double *a, double b)
+{
+	size_t i = 0; bool f = (a[0] == b);
+	if (f) for (i = 1; i <= N; ++i) if (a[i] != 0.0) break;
+	return f && (i > N);
+}
+
+bool qd_lt(size_t N, double *a, double b)
+{
+	size_t i = 0; bool f = (a[0] == b);
+	if (f) for (i = 1; i <= N; ++i) if (a[i] != 0.0) break;
+	return (a[0] < b || (i <= N && a[i] < 0.0));
+}
+
+bool qd_gt(size_t N, double *a, double b)
+{
+	size_t i = 0; bool f = (a[0] == b);
+	if (f) for (i = 1; i <= N; ++i) if (a[i] != 0.0) break;
+	return (a[0] > b || (i <= N && a[i] > 0.0));
+}
+
+bool qd_le(size_t N, double *a, double b)
+{
+	size_t i; bool f = (a[0] < b);
+	if (!f) for (i = 1; i <= N; ++i) if (a[i] != 0) break;
+	return (f || ((a[0] == b) && (i > N || a[i] < 0.0)));
+}
+
+bool qd_ge(size_t N, double *a, double b)
+{
+	size_t i = 0; bool f = (a[0] > b);
+	if (!f) for (i = 1; i <= N; ++i) if (a[i] != 0.0) break;
+	return (f || ((a[0] == b) && (i > N || a[i] > 0.0)));
+}
+
+void qd_abs(size_t N, double *a, double *b)
+{
+	if (qd_lt(N, b, 0.0)) qd_minus(N, a, b);
+	else
+		for (size_t i = 0; i <= N; ++i) a[i] = b[i];
+}
+
+Real sqrt(const Real& a)
+{
+  /* Strategy:  
+
+     Perform the following Newton iteration:
+
+       x' = x + (1 - a * x^2) * x / 2;
+       
+     which converges to 1/sqrt(a), starting with the
+     double precision approximation to 1/sqrt(a).
+     Since Newton's iteration more or less doubles the
+     number of correct digits, we only need to perform it 
+     twice.
+  */
+	const size_t N = a.atom();
+	Real r(N);
+
+	if (a.is_negative()) throw "(real::sqrt): Negative argument.";
+
+	if (!a.is_zero()) {
+		Real h = mul_pwr2(a, 0.5);
+		r = 1.0 / _sqrt(a(0));
+		for (size_t i = 0; i < N; ++i)
+			r += ((0.5 - h * sqr(r)) * r);
+			r *= a;
+	}
+	return r;
+}
+
+/* Computes the n-th root of a */
+Real nroot(const Real& a, int n)
+{
+/* Strategy:  Use Newton's iteration to solve
+     
+        1/(x^n) - a = 0
+
+     Newton iteration becomes
+
+        x' = x + x * (1 - a * x^n) / n
+
+     Since Newton's iteration converges quadratically, 
+     we only need to perform it twice.
+                                                     */
+	const size_t N = a.atom();
+	Real x(N);
+
+	if (n <= 0) throw "(real::nroot): N must be positive.";
+
+	if (n % 2 == 0 && a.is_negative())
+		throw "(real::nroot): Negative argument.";
+
+	if (n == 1) x = a;       else
+	if (n == 2) x = sqrt(a); else
+	if (!a.is_zero()) {
+		/* Note  a^{-1/n} = exp(-log(a)/n) */
+		auto r = abs(a);
+		x = _exp(-_log(r(0)) / n);
+		/* Perform Newton's iteration. */
+		double dbl_n = static_cast<double>(n);
+		for (size_t i = 0; i < N; ++i)
+			x += x * (1.0 - r * npwr(x, n)) / dbl_n;
+		if (a(0) < 0.0) x = -x;
+		x = 1.0 / x;
+	}
+	return x;
+}
+
+Real exp(const Real& a)
+{
+	const int N = a.atom();
+	int n1 = 2 * N + 3, n2 = 2 * n1 - (N + 1) / 2;
+
+/* Strategy:  We first reduce the size of x by noting that  
+
+          exp(kr + m * log(2)) = 2^m * exp(r)^k
+
+   where m and k are integers.  By choosing m appropriately 
+   we can make |kr| <= log(2) / 2 = 0.347.  Then exp(r) is  
+   evaluated using the familiar Taylor series.  Reducing the
+   argument substantially speeds up the convergence.      */
+
+	const double k = ldexp(1.0, n2);
+	const double inv_k = 1.0 / k;
+	Real result((size_t)N);
+
+	if (a(0) <= -709.0) result = 0.0;        else
+
+	if (a(0) >=  709.0) result = REAL(_inf); else
+
+	if (a.is_zero()   ) result = 1.0;        else
+
+	if (a.is_one()    ) result = REAL(_e);   else
+
+	{
+		double m = _floor(a(0) / REAL(_log2)(0) + 0.5);
+		Real r = mul_pwr2(a - REAL(_log2) * m, inv_k);
+		Real s, p, t;
+		double thresh = inv_k * DOUBLE(_eps);
+
+		p = sqr(r);
+		s = r + mul_pwr2(p, 0.5);
+		int i = 0;
+		do {
+			p *= r;
+			t = p * real_inv_fact(N, i++);
+			s += t;
+		} while (fabs(t.to_d()) > thresh && i < n1+2);
+
+		for (int i = 0; i < n2; ++i)
+			s = mul_pwr2(s, 2.0) + sqr(s);
+			s += 1.0;
+		result = ldexp(s, static_cast<int>(m));
+	}
+	return result;
+}
+
+/* Logarithm.  Computes log(x) in quad-double precision.
+   This is a natural logarithm (i.e., base e).            */
+Real log(const Real& a)
+{
+  /* Strategy.  The Taylor series for log converges much more
+     slowly than that of exp, due to the lack of the factorial
+     term in the denominator.  Hence this routine instead tries
+     to determine the root of the function
+
+         f(x) = exp(x) - a
+
+     using Newton iteration.  The iteration is given by
+
+         x' = x - f(x)/f'(x) 
+            = x - (1 - a * exp(-x))
+            = x + a * exp(-x) - 1.
+           
+     Two iteration is needed, since Newton's iteration 
+     approximately doubles the number of digits per iteration. */
+
+	const size_t N = a.atom();
+	Real x(N);
+
+	if (a(0) < 0.0) throw "(poly::log): Non-positive argument.";
+	if (a(0) == 0.0) x = -REAL(_inf);
+	else if (!a.is_one())
+	{
+		x = _log(a(0));   /* Initial approximation */
+
+		for (size_t i = 0; i < N; ++i) x = x + a * exp(-x) - 1.0;
+	}
+	return x;
+}
+
+Real log10(const Real& a)
+{
+	const size_t N = a.atom();
+	return log(a) / REAL(_log10);
+}
+
+/* Computes sin(a) and cos(a) using Taylor series.
+   Assumes |a| <= pi/2048.                           */
+static void sincos_taylor(const Real& a, Real& sin_a, Real& cos_a)
+{
+	const size_t N = a.atom();
+	const double thresh = 0.5 * DOUBLE(_eps) * fabs(a.to_d());
+	Real p, s, t, x;
+
+	if (a.is_zero()) {
+		sin_a = 0.0;
+		cos_a = 1.0;
+		return;
+	}
+
+	x = -sqr(a);
+	s = a;
+	p = a;
+	for (int i = 0; i < n_inv_fact; i += 2) {
+		p *= x;
+		t = p * real_inv_fact(N, i);
+		s += t;
+		if (fabs(t.to_d()) <= thresh) break;
+	}
+
+	sin_a = s;
+	cos_a = sqrt(1.0 - sqr(s));
+}
+
+static Real sin_taylor(const Real& a)
+{
+	const size_t N = a.atom();
+	const double thresh = 0.5 * DOUBLE(_eps) * fabs(a.to_d());
+	Real p, s(N), t, x;
+
+	if (!a.is_zero())
+	{
+		x = -sqr(a);
+		s = a;
+		p = a;
+		for (int i = 0; i < n_inv_fact; i += 2) {
+			p *= x;
+			t = p * real_inv_fact(N, i);
+			s += t;
+			if (fabs(t.to_d()) <= thresh) break;
+		}
+	}
+	return s;
+}
+
+static Real cos_taylor(const Real& a)
+{
+	const size_t N = a.atom();
+	const double thresh = 0.5 * DOUBLE(_eps);
+	Real p, s(N), t, x;
+
+	if (a.is_zero())
+	{
+		x = -sqr(a);
+		s = 1.0 + mul_pwr2(x, 0.5);
+		p = x;
+		for (int i = 1; i < n_inv_fact; i += 2) {
+			p *= x;
+			t = p * real_inv_fact(N, i);
+			s += t;
+			if (fabs(t.to_d()) <= thresh) break;
+		}
+	}
+	return s;
+}
+
+Real sin(const Real& a)
+{
+/* Strategy.  To compute sin(x), we choose integers a, b so that
+
+       x = s + a * (pi/2) + b * (pi/1024)
+
+     and |s| <= pi/2048.  Using a precomputed table of
+     sin(k pi / 1024) and cos(k pi / 1024), we can compute
+     sin(x) from sin(s) and cos(s).  This greatly increases the
+     convergence of the sine Taylor series.                          */
+
+	const size_t N = a.atom();
+	Real r(N);
+	if (!a.is_zero())
+	{
+		// approximately reduce modulo 2*pi
+		Real z = nint(a / REAL(_2pi));
+		Real v = a - REAL(_2pi) * z;
+
+		// approximately reduce modulo pi/2 and then modulo pi/1024
+		double  q = _floor(v(0) / REAL(_pi2)(0) + 0.5);
+		Real t = v - REAL(_pi2) * q;
+		int j = static_cast<int>(q);
+		q = _floor(t(0) / _pi1024[N](0) + 0.5);
+		t -= _pi1024[N] * q;
+		int k = static_cast<int>(q);
+		int abs_k = abs(k);
+
+		if (j < -2 || j > 2) throw "(poly::sin): Cannot reduce modulo pi/2.";
+
+		if (abs_k > 256)	 throw "(poly::sin): Cannot reduce modulo pi/1024.";
+
+		if (k == 0) switch (j) {
+			case  0: r =  sin_taylor(t); break;
+			case  1: r =  cos_taylor(t); break;
+			case -1: r = -cos_taylor(t); break;
+			default: r = -sin_taylor(t);
+		} else {
+			Real sin_t, cos_t;
+			Real u = real_cos_table(N, abs_k-1);
+			Real v = real_sin_table(N, abs_k-1);
+			sincos_taylor(t, sin_t, cos_t);
+
+			if (j == 0) {
+				if (k > 0) {
+					r = u * sin_t + v * cos_t;
+				} else {
+					r = u * sin_t - v * cos_t;
+				}
+			} else if (j == 1) {
+				if (k > 0) {
+					r = u * cos_t - v * sin_t;
+				} else {
+					r = u * cos_t + v * sin_t;
+				}
+			} else if (j == -1) {
+				if (k > 0) {
+					r = v * sin_t - u * cos_t;
+				} else {
+			 		r = - u * cos_t - v * sin_t;
+				}
+			} else {
+				if (k > 0) {
+					r = - u * sin_t - v * cos_t;
+				} else {
+					r = v * cos_t - u * sin_t;
+				}
+			}
+		}
+	}
+	return r;
+}
+
+Real cos(const Real& a)
+{
+	const size_t N = a.atom();
+	Real r(1.0, N);
+	
+	if (!a.is_zero())
+	{
+		// approximately reduce modulo 2*pi
+		Real z = nint(a / REAL(_2pi));
+		Real v = a - REAL(_2pi) * z;
+
+		// approximately reduce modulo pi/2 and then modulo pi/1024
+		double q = _floor(v(0) / REAL(_pi2)(0) + 0.5);
+		Real t = v - REAL(_pi2) * q;
+		int j = static_cast<int>(q);
+		q = _floor(t(0) / _pi1024[N](0) + 0.5);
+		t -= _pi1024[N] * q;
+		int k = static_cast<int>(q);
+		int abs_k = abs(k);
+
+		if (j < -2 || j > 2) throw "(poly::cos): Cannot reduce modulo pi/2.";
+
+		if (abs_k > 256)	 throw "(poly::cos): Cannot reduce modulo pi/1024.";
+
+		if (k == 0) switch (j) {
+			case  0: r =  cos_taylor(t); break;
+			case  1: r = -sin_taylor(t); break;
+			case -1: r =  sin_taylor(t); break;
+			default: r = -cos_taylor(t);
+		} else {
+
+			Real sin_t, cos_t;
+			sincos_taylor(t, sin_t, cos_t);
+
+			Real u = real_cos_table(N, abs_k-1);
+			Real v = real_sin_table(N, abs_k-1);
+
+			if (j == 0) {
+				if (k > 0) {
+					r = u * cos_t - v * sin_t;
+				} else {
+					r = u * cos_t + v * sin_t;
+				}
+			} else if (j == 1) {
+				if (k > 0) {
+					r = - u * sin_t - v * cos_t;
+				} else {
+					r = v * cos_t - u * sin_t;
+				}
+			} else if (j == -1) {
+				if (k > 0) {
+					r = u * sin_t + v * cos_t;
+				} else {
+					r = u * sin_t - v * cos_t;
+				}
+			} else {
+				if (k > 0) {
+					r = v * sin_t - u * cos_t;
+				} else {
+					r = - u * cos_t - v * sin_t;
+				}
+			}
+		}
+	}
+	return r;
+}
+
+void sincos(const Real& a, Real& sin_a, Real& cos_a)
+{
+	const size_t N = a.atom();
+	if (a.is_zero()) {
+		sin_a = 0.0;
+		cos_a = 1.0;
+		return;
+	}
+
+	// approximately reduce by 2*pi
+	Real z = nint(a / REAL(_2pi));
+	Real t = a - REAL(_2pi) * z;
+
+	// approximately reduce by pi/2 and then by pi/1024.
+	double  q = _floor(t(0) / REAL(_pi2)(0) + 0.5);
+		   t -= REAL(_pi2) * q;
+		int j = static_cast<int>(q);
+			q = _floor(t(0) / _pi1024[N](0) + 0.5);
+		   t -= _pi1024[N] * q;
+		int k = static_cast<int>(q);
+	int abs_k = abs(k);
+
+	if (j < -2 || j > 2) throw "(poly::sincos): Cannot reduce modulo pi/2.";
+
+	if (abs_k > 256)	 throw "(poly::sincos): Cannot reduce modulo pi/1024.";
+
+	Real sin_t, cos_t;
+	sincos_taylor(t, sin_t, cos_t);
+
+	if (k == 0) {
+		if (j == 0) {
+			sin_a = sin_t;
+			cos_a = cos_t;
+		} else if (j == 1) {
+			sin_a = cos_t;
+			cos_a = -sin_t;
+		} else if (j == -1) {
+			sin_a = -cos_t;
+			cos_a = sin_t;
+		} else {
+			sin_a = -sin_t;
+			cos_a = -cos_t;
+		}
+		return;
+	}
+
+	Real u = real_cos_table(N, abs_k-1);
+	Real v = real_sin_table(N, abs_k-1);
+
+	if (j == 0) {
+		if (k > 0) {
+			sin_a = u * sin_t + v * cos_t;
+			cos_a = u * cos_t - v * sin_t;
+		} else {
+			sin_a = u * sin_t - v * cos_t;
+			cos_a = u * cos_t + v * sin_t;
+		}
+	} else if (j == 1) {
+		if (k > 0) {
+			cos_a = - u * sin_t - v * cos_t;
+			sin_a =   u * cos_t - v * sin_t;
+		} else {
+			cos_a =   v * cos_t - u * sin_t;
+			sin_a =   u * cos_t + v * sin_t;
+		}
+	} else if (j == -1) {
+		if (k > 0) {
+			cos_a =   u * sin_t + v * cos_t;
+			sin_a =   v * sin_t - u * cos_t;
+		} else {
+			cos_a =   u * sin_t - v * cos_t;
+			sin_a = - u * cos_t - v * sin_t;
+		}
+	} else {
+		if (k > 0) {
+			sin_a = - u * sin_t - v * cos_t;
+			cos_a =   v * sin_t - u * cos_t;
+		} else {
+			sin_a =   v * cos_t - u * sin_t;
+			cos_a = - u * cos_t - v * sin_t;
+		}
+	}
+}
+
+Real atan(const Real& a)
+{
+	const size_t N = a.atom();
+	return atan2(a, Real(1.0, N));
+}
+
+Real atan2(const Real &y, const Real &x)
+{
+/* Strategy: Instead of using Taylor series to compute 
+     arctan, we instead use Newton's iteration to solve
+     the equation
+
+        sin(z) = y/r    or    cos(z) = x/r
+
+     where r = sqrt(x^2 + y^2).
+     The iteration is given by
+
+        z' = z + (y - sin(z)) / cos(z)          (for equation 1)
+        z' = z - (x - cos(z)) / sin(z)          (for equation 2)
+
+     Here, x and y are normalized so that x^2 + y^2 = 1.
+     If |x| > |y|, then first iteration is used since the 
+     denominator is larger.  Otherwise, the second is used.
+*/
+	const size_t N = y.atom();
+#ifndef NDEBUG
+	const size_t M = x.atom();
+#endif
+	assert(N == M);
+	if (x.is_zero()) {
+		if (y.is_zero())	/* Both x and y is zero. */
+			throw "(poly::atan2): Both arguments zero.";
+		return (y.is_positive()) ? REAL(_pi2) : -REAL(_pi2);
+	} else if (y.is_zero()) {
+		return (x.is_positive()) ? Real(0.0) : REAL(_pi);
+	}
+
+	if (x == y)  return (y.is_positive()) ? REAL(_pi4) : -REAL(_3pi4);
+
+	if (x == -y) return (y.is_positive()) ? REAL(_3pi4) : -REAL(_pi4);
+
+	Real r = sqrt(sqr(x) + sqr(y));
+	Real xx = x / r;
+	Real yy = y / r;
+
+	/* Compute double precision approximation to atan. */
+	Real z(_atan2(y.to_d(), x.to_d()), N);
+	Real sin_z, cos_z;
+
+	if (fabs(xx(0)) > fabs(yy(0))) {
+		/* Use Newton iteration 1.	z' = z + (y - sin(z)) / cos(z)  */
+		for (size_t i = 0; i < N; ++i) {
+			sincos(z, sin_z, cos_z);
+			z += (yy - sin_z) / cos_z;
+		}
+	} else {
+		/* Use Newton iteration 2.	z' = z - (x - cos(z)) / sin(z)  */
+		for (size_t i = 0; i < N; ++i) {
+			sincos(z, sin_z, cos_z);
+			z -= (xx - cos_z) / sin_z;
+		}
+	}
+	return z;
+}
+
+Real drem(const Real& a, const Real& b)
+{
+	Real n = nint(a/b);
+	return (a - n * b);
+}
+
+Real divrem(const Real &a, const Real &b, Real &r)
+{
+	Real n = nint(a/b);
+	r = a - n * b;
+	return n;
+}
+
+Real tan(const Real &a)
+{
+	Real s, c;
+	sincos(a, s, c);
+	return s/c;
+}
+
+Real asin(const Real &a)
+{
+	const size_t N = a.atom();
+	Real abs_a = abs(a);
+
+	if (abs_a > 1.0) throw "(poly::asin): Argument out of domain.";
+	if (abs_a.is_one())
+		return (a.is_positive()) ? REAL(_pi2) : -REAL(_pi2);
+	return atan2(a, sqrt(1.0 - sqr(a)));
+}
+
+Real acos(const Real &a)
+{
+	const size_t N = a.atom();
+	Real abs_a = abs(a);
+
+	if (abs_a > 1.0) throw "(poly::acos): Argument out of domain.";
+	if (abs_a.is_one())
+		return (a.is_positive()) ? Real(0.0) : REAL(_pi);
+	return atan2(sqrt(1.0 - sqr(a)), a);
+}
+
+Real sinh(const Real &a)
+{
+	const size_t N = a.atom();
+	Real z(N);
+
+	if (!a.is_zero())
+	{
+		if (abs(a) > 0.05) {
+			Real ea = exp(a);
+			return mul_pwr2(ea - inv(ea), 0.5);
+		}
+
+		/* Since a is small, using the above formula gives
+		     a lot of cancellation.   So use Taylor series. */
+		Real s = a;
+		Real t = a;
+		Real r = sqr(t);
+		double m = 1.0;
+		double thresh = fabs(a.to_d() * DOUBLE(_eps));
+
+		do {
+			m += 2.0;
+			t *= r;
+			t /= (m-1) * m;
+			s += t;
+		} while (abs(t) > thresh);
+		z = s;
+	}
+	return z;
+}
+
+Real cosh(const Real &a)
+{
+	const size_t N = a.atom();
+	Real z(1.0, N);
+
+	if (!a.is_zero())
+	{
+		Real ea = exp(a);
+		z = mul_pwr2(ea + inv(ea), 0.5);
+	}
+	return z;
+}
+
+Real tanh(const Real &a)
+{
+	const size_t N = a.atom();
+	Real z(N);
+
+	if (!a.is_zero())
+	{
+		if (fabs(a.to_d()) > 0.05) {
+			Real ea = exp(a);
+			Real inv_ea = inv(ea);
+			z = (ea - inv_ea) / (ea + inv_ea);
+		} else {
+			Real s, c;
+			s = sinh(a);
+			c = sqrt(1.0 + sqr(s));
+			z = s / c;
+		}
+	}
+	return z;
+}
+
+void sincosh(const Real &a, Real &s, Real &c)
+{
+	if (fabs(a.to_d()) <= 0.05) {
+		s = sinh(a);
+		c = sqrt(1.0 + sqr(s));
+	} else {
+		Real ea = exp(a);
+		Real inv_ea = inv(ea);
+		s = mul_pwr2(ea - inv_ea, 0.5);
+		c = mul_pwr2(ea + inv_ea, 0.5);
+	}
+}
+
+Real asinh(const Real &a)
+{
+	return log(a + sqrt(sqr(a) + 1.0));
+}
+
+Real acosh(const Real &a)
+{
+	if (a < 1.0) throw "(poly::acosh): Argument out of domain.";
+	return log(a + sqrt(sqr(a) - 1.0));
+}
+
+Real atanh(const Real &a)
+{
+	if (abs(a) >= 1.0) throw "(poly::atanh): Argument out of domain.";
+	return mul_pwr2(log((1.0 + a) / (1.0 - a)), 0.5);
+}
+
+Real fmod(const Real &a, const Real &b)
+{
+	Real n = aint(a / b);
+	return (a - b * n);
+}
+
+/* polyeval(c, n, x)
+   Evaluates the given n-th degree polynomial at x.
+   The polynomial is given by the array of (n+1) coefficients.
+*/
+Real polyeval(const Real *c, int n, const Real &x)
+{
+	/* Just use Horner's method of polynomial evaluation. */
+	Real r = c[n];
+  
+	for (int i = n-1; i >= 0; i--) {
+		r *= x;
+		r += c[i];
+	}
+	return r;
+}
+
+/* polyroot(c, n, x0)
+   Given an n-th degree polynomial, finds a root close to 
+   the given guess x0.  Note that this uses simple Newton
+   iteration scheme, and does not work for multiple roots.
+*/
+Real polyroot(const Real *c, int n, const Real& x0, int max_iter, double thresh)
+{
+	const size_t N = x0.atom();
+	Real x = x0;
+	Real f;
+	Real *d = new Real[n];
+	bool conv = false;
+	int i;
+	double max_c = fabs(c[0].to_d());
+	double v;
+
+	if (thresh == 0.0) thresh = DOUBLE(_eps);
+
+	/* Compute the coefficients of the derivatives. */
+	for (i = 1; i <= n; i++) {
+		v = fabs(c[i].to_d());
+		if (v > max_c) max_c = v;
+		d[i-1] = c[i] * static_cast<double>(i);
+	}
+	thresh *= max_c;
+
+	/* Newton iteration. */
+	for (i = 0; i < max_iter; i++) {
+		f = polyeval(c, n, x);
+
+		if (abs(f) < thresh) {
+			conv = true;
+			break;
+		}
+		x -= (f / polyeval(d, n-1, x));
+	}
+	delete [] d;
+
+	if (!conv) {
+		const char *msg = "(poly::polyroot): Failed to converge.";
+		fprintf(stderr, "ERROR %s\n", msg);
+		x = REAL(_nan);
+	}
+	return x;
+}
+
+/* Read a quad-double from s. */
+template <> int Real::read(const char *s, Real& qd)
+{
+	const size_t N = qd.N;
+	const char *p = s;
+	char   ch;
+	int  sign = 0;
+	int point = -1;		/* location of decimal point */
+	int    nd = 0;		/* number of digits read */
+	int     e = 0;		/* exponent. */
+	bool done = false;
+	Real r(N);		/* number being read */
+
+	/* Skip any leading spaces */
+	while (*p == ' ') p++;
+
+	while (!done && (ch = *p) != '\0') {
+		if (ch >= '0' && ch <= '9') {
+			/* It's a digit */
+			int d = ch - '0';
+			r *= 10.0;
+			r += static_cast<double>(d);
+			nd++;
+		} else {
+			/* Non-digit */
+			switch (ch) {
+			  case '.':
+				if (point >= 0) return -1;   /* we've already encountered a decimal point. */
+				point = nd;
+				break;
+			  case '-':
+			  case '+':
+				if (sign != 0 || nd > 0) return -1;  /* we've already encountered a sign, or if its not at first position. */
+				sign = (ch == '-') ? -1 : 1;
+				break;
+			  case 'E':
+			  case 'e':
+				int nread;
+				nread = sscanf(p+1, "%d", &e);
+				done = true;
+				if (nread != 1) return -1;  /* read of exponent failed. */
+				break;
+			  case ' ':
+				done = true;
+				break;
+			  default:
+				return -1;
+			}
+		}
+		p++;
+	}
+
+	/* Adjust exponent to account for decimal point */
+	if (point >= 0) { e -= (nd - point); }
+
+	/* Multiply the the exponent */
+	while (e != 0) if (e > 0) { r *= 10.0; e--; } else { r /= 10.0; e++; }
+
+	qd = (sign < 0) ? -r : r;
+	return 0;
+}
+
+template <> Real& Real::operator = (const char *s)
+{
+	if (w == NULL) { _size = 1; N = MAXN; w = new double[N+1]; _st = _f = 1; }
+	if (read(s, *this)) throw "(poly::operator=): INPUT ERROR.";
+	return *this;
+}
+
+static char *to_str(const Real& val, char *str, int& exp, size_t& len)
+{
+	size_t A = val.atom();
+	static const Real t3(1.0e100, A);
+	static const Real t2(1.0e10,  A);
+	static const Real t1(10.0,    A);
+	static const Real t0(0.0,     A);
+	static const Real s1(1.0,     A);
+	static const Real s2(1.0e-10, A);
+	static const Real s3(1.0e-100,A);
+	int i, sign = sgn(val), n = _ndigits(A) + 2;
+	Real r = pow(t1, 1 - n);
+	Real m = abs(val);
+	char *b = str, *c = NULL;
+	len = 0; exp = 0;
+	if (m > s1) { 
+		while (m > t3) { m /= t3; exp += 100; }
+		while (m > t2) { m /= t2; exp += 10;  }
+		while (m > t1) { m /= t1; exp++;      }
+	} else if (m > t0) {
+		while (m < s3) { m *= t3; exp -= 100; }
+		while (m < s2) { m *= t2; exp -= 10;  }
+		while (m < s1) { m *= t1; exp--;      }
+	}
+	*b++ = '0'; *b++ = '0';
+	for (i = 0; i < n; ++i) {
+		Real t = floor(m); m -= t; m *= t1;
+		*b++ = t.to_i() + '0';
+		r *= t1; if (i < n-1 && m < r) break;
+	}
+	char d = '9';
+	if (i == n) d = '4';
+	if (*(b-1) > d) c = (--b) - 1;
+	while (c) {
+		(*c)++;
+		if (*c > '9') { c--; b--; }
+		else c = NULL;
+	}	*b = '\0';
+	c = str; if (*c == '0') c++;
+	if (*c == '0') c++; else exp++;
+	if (sign < 0) *--c = '-';
+	len = b - c;
+	return c;
+}
+
+static void append_expn(char *str, int expn)
+{
+	int k;
+	*str++ = (expn < 0 ? '-' : '+');
+	expn = abs(expn);
+	if (expn >= 100) {
+		k = (expn / 100);
+		*str++ = '0' + k;
+		expn -= 100 * k;
+	}
+	k = (expn / 10);
+	*str++ = '0' + k;
+	expn -= 10 * k;
+	*str++ = '0' + expn;
+	*str = '\0';
+}
+
+template <> char *Real::to_string(int precision, int width,
+	rios::fmtflags fmt, bool showpos, bool uppercase, char fill) const
+{
+	if (isnan(w[0])) return const_cast<char*>("nan");
+	if (isinf(w[0])) return const_cast<char*>("inf");
+	size_t str_size, blank, buf_size = _ndigits(this->atom()) + 5;
+	char *buf = new char[buf_size];
+	int exp, exponent;
+	char *s = to_str(*this, buf, exponent, str_size);
+	bool sign = (*s == '-');
+
+	bool fixed = (fmt & rios::fixed) != 0;
+	str_size = 2;
+	if (sign || showpos) str_size++;
+	str_size += precision; if (precision > 0) str_size++;;
+	if (fixed) {
+		if (exponent > 0) str_size += exponent;
+		buf_size = str_size;
+	} else {
+		buf_size = str_size + 5;
+	}
+	blank = width + 1;
+	if (buf_size < blank) {
+		blank -= buf_size;
+		buf_size = width + 1;
+	} else blank = 0;
+	char *str = new char[buf_size+1];
+	char *b = str; bool dot = true;
+	while (blank > 0) { *b++ = fill; blank--; }
+	if (sign) { *b++ = *s++; str_size--; }
+	else if (showpos) { *b++ = '+'; str_size--; }
+	char *c = b; exp = fixed ? exponent : 0;
+	for (size_t i = 0; i < str_size; ++i) {
+		if (exp < 0) {
+			*b++ = '0'; ++exp;
+			if (i == 0) { *b++ = '.'; i++; dot = false; }
+		} else if (exp > 0) {
+			if (*s) *b++ = *s++; else *b++ = '0';
+			dot = (--exp == 0);
+		} else {
+			if (*s) *b++ = *s++; else *b++ = '0';
+			if (dot) { *b++ = '.'; i++; dot = false; }
+		}
+	}	char d = *s;
+	s = str;
+	if (*--b >= '5' || (*b == '.' && d >= '5')) {
+		do {
+			if (*b != '.') *b = '0';
+			if (*--b == '.') --b;
+			(*b)++;
+		} while (b > c && *b > '9');
+		if (*c > '9') {
+			size_t i; *c = '1';
+			for (i = 1; i < str_size-1; ++i)
+				if (c[i] == '.') {
+					c[i] = '0'; c[i+1] = '.';
+					c[str_size++] = '0';
+					if (s[0] == fill) s++;
+					break;
+				}
+			if (c[str_size-1] == '.' && i == str_size-1 ) {
+				c[str_size-1] = '0'; str_size++;
+				if (s[0] == fill) s++;
+			}
+		}
+	}
+	b = c + str_size - 1; *b = '\0';
+	if (!fixed) {
+		*b++ = uppercase ? 'E' : 'e';
+		append_expn(b, exponent);
+		while(*b)++b;
+	}
+	str_size = b - s;
+	char *result = new char[str_size + 1];
+	strcpy(result, s);
+	delete[] str;
+	delete[] buf;
+	return result;
+}
+
+template <> int Real::write(char *s, int len, int precision,
+	rios::fmtflags fmt, bool showpos, bool uppercase, char fill) const
+{
+	char *str = this->to_string(precision, 0, fmt, showpos, uppercase, fill);
+	int length = strlen(str);
+	if (len > 0) {
+		strncpy(s, str, len-1);
+		s[len-1] = 0;
+	}	delete[] str;
+	return length;
+}
+
+template <> char *Real::to_a(const char *f) const
+{
+	str_buf c(80);
+	c += '<';
+	for (size_t i = 0; i <= N; i++) {
+		sprintg(c, w[i], f);
+		if (i < N) c += ',';
+	}
+	c += '>';
+	char *result = new char[c.size() + 1];
+	strcpy(result, c.c_str());
+	return result;
+}
+
+template <> char *Real::to_s(const char *f, char fill) const
+{
+	if (isinf(w[0])) { char *s = new char[4]; sprintf(s, "inf"); return s; }
+	if (isnan(w[0])) { char *s = new char[4]; sprintf(s, "nan"); return s; }
+	int len = 0, prec = 0;
+	char *a, *b = NULL, *c = const_cast<char*>(f);
+	while(*c != '%')++c;++c; a = c;
+	while((*c >= '0' && *c <= '9') || *c == '.') { if (*c == '.') b = c + 1; ++c; }
+	len = atoi(a); prec = b ? atoi(b) : 6;
+	rios::fmtflags fmt = rios::scientific;
+	if (*c == 'f') fmt = rios::fixed;
+	if (*c == 'g') {
+		int d = floor(log10(fabs(w[0])));
+		if (abs(d) <= prec) fmt = rios::fixed;
+	}
+	int size = write(NULL, 0, prec, fmt);
+	int length = len > size ? len : size;
+	char *str = new char[length+1];
+	write(str, length+1, prec, fmt);
+	if (*c == 'g' && (fmt & rios::fixed)) {
+		c = str; b = NULL;
+		while (*c == '-' || *c == '+') ++c;
+		while((*c >= '0' && *c <= '9') || *c == '.') { if (*c == '.') b = c; ++c; }
+		if (b) {
+			while (*(c-1) == '0') --c; *c = '\0';
+			if (*(b+1) == '\0') *b = '\0';
+		}
+	}	size = strlen(str);
+	if (len > size) {
+		c = str + len; b = str + size;
+		for (int i = len; i >= 0; --i) {
+			if (i >= len - size) *c-- = *b--;
+			else *c-- = fill;
+		}
+	}
+	return str;
+}
+
+template <> char *Vector::to_s(const char *f) const
+{
+	str_buf c(80);
+	c += '[';
+	for (size_t i = 0; i < _size; ++i) {
+		Real v = (*this)[i];
+		char *b = v.to_s(f);
+		c += b;
+		if (i < _size-1) c += ", ";
+		delete[] b;
+	}
+	c += ']';
+	char *s = new char[c.size()+1];
+	strcpy(s, c.c_str());
+	return s;
+}
+
+template <> char *Matrix::to_s(const char *f) const
+{
+	str_buf e(80);
+	sprintf(e.c_buf(), "<{%ld, %ld}, %ld, [", r, c, a); ++e;
+	for (size_t i = 0; i < r; ++i) {
+		Vector v = row(i);
+		char *b = v.to_s(f);
+		e += b;
+		if (i < r-1) e += ',';
+		delete[] b;
+	}	e += "]>";
+	char *s = new char[e.size()+1];
+	strcpy(s, e.c_str());
+	return s;
+}
+
+template <> char *Matrix_view::to_s(const char *f) const
+{
+	str_buf e(80);
+	sprintf(e.c_buf(), "<{%ld, %ld}, %ld, @[", r, c, a); ++e;
+	for (size_t i = 0; i < r; ++i) {
+		Vector v = row(i);
+		char *b = v.to_s(f);
+		e += b;
+		if (i < r-1) e += ',';
+		delete[] b;
+	}	e += "]>";
+	char *s = new char[e.size()+1];
+	strcpy(s, e.c_str());
+	return s;
+}
+
+#ifdef USE_RANDOM
+template <> Real Real::qdrand(size_t N)
+{
+	static std::random_device rnd;
+	static std::mt19937 mt(rnd());
+	static const double m_const = 4.6566128730773926e-10;  /* = 2^{-31} */
+	double m = m_const;
+	Real r(N);
+
+/* Strategy:  Generate 31 bits at a time, using lrand48 
+     random number generator.  Shift the bits, and repeat
+     7 times. */
+
+	for (int i = 0; i < 7; i++, m *= m_const) {
+		double d = mt() * m;
+		r += d;
+	}
+	return r - 1.0;
+}
+
+template <> Real Real::debug_rand(size_t N)
+{
+	static std::random_device rnd;
+	static std::mt19937 mt(rnd());
+	if (std::rand() % 2 == 0) return qdrand(N);
+
+	int expn = 0;
+	Real a(N);
+	double d;
+	for (int i = 0; i < 4; i++) {
+		d = std::ldexp(mt() / static_cast<double>(RAND_MAX), -expn);
+		a += d;
+		expn = expn + 54 + mt() % 200;
+	}
+	return a;
+}
+
+template <> Real Real::uniform_rand(size_t N, double a, double b)
+{
+	static std::random_device rnd;
+	static std::mt19937_64 mt(rnd());
+	std::uniform_real_distribution<> dist(a, b);
+	Real d(N);
+	for (size_t i = 0; i <= N; i++) d[i] = dist(mt);
+	d.normalize(dist(mt));
+	return d / static_cast<double>(N+2);
+}
+
+template <> Real Real::normal_rand(size_t N, double a, double b)
+{
+	static std::random_device rnd;
+	static std::mt19937_64 mt(rnd());
+	std::normal_distribution<> dist(a, b);
+	Real d(N);
+	for (size_t i = 0; i <= N; i++) d[i] = dist(mt);
+	d.normalize(dist(mt));
+	return d / static_cast<double>(N+2);
+}
+#endif
+
+void debug_sin_table(real_precision N)
+{
+	char fmt[80];
+	sprintf(fmt, "%%.%de\n", _ndigits(N));
+	for (int i = 0; i < 256; ++i) {
+		Real s = real_sin_table(N, i);
+		s.print(fmt);
+	}
+}
+
+void debug_cos_table(real_precision N)
+{
+	char fmt[80];
+	sprintf(fmt, "%%.%de\n", _ndigits(N));
+	for (int i = 0; i < 256; ++i) {
+		Real s = real_cos_table(N, i);
+		s.print(fmt);
+	}
+}
+
+void debug_inv_fact(real_precision N)
+{
+	char fmt[80];
+	sprintf(fmt, "%%.%de\n", _ndigits(N));
+	for (int i = 0; i < 15; ++i) {
+		Real s = real_inv_fact(N, i);
+		s.print(fmt);
+	}
+}
+
+real_const<double> _2pi     (real_const_table[0]);
+real_const<double> _pi      (real_const_table[1]);
+real_const<double> _pi2     (real_const_table[2]);
+real_const<double> _pi4     (real_const_table[3]);
+real_const<double> _3pi4    (real_const_table[4]);
+real_const<double> _e       (real_const_table[5]);
+real_const<double> _log2    (real_const_table[6]);
+real_const<double> _log10   (real_const_table[7]);
+real_const<double> _max     (real_const_table[8]);
+real_const<double> _safe_max(real_const_table[9]);
+real_const<double> _nan     (real_const_table[10]);
+real_const<double> _inf     (real_const_table[11]);
+real_const<double> _min_normalized(real_const_table[12]);
+real_const<double> _eps     (real_const_table[13]);
+real_const<double> _pi1024  (real_const_table[14]);
+real_const<int>    _ndigits (real_const_ndigits);
+
+template <> inline int sprintg(str_buf& c, const Real& v, const char *f)
+{
+	int width = 0, prec = 5; rios::fmtflags fmt = rios::scientific;
+	if (f && *f == '%') {
+		char *b = const_cast<char*>(f) + 1, *a = NULL, *c = b;
+		while ((*c >= '0' && *c <= '9') || *c == '.') { if (*c == '.') a = c + 1; ++c; }
+		if (*c >= 'e' && *c <= 'g') { width = atoi(b); if (a) prec = atoi(a); }
+		if (*c == 'f') fmt = rios::fixed; else
+		if (*c == 'g') {
+			int d = floor(log10(fabs(v(0))));
+			if (abs(d) <= prec) fmt = rios::fixed;
+		}
+	}
+	char *str = v.to_string(prec, width, fmt, false, false);
+	if (fmt == rios::fixed) {
+		char *s = str; while(*s)++s;
+		do { if (*--s != '0') break; *s = '\0'; } while (s != str);
+		if (*s == '.') *s = '\0';
+	}
+	c += str;
+	int n = strlen(str);
+	delete[] str;
+	return n;
+}
+
+template <> void poly_to_s(str_buf& c, int N, const int *size, const double *data, const char *f)
+{
+	int n = *size;
+	if (N == 0) {
+		if (n == 0) {
+			sprintg<double>(c, *data, f);
+		} else {
+			c += '<';
+			Real a(size_t(n), data, 0);
+			sprintg<Real>(c, a, f);
+			c += '>';
+		}
+	}
+	else {
+		c += (N == 1) ? '(' : '[';
+		int m = size[N] + 1;
+		for (int i = N; i > 1; --i) m *= size[i-1];
+		for (int i = 0; i < n; ++i) {
+			poly_to_s(c, N-1, size+1, &data[i*m], f);
+			if (i < n-1) c += ',';
+		}
+		c += (N == 1) ? ')' : ']';
+	}
+}
+