pspline 5.0.5 → 5.1.0

data/ext/pspline/include/basis/real_inline.h

@@ -0,0 +1,442 @@
+#ifndef REAL_INLINE_H
+#define REAL_INLINE_H
+
+#define _QD_SPLITTER 134217729.0               // = 2^27 + 1
+#define _QD_SPLIT_THRESH 6.69692879491417e+299 // = 2^996
+
+template <typename T>
+inline T quick_two_sum(T a, T b, T &err)
+{
+	T s = a + b;
+	err = b - (s - a);
+	return s;
+}
+
+template <typename T>
+inline T quick_two_diff(T a, T b, T &err)
+{
+	T s = a - b;
+	err = (a - s) - b;
+	return s;
+}
+
+template <typename T>
+inline T two_sum(T a, T b, T &err)
+{
+	T s = a + b;
+	T c = s - a;
+	err = (a - (s - c)) + (b - c);
+	return s;
+}
+
+template <typename T>
+inline T two_diff(T a, T b, T &err)
+{
+	T s = a - b;
+	T c = s - a;
+	err = (a - (s - c)) - (b + c);
+	return s;
+}
+
+template <typename T>
+inline void split(T a, T &hi, T &lo)
+{
+	T temp;
+	if (a > _QD_SPLIT_THRESH || a < -_QD_SPLIT_THRESH) {
+		a *= 3.7252902984619140625e-09;  // 2^-28
+		temp = _QD_SPLITTER * a;
+		hi = temp - (temp - a);
+		lo = a - hi;
+		hi *= 268435456.0;          // 2^28
+		lo *= 268435456.0;          // 2^28
+	} else {
+		temp = _QD_SPLITTER * a;
+		hi = temp - (temp - a);
+		lo = a - hi;
+	}
+}
+
+template <typename T>
+inline T two_prod(T a, T b, T &err)
+{
+	T a_hi, a_lo, b_hi, b_lo;
+	T p = a * b;
+	split(a, a_hi, a_lo);
+	split(b, b_hi, b_lo);
+	err = ((a_hi * b_hi - p) + a_hi * b_lo + a_lo * b_hi) + a_lo * b_lo;
+	return p;
+}
+
+template <typename T>
+inline T two_sqr(T a, T &err)
+{
+	T hi, lo;
+	T q = a * a;
+	split(a, hi, lo);
+	err = ((hi * hi - q) + 2.0 * hi * lo) + lo * lo;
+	return q;
+}
+
+template <typename T>
+inline T two_sqr2(T a0, T a1, T &err)
+{
+	T p = two_sqr(a0, err);
+	err += 2.0 * a0 * a1;
+	err += a1 * a1;
+	return quick_two_sum(p, err, err);
+}
+
+template <typename T>
+inline void three_sum(T &p, T &q, T &r)
+{
+	T t1, r1, r2;
+	t1 = two_sum( p,  q, r1);
+	 p = two_sum( r, t1, r2);
+	 q = two_sum(r1, r2,  r);
+}
+
+template <typename T>
+inline void three_sum2(T &p, T &q, T r)
+{
+	T t1, r1, r2;
+	t1 = two_sum(p,  q, r1);
+	 p = two_sum(r, t1, r2);
+	 q = r1 + r2;
+}
+
+template <typename T>
+inline T four_diff1(T a0, T a1, T b, T &e)
+{
+	a0 = two_diff(a0, b, b);
+	b += a1;
+	return quick_two_sum(a0, b, e);
+}
+
+template <typename T>
+inline T four_diff2(T a0, T a1, T b0, T b1, T &e)
+{
+	a0 = two_diff(a0, b0, b0);
+	b0 += a1;
+	b0 -= b1;
+	return quick_two_sum(a0, b0, e);
+}
+
+template <typename T>
+inline T four_sum1(T a0, T a1, T b, T &e)
+{
+	T s = two_sum(a0, b, e);
+	 e += a1;
+	return quick_two_sum(s, e, e);
+}
+
+template <typename T>
+inline T four_sum2(T a0, T a1, T b0, T b1, T &e)
+{
+	T s = two_sum(a0, b0, e);
+	 e += (a1 + b1);
+	return quick_two_sum(s, e, e);
+}
+
+template <typename T>
+inline void four_sum3(T &s0, T &s1, T &s2, T t)
+{
+	s0 = two_sum(t, s0, t);
+	s1 = two_sum(t, s1, t);
+	s2 += t;
+}
+
+template <typename T>
+inline T four_prod1(T a0, T a1, T b, T &e)
+{
+	T p = two_prod(a0, b, e);
+	 e += (a1 * b);
+	return quick_two_sum(p, e, e);
+}
+
+template <typename T>
+inline T four_prod2(T a0, T a1, T b0, T b1, T &e)
+{
+	T p = two_prod(a0, b0, e);
+	 e += (a0 * b1 + a1 * b0);
+	return quick_two_sum(p, e, e);
+}
+
+template <typename T>
+inline T quick_three_accum(T &a, T &b, T c)
+{
+	T s; bool za, zb;
+
+	s = two_sum(b, c, b);
+	s = two_sum(a, s, a);
+
+	za = (a != 0.0);
+	zb = (b != 0.0);
+
+	if (za && zb) return s;
+
+	if (!zb) { b = a; } a = s;
+	return 0.0;
+}
+
+template <typename T>
+inline void quick_renorm(int N, T *w, T c)
+{
+	if (N == 0) w[0] = quick_two_sum(w[0], c, c);
+	else
+	{
+		T t[N+1];
+		for (int i = 0; i < N; ++i) {
+			for (int j = N-i; j >= 0; --j)
+				c = quick_two_sum(i == 0 ? w[j] : t[j], c, t[j]);
+			w[i] = c; c = t[N-i];
+		}	w[N] = t[0] + t[1];
+	}
+}
+
+template <typename T>
+inline void renorm(int N, T *w, T &c)
+{
+	if (isinf(w[0])) return;
+
+	w[N] = quick_two_sum(w[N], c, c);
+	if (N > 0)
+		for (int i = N; i > 0; --i)
+			w[i-1] = quick_two_sum(w[i-1], w[i], w[i]);
+	if (N > 1) {
+		int k = 0, j = 2;
+		while (k < N) {
+			if (w[k+1] != 0) k++;
+				w[k] = quick_two_sum(w[k], w[j], w[k+1]);
+			if (++j > N) break;
+		}
+		if (w[k+1] != 0) k++;
+			w[k] = quick_two_sum(w[k], c, k == N ? c : w[k+1]);
+		for (int i = k + 2; i <= N; ++i) w[i] = 0;
+	}
+}
+
+template <typename T>
+inline void renorm(int N, T *w)
+{
+	if (isinf(w[0])) return;
+
+	if (N > 0)
+		for (int i = N; i > 0; --i)
+			w[i-1] = quick_two_sum(w[i-1], w[i], w[i]);
+	if (N > 1) {
+		int k = 0, j = 2;
+		while (k < N) {
+			if (w[k+1] != 0) k++;
+				w[k] = quick_two_sum(w[k], w[j], w[k+1]);
+			if (++j > N) break;
+		}
+		for (int i = k + 2; i <= N; ++i) w[i] = 0;
+	}
+}
+
+inline double _ldexp(double a, int b) { return ldexp(a, b); }
+inline double _floor(double a) { return floor(a); }
+inline double _atan2(double a, double b) { return atan2(a, b); }
+inline double _ceil(double a) { return ceil(a); }
+inline double _sqrt(double a) { return sqrt(a); }
+inline double _exp(double a) { return exp(a); }
+inline double _log(double a) { return log(a); }
+
+/* Computes the nearest integer to d. */
+template <typename T>
+inline T nint(T d)
+{
+	if (d == floor(d)) return d;
+	return floor(d + 0.5);
+}
+template <>
+inline double nint(double  d)
+{
+	if (d == _floor(d)) return d;
+	return _floor(d + 0.5);
+}
+
+/* Computes the truncated integer. */
+template <typename T>
+inline T aint(T d)
+{
+	return (d >= 0.0) ? floor(d) : ceil(d);
+}
+template <>
+inline double aint(double  d)
+{
+	return (d >= 0.0) ? _floor(d) : _ceil(d);
+}
+
+inline double sqr(double  t) { return t * t; }
+
+inline double _nint(double a) { return nint(a); }
+inline double _aint(double a) { return aint(a); }
+inline double _sqr(double a) { return sqr(a); }
+
+void qd_add(size_t, double*, double*, double );
+void qd_add(size_t, double*, double*, double*);
+void qd_sub(size_t, double*, double*, double );
+void qd_sub(size_t, double*, double*, double*);
+void qd_mul(size_t, double*, double*, double );
+void qd_mul(size_t, double*, double*, double*);
+void qd_div(size_t, double*, double*, double );
+void qd_div(size_t, double*, double*, double*);
+void qd_minus(size_t, double*, double*);
+void qd_abs(size_t, double*, double*);
+inline void qd_ass(size_t a, double *b, double *c) { for (size_t i = 0; i <= a; ++i) b[i] = c[i]; }
+bool qd_eq(size_t, double*, double*);
+bool qd_eq(size_t, double*, double );
+bool qd_lt(size_t, double*, double*);
+bool qd_lt(size_t, double*, double );
+bool qd_gt(size_t, double*, double*);
+bool qd_gt(size_t, double*, double );
+bool qd_le(size_t, double*, double*);
+bool qd_le(size_t, double*, double );
+bool qd_ge(size_t, double*, double*);
+bool qd_ge(size_t, double*, double );
+
+template <typename T = double> class real;
+
+template <typename T> real<T> operator + (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+	T x[L+1];
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; qd_add(L, x, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; qd_add(L, x, a.w, c); } else
+	{
+		qd_add(L, x, a.w, b.w);
+	}
+	return real<T>(L, x);
+}
+
+template <typename T> real<T> operator * (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+	T p[L+1];
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; qd_mul(L, p, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; qd_mul(L, p, a.w, c); } else
+	{
+		qd_mul(L, p, a.w, b.w);
+	}
+	return real<T>(L, p);
+}
+
+template <typename T> real<T> operator / (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+	T q[L+1];
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; qd_div(L, q, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; qd_div(L, q, a.w, c); } else
+	{
+		qd_div(L, q, a.w, b.w);
+	}
+	return real<T>(L, q);
+}
+
+template <typename T> bool operator == (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; return qd_eq(L, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; return qd_eq(L, a.w, c); } else
+	{
+		return qd_eq(L, a.w, b.w);
+	}
+}
+
+template <typename T> bool operator < (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; return qd_lt(L, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; return qd_lt(L, a.w, c); } else
+	{
+		return qd_lt(L, a.w, b.w);
+	}
+}
+
+template <typename T> bool operator > (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; return qd_gt(L, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; return qd_gt(L, a.w, c); } else
+	{
+		return qd_gt(L, a.w, b.w);
+	}
+}
+
+template <typename T> bool operator <= (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; return qd_le(L, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; return qd_le(L, a.w, c); } else
+	{
+		return qd_le(L, a.w, b.w);
+	}
+}
+
+template <typename T> bool operator >= (const real<T>& a, const real<T>& b)
+{
+	const size_t N = a.N, M = b.N;
+	const size_t L = (N >= M ? N : M);
+
+	if (N < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= N) ? a.w[i] : 0.0; return qd_ge(L, c, b.w); } else
+	if (M < L) { T c[L+1]; for (size_t i = 0; i <= L; ++i) c[i] = (i <= M) ? b.w[i] : 0.0; return qd_ge(L, a.w, c); } else
+	{
+		return qd_ge(L, a.w, b.w);
+	}
+}
+
+template <typename T> real<T> sqr(const real<T>& a)
+{
+	const size_t N = a.N;
+
+	if (N == 0) {
+		return real<T>(a.w[0] * a.w[0]);
+	} else
+
+	if (N == 1) {
+		double p[2];
+		p[0] = two_sqr2(a.w[0], a.w[1], p[1]);
+		return real<T>(N, p);
+	} else
+
+	return a * a;
+}
+
+template <typename T> real<T> npwr(const real<T>& a, int n)
+{
+	const size_t N = a.atom();
+	real<T> s(1.0, N);  /* current answer */
+
+	if (n != 0) {
+		real<T> r = a;   /* odd-case multiplier */
+		int w = abs(n);
+		if (w > 1)
+		/* Use binary exponentiation. */
+			while (w > 0) {
+				/* If odd, multiply by r. Note eventually w = 1, so this eventually executes. */
+				if (w % 2 == 1) s *= r;
+				w /= 2;
+				if (w > 0)      r *= r;
+			}
+		else s = r;
+		if (n < 0) s = (1.0 / s);
+	}
+	return s;
+}
+
+#endif

data/ext/pspline/include/basis/spline.h

@@ -0,0 +1,83 @@
+#ifndef _SPLINE_H_INCLUDED_
+#define _SPLINE_H_INCLUDED_
+
+//
+//	Ｂスプライン関数
+//
+class spline : public base_spline<>
+{
+	Vector *alp;
+
+  public:
+	// constructor
+	spline() : alp(NULL) {}
+	spline(int n, const Vector& x, const Vector& y, int j, int d = 0, int *dp = NULL);
+	spline(const spline& s);
+	// destructor
+	~spline() { delete alp; }
+	// operator
+	spline& operator = (const spline& s);
+	void ass(Vector& a) { a = *alp; }
+	Real operator[](const Real& t) const
+	{ assert(t >= x_min() || t <= x_max()); return apply(t, *alp); }
+	Real operator[](int i) const
+	{ assert(i < 0 || i >= Icox()); return (*alp)[i]; }
+	Real operator()(const Real& t, const Vector& a, int b = 0) const
+	{ assert(t >= x_min() || t <= x_max() || b <= Jisu()); return apply(t, a, b); }
+//	void bibun_keisu(int i, Matrix& m) const { return base_spline::bibun_keisu(i, m); }
+	Real bibun(const Real& t, int d = 1) const;
+	Real sekibun(const Real& t, int s) const { return base_spline::sekibun<double>(t, *alp, s); }
+	Real sekibun(const Real& x) const { return base_spline::sekibun(x, *alp); }
+	Real sekibun(const Real& x, const Vector& clp) const { return base_spline::sekibun(x, clp); }
+};
+//
+//	Ｂスプライン補間
+//
+class Bspline
+{
+	Matrix *alp; spline *sp;
+
+  public:
+	// constructor
+	Bspline() : alp(NULL), sp(NULL) {}
+	// bspline : 境界条件のないＢスプライン補間
+	Bspline(int n, const Vector&, const Vector&, int j);
+	// cspline : 関数値境界条件によるＢスプライン補間
+	Bspline(int n, const Vector&, const Vector&, int j, int d, const Vector&);
+	// dspline : 微分境界条件によるＢスプライン補間
+	Bspline(int n, const Vector&, const Vector&, int j, int d, int *Dp, const Vector&);
+	// tspline : 周期境界条件によるスプライン補間
+	Bspline(int n, const Vector&, const Vector&, int j, int t);
+	// copy constructor
+	Bspline(const Bspline& b);
+	// destructor
+	~Bspline() { delete sp; delete alp; }
+	// operator
+	Bspline& operator = (const Bspline& b);
+	int Imax() const { return sp->Imax(); }
+	int Icox() const { return sp->Icox(); }
+	int Maxq() const { return sp->Maxq(); }
+	int Rank() const { return sp->Rank(); }
+	int Jisu() const { return sp->Jisu(); }
+	int Shuki()const { return sp->Shuki();}
+	Real operator[](const Real& t) const { return (*sp)[t]; }
+	Real operator()(const Real& t, int b = 0) const
+	{
+		if (b > Jisu()) throw "out of range, Bspline()";
+		auto v = alp->row((b > 0) ? b : 0);
+		return (*sp)(t, v, b);
+	}
+	Real x_max() const { return sp->x_max(); }
+	Real x_min() const { return sp->x_min(); }
+	Real bibun(const Real& t, int jbn = 1)  const { return sp->bibun(t, jbn); }
+	Real sekibun(const Real& t, int jsk)    const { return sp->sekibun(t, jsk); }
+	Real sekibun(const Real& ta, const Real& tb) const { return sp->sekibun(tb, -1) - sp->sekibun(ta, -1); }
+	Real sekibun(const Real& x) const { return sp->Shuki() ? sp->sekibun(x, alp->row(0)) : sp->sekibun(x); }
+};
+
+//
+//	misc
+//
+int plots(const Bspline&, const Vector&, Vector&, Vector&, int, int = 0);
+
+#endif