pspline 5.0.5 → 5.1.0

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

@@ -1,137 +1,145 @@
-#ifndef _BASIS_H_INCLUDED_
-#define _BASIS_H_INCLUDED_
-#include <stdlib.h>
-#include <string.h>
-
-template <typename T>
-int deboor(int, T*, int, T, T*, int&, int = 0);
-template<typename T>
-void deboor_cox(int, T*, int, T, T*, int&, int, int = 0);
-
-/*******************************************************************************
-	Ｂスプライン基底（節点列によるＢスプライン関数計算）
-*******************************************************************************/
-template <typename S = double> class base_spline
-{
-  protected:
-	int imax, icox, rank, jisu, shuki, maxq;
-	S *knots;
-  public:
-	// constructor
-	base_spline() : knots(NULL) {}
-	base_spline(int, const S*, int, int = 0, int* = NULL);
-	base_spline(const S*, int, int, int);
-	base_spline(const base_spline&);
-	// destructor
-	~base_spline() { delete[] knots; }
-	// operator
-	base_spline& operator=(const base_spline&);
-	int ranks(int b=0) const {return rank-b;}
-	int Imax() const { return imax; }
-	int Icox() const { return icox; }
-	int Rank() const { return rank; }
-	int Jisu() const { return jisu; }
-	int Shuki()const { return shuki;}
-	int Maxq() const { return maxq; }
-	S *Knots() const { return knots;}
-	int Kset(S x) const;
-	S x_max() const {return knots[icox];}
-	S x_min() const {return knots[jisu];}
-	S operator[] (int i) const {return knots[i];}
-	int basic(S, int, S*, int = 0) const;
-	void   bibun_keisu(int, int, S**) const;
-	void sekibun_keisu(int, int, S**) const;
-	void gyoretu(S**, int, const S* = NULL, const int* = NULL) const;
-	parray<S> basis(S, int = 0) const;
-	parray<S> bases(S, int = 0) const;
-/*******************************************************************************
-	線形結合係数の適用 Σa[i]*b[i]; i = kset-Kai+1,...,kset;
-	  d: d > 0 ? 微分階数 : d == 0 ? 補間値
-	  t: データ点の座標値
-	alp: 線形結合係数の配列
-*******************************************************************************/
-template <typename T> T apply(S t, T *alp, int d = 0) const
-{
-	int k = rank - d;
-	S *b = T_ALLOC(S, icox);
-	int kset = basic(t, icox, b, k);
-	k = kset - k + 1;
-	if (k < 0) k = 0;
-	T sum = 0.0;
-	for (int i = k; i <= kset; i++) sum += alp[i] * b[i];
-	FREE(b);
-	return sum;
-}
-/*******************************************************************************
-	定積分の計算
-*******************************************************************************/
-template <typename T> T sekibun(S x, T *alp) const
-{
-	S  *q = knots;
-	int K = rank, J = K - 1;
-	int Imax = Kset(x);
-	T sum = 0.0;
-	for (int ql = J; ql <= Imax; ++ql) {
-		S t = q[ql];
-		parray<S> fl = bases(t, J);
-		int ks = fl(0), kt = fl(1), kset = ks + J;
-		S *ft = *fl, Qh = (ql < Imax ? q[ql+1] : x) - t;
-		for (int i = ks; i <= kset; ++i) {
-			S Qs = 0.0; int j = i - ks + K * kt;
-			for (int r = K; r > 0; --r) {
-				S Bik = ft[j -= kt];
-				Qs = (Qs + Bik) * Qh / (S)r;
-			}
-			sum += alp[i] * Qs;
-		}
-	}
-	return sum;
-}
-/*******************************************************************************
-	高階積分の計算
-*******************************************************************************/
-template <typename T> T sekibun(S t, const T *alp, int Jsk) const
-{
-	int ks, kset, k = rank + Jsk;
-	S b[k];
-	ks = deboor<S>(rank, knots, icox, t, b, kset, k);
-	T *a[2], *w = new T[2*(kset+1)]; a[0] = w; a[1] = &w[kset+1];
-	for (int i = 0; i <= kset; ++i) a[Jsk%2][i] = alp[i];
-	while (Jsk) {
-		T *a0 = a[Jsk%2], *a1 = a[(Jsk+1)%2];
-		for (int i = 0; i <= kset; ++i)
-			a1[i] = (i > 0 ? a1[i-1] : 0.0) + a0[i] * (knots[i+(k-Jsk)] - knots[i]) / (k-Jsk);
-		Jsk--;
-	}
-	T sek = 0.0;
-	for (int i = ks > 0 ? ks : 0; i <= kset; ++i) sek += a[0][i] * b[i-ks];
-	delete[] w;
-	return sek;
-}
-/*******************************************************************************
-	多次元積分の計算
-*******************************************************************************/
-template <typename T> void sekibun(S x, T *alp, int n, T *p) const
-{
-	 S *q = knots;
-	int K = rank, J = K - 1;
-	int Imax = Kset(x);
-	for (int ql = J; ql <= Imax; ++ql) {
-		S t = q[ql];
-		parray<S> fl = bases(t, J);
-		int ks = fl(0), kt = fl(1), kset = ks + J;
-		S *ft = *fl, Qh = (ql < Imax ? q[ql+1] : x) - t;
-		for (int i = ks; i <= kset; ++i) {
-			S Qs = 0.0; int j = i - ks + K * kt;
-			for (int r = K; r > 0; --r) {
-				S Bik = ft[j -= kt];
-				Qs = (Qs + Bik) * Qh / (S)r;
-			}
-			for (int k = 0; k < n; ++k) p[k] += alp[n*i+k] * Qs;
-		}
-	}
-}
-
-};	// end of base_spline;
-
-#endif
+#ifndef _BASIS_H_INCLUDED_
+#define _BASIS_H_INCLUDED_
+#include <assert.h>
+
+template <typename P, typename T>
+int deboor(int, const P&, int, const T&, P&, int&, int = 0);
+template <typename P, typename T>
+void deboor_cox(int, const P&, int, const T&, P&, int&, int, int = 0);
+
+/*******************************************************************************
+	Ｂスプライン基底（節点列によるＢスプライン関数計算）
+*******************************************************************************/
+template <typename S = double> class base_spline
+{
+  protected:
+	int imax, icox, rank, jisu, shuki, maxq;
+	varray<S> *knots;
+	base_spline *Base() { return this; }
+  public:
+	// default constructor
+	base_spline() : knots(NULL) {}
+	// constructor
+	base_spline(int, const varray<S>&, int, int = 0, int* = NULL);
+	base_spline(const varray<S>&, int, int, int);
+	// copy constructor
+	base_spline(const base_spline&);
+	// destructor
+	~base_spline() { delete knots; }
+	// assignment operator
+	base_spline& operator=(const base_spline&);
+	// properties
+	int Imax() const { return imax; }
+	int Icox() const { return icox; }
+	int Rank() const { return rank; }
+	int Jisu() const { return jisu; }
+	int Shuki()const { return shuki;}
+	int Maxq() const { return maxq; }
+	varray<S>& Knots() const { return *knots; }
+	int Kset(const real<S>& x) const;
+	real<S> x_max() const {return (*knots)[icox];}
+	real<S> x_min() const {return (*knots)[jisu];}
+	real<S> operator[] (int i) const {return (*knots)[i];}
+	int basic(const real<S>&, int, varray<S>&, int = 0) const;
+	void   bibun_keisu(int, marray<S>&) const;
+	void sekibun_keisu(int, marray<S>&) const;
+	void gyoretu(marray<S>&, int, const varray<S>&, const int* = NULL) const;
+	marray<S> gyoretu(const Int&, const varray<S>&, const int* = NULL) const;
+	parray<S> basis(const real<S>&, int = 0) const;
+	parray<S> bases(const real<S>&, int = 0) const;
+	parray<S> sekibun(const real<S>&, int) const;
+	void print() const;
+/*******************************************************************************
+	線形結合係数の適用 Σa[i]*b[i]; i = kset-Kai+1,...,kset;
+	  d: d > 0 ? 微分階数 : d == 0 ? 補間値 : 高階積分
+	  t: データ点の座標値
+	alp: （微分）線形結合係数の配列
+*******************************************************************************/
+template <typename T> real<T> apply(const real<S>& t, const varray<T>& alp, int d = 0) const
+{
+	if (d >= 0) {
+		assert(rank > d);
+		int k = rank - d;
+		varray<S> b(size_t(icox), t.atom());
+		int ks = basic(t, icox, b, k);
+		int kset = ks + k - 1;
+		if (ks < 0) ks = 0;
+		real<T> sum(T(), t.atom());
+		for (int i = ks; i <= kset; i++) sum += alp[i] * b[i];
+		return sum;
+	} else
+		return sekibun<T,real<T>,varray<T> >(t, alp, d);
+}
+/*******************************************************************************
+	不定積分の計算
+*******************************************************************************/
+template <typename T> real<T> sekibun(const real<S>& x, const varray<T>& alp) const
+{
+	const varray<S>& q = *knots;
+	int K = rank, J = K - 1;
+	int Imax = Kset(x);
+	real<T> sum(alp.atom());
+	for (int ql = J; ql <= Imax; ++ql) {
+		real<S> t = q[ql];
+		parray<S> fl = bases(t, J);
+		int ks = fl.offset(), kset = ks + J;
+		real<S> Qh = (ql < Imax ? q[ql+1] : x) - t;
+		for (int i = ks; i <= kset; ++i) {
+			real<S> Qs = fl.saylor(i - ks, Qh);
+			sum += alp[i] * Qs;
+		}
+	}
+	return sum;
+}
+/*******************************************************************************
+	高階積分の計算
+*******************************************************************************/
+template <typename T, typename P = real<T>, typename Q = varray<T> >
+P sekibun(const real<S>& t, const Q& alp, int Jsk) const
+{
+	assert(Jsk < 0);
+	size_t A = alp.atom();
+	int k = rank - Jsk;
+	varray<S> b(size_t(k), t.atom());
+	const varray<S>& q = *knots;
+	int kset, ks = deboor(rank, q, icox, t, b, kset, k);
+	Q a(size_t(kset+1), A);
+	for (int i = 0; i <= kset; ++i) a[i] = alp[i];
+	while (Jsk < 0) {
+		P ab(T(), A);
+		for (int i = 0; i <= kset; ++i) {
+			real<S> w = (q[i+(k+Jsk)] - q[i]) / S(k+Jsk);
+			a[i] = ab + a[i] * w; ab = a[i];
+		}
+		Jsk++;
+	}
+	P sek(T(), A);
+	for (int i = ks > 0 ? ks : 0; i <= kset; ++i) sek += a[i] * b[i-ks];
+	return sek;
+}
+/*******************************************************************************
+	多次元積分の計算
+*******************************************************************************/
+template <typename T> varray<T> sekibun(const real<S>& x, const marray<T>& clp) const
+{
+	const varray<S>& q = *knots;
+	int K = rank, J = K - 1;
+	int Imax = Kset(x);
+	varray<T> p(T(), clp.cols(), clp.atom());
+	for (int ql = J; ql <= Imax; ++ql) {
+		real<S> t = q[ql];
+		parray<S> fl = bases(t, J);
+		int ks = fl.offset(), kset = ks + J;
+		real<S> Qh = (ql < Imax ? q[ql+1] : x) - t;
+		for (int i = ks; i <= kset; ++i) {
+			real<S> Qs = fl.saylor(i - ks, Qh);
+			size_t n = p.size();
+			for (size_t k = 0; k < n; ++k) p[k] += clp[i][k] * Qs;
+		}
+	}
+	return p;
+}
+
+};	// end of base_spline;
+
+#endif

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

@@ -1,152 +1,188 @@
-#ifndef _FFT_H_INCLUDED_
-#define _FFT_H_INCLUDED_
-
-template <typename T> bool rft(T *, size_t, int);	// 実数値高速フーリエ変換
-template <typename T> bool cft(T *, size_t, int);	// 複素高速フーリエ変換（実数値配列引数）
-
-template <typename T = double, typename S = T> struct fft
-{
-
-static bool complex_forward(T *dat, int N)  { return cft(dat, N << 1, 1);  }
-
-static bool complex_backward(T *dat, int N) { return cft(dat, N << 1, 0);  }
-
-static bool complex_inverse(T *dat, int N)  { return cft(dat, N << 1, -1); }
-
-static bool complex_transform(T *dat, int N, int f) { return cft(dat, N << 1, f); }
-
-static void half_en_pack(double *data, size_t n, double *dfft)
-{
-	size_t nn, i, j;
-	double *data1 = data, *data2 = data + n;
-	
-	nn = n + n;
-	data1[0] = dfft[0]; data2[0] = dfft[1];
-	for (i = 2; i < n; i += 2) {
-		j = nn - i;
-		data1[i-1] = 0.5*(dfft[ j ] + dfft[ i ]);
-		data1[ i ] = 0.5*(dfft[i+1] - dfft[j+1]);
-		data2[i-1] = 0.5*(dfft[i+1] + dfft[j+1]);
-		data2[ i ] = 0.5*(dfft[ j ] - dfft[ i ]);
-	}
-	if (i == n) {
-		data1[i-1] = dfft[i]; data2[i-1] = dfft[i+1];
-	}
-}
-
-static void complex_get(T *data, int N, int i, T *val)
-{
-	i %= N;
-	if (N/2 < i ) i -= N;
-	if (i < -N/2) i += N;
-	T *var = &data[(i < 0 ? i + N : i) << 1];
-	val[0] = var[0];
-	val[1] = var[1];
-}
-	
-static bspline<T,S> *cfft(T *dat, int N, int j)
-{
-	T *data = new T[N << 1];
-	S *x = new S[N+1];
-	for (int i = 0; i < N; ++i) {
-		x[i] = i - N/2;
-		int r = i < N/2 ? i + N/2 + N%2 : i - N/2;
-		data[2*i]   = dat[r*2];
-		data[2*i+1] = dat[r*2+1];
-	}	x[N] = N - N/2;
-	bspline<T,S> *wfft = make_bspline<2,T,S>(x, N, data, j, 1);
-	delete[] x;
-	delete[] data;
-	return wfft;
-}
-
-static bool real_forward(T *dat, int N) { return rft(dat, N, 1); }
-
-static bool real_backward(T *dat, int N) { return rft(dat, N, 0); }
-
-static bool real_inverse(T *dat, int N) { return rft(dat, N, -1); }
-
-static bool real_transform(T *dat, int N, int f) { return rft(dat, N, f); }
-
-static void half_de_pack(double *dfft, size_t n, double *data)
-{
-	size_t nn, i, j;
-	double *data1 = data, *data2 = data + n;
-	
-	nn = n + n;
-	dfft[0] = data1[0]; dfft[1] = data2[0];
-	for (i = 2; i < n; i += 2) {
-		j = nn - i;
-		dfft[ i ] = data1[i-1] - data2[ i ];
-		dfft[i+1] = data2[i-1] + data1[ i ];
-		dfft[ j ] = data1[i-1] + data2[ i ];
-		dfft[j+1] = data2[i-1] - data1[ i ];
-	}
-	if (i == n) {
-		dfft[n] = data1[n-1]; dfft[n+1] = data2[n-1];
-	}
-}
-
-static void real_get(T *data, int N, int i, T *val)
-{
-	i %= N;
-	if (N/2 < i ) i -= N;
-	if (i < -N/2) i += N;
-	int j = (i < 0 ? -i : i) << 1;
-	T *var = &data[i == 0 ? 0 : j - 1];
-	val[0] = var[0];
-	if (i == 0 || j == N)
-		val[1] = 0;
-	else
-		val[1] = var[1] * (i < 0 ? -1 : 1);
-}
-
-static void half_get(T *data1, int N, int i, T *val)
-{
-	i %= N;
-	if (N/2 < i ) i -= N;
-	if (i < -N/2) i += N;
-	int j = (i < 0 ? -i : i) << 1;
-	T *data2 = data1 + N;
-	if (i == 0) {
-		val[0] = data1[0];
-		val[1] = data2[0];
-	} else if (j == N) {
-		val[0] = data1[N-1];
-		val[1] = data2[N-1];
-	} else if (i < 0) {
-		val[0] = data1[j-1] + data2[j];
-		val[1] = data2[j-1] - data1[j];
-	} else {
-		val[0] = data1[j-1] - data2[j];
-		val[1] = data2[j-1] + data1[j];
-	}
-}
-
-static bspline<T,S> *rfft(T *dat, int N, int j)
-{
-	T *data = new T[N << 1];
-	S *x = new S[N+1];
-	for (int i = 0; i < N; ++i) {
-		x[i] = i - N/2;
-		int r = i < N/2 ? N/2 - i : i - N/2;
-		if (i == 0 && N%2 == 0) {
-			data[0] = dat[2*r-1];
-			data[1] = 0.0;
-		} else if (i == N/2) {
-			data[2*i] = dat[0];
-			data[2*i+1] = 0.0;
-		} else {
-			data[2*i]   = dat[2*r-1];
-			data[2*i+1] = dat[2*r] * (i < N/2 ? -1 : 1);
-		}
-	}	x[N] = N - N/2;
-	bspline<T,S> *wfft = make_bspline<2,T,S>(x, N, data, j, 1);
-	delete[] x;
-	delete[] data;
-	return wfft;
-}
-
-};	// end of fft;
-
-#endif
+#ifndef _FFT_H_INCLUDED_
+#define _FFT_H_INCLUDED_
+#include "basis/marray_ext.h"
+#include "basis/real_inline.h"
+#include "basis/marray_class_ext.h"
+#include "basis/util.h"
+#include "basis/poly_array.h"
+#include "basis/basis.h"
+#include "basis/pspline.h"
+
+template <typename T> bool rfft(varray<T>&, size_t, int);	// 実数値高速フーリエ変換
+template <typename T> bool cfft(varray<T>&, size_t, int);	// 複素高速フーリエ変換（実数値配列引数）
+
+template <typename T = double, typename S = T> struct fft
+{
+
+static bool complex_forward(varray<T>& dat)  { return cfft(dat, dat.size(), 1);  }
+
+static bool complex_backward(varray<T>& dat) { return cfft(dat, dat.size(), 0);  }
+
+static bool complex_inverse(varray<T>& dat)  { return cfft(dat, dat.size(), -1); }
+
+static bool complex_transform(varray<T>& dat, int f) { return cfft(dat, dat.size(), f); }
+
+static varray<T> half_en_pack(const varray<T>& dfft)
+{
+	size_t nn = dfft.size(), n = nn >> 1, i, j;
+	varray<T> data(nn, dfft.atom());
+	const varray<T>& data1 = data[0], &data2 = data[n];
+	
+	data1[0] = dfft[0]; data2[0] = dfft[1];
+	for (i = 2; i < n; i += 2) {
+		j = nn - i;
+		data1[i-1] = 0.5*(dfft[ j ] + dfft[ i ]);
+		data1[ i ] = 0.5*(dfft[i+1] - dfft[j+1]);
+		data2[i-1] = 0.5*(dfft[i+1] + dfft[j+1]);
+		data2[ i ] = 0.5*(dfft[ j ] - dfft[ i ]);
+	}
+	if (i == n) {
+		data1[i-1] = dfft[i]; data2[i-1] = dfft[i+1];
+	}
+	return data;
+}
+
+static void complex_get(const varray<T>& data, int i, varray<T>& val)
+{
+	int nn = data.size(), N = nn >> 1;
+	i %= N;
+	if (N/2 < i ) i -= N;
+	if (i < -N/2) i += N;
+	const varray<T>& var = data[(i < 0 ? i + N : i) << 1];
+	val[0] = var[0];
+	val[1] = var[1];
+}
+	
+static bspline<T,S> *cfft_spline(const varray<T>& dfft, int j)
+{
+	int nn = dfft.size(), N = nn >> 1;
+	size_t A = dfft.atom();
+	poly_array<T> Y(Int{N, 2, int(A)});
+	varray<S> X(size_t(N+1), A);
+	const varray<T>& data = *Y;
+	for (int i = 0; i < N; ++i) {
+		X[i] = T(i - N/2);
+		int r = i < N/2 ? i + N/2 + N%2 : i - N/2;
+		data[2*i]   = dfft[r*2];
+		data[2*i+1] = dfft[r*2+1];
+	}	X[N] = T(N - N/2);
+	return new bspline<T,S>(Y, X, N+1, j, 1);
+}
+
+static bool real_forward(varray<T>& dat) { return rfft(dat, dat.size(), 1); }
+
+static bool real_backward(varray<T>& dat) { return rfft(dat, dat.size(), 0); }
+
+static bool real_inverse(varray<T>& dat) { return rfft(dat, dat.size(), -1); }
+
+static bool real_transform(varray<T>& dat, int f) { return rfft(dat, dat.size(), f); }
+
+static varray<T> half_de_pack(const varray<T>& data)
+{
+	size_t nn = data.size(), n = nn >> 1, i, j;
+	varray<T> dfft(nn, data.atom());
+	const varray<T>& data1 = data[0], &data2 = data[n];
+	
+	dfft[0] = data1[0]; dfft[1] = data2[0];
+	for (i = 2; i < n; i += 2) {
+		j = nn - i;
+		dfft[ i ] = data1[i-1] - data2[ i ];
+		dfft[i+1] = data2[i-1] + data1[ i ];
+		dfft[ j ] = data1[i-1] + data2[ i ];
+		dfft[j+1] = data2[i-1] - data1[ i ];
+	}
+	if (i == n) {
+		dfft[n] = data1[n-1]; dfft[n+1] = data2[n-1];
+	}
+	return dfft;
+}
+
+static void real_get(varray<T>& data, int i, varray<T>& val)
+{
+	int N = data.size();
+	i %= N;
+	if (N/2 < i ) i -= N;
+	if (i < -N/2) i += N;
+	int j = (i < 0 ? -i : i) << 1;
+	const varray<T>& var = data[i == 0 ? 0 : j - 1];
+	val[0] = var[0];
+	if (i == 0 || j == N)
+		val[1] = T();
+	else
+		val[1] = var[1] * (i < 0 ? -1 : 1);
+}
+
+static void half_get(varray<T>& data1, int i, varray<T>& val)
+{
+	int nn = data1.size(), N = nn >> 1;
+	i %= N;
+	if (N/2 < i ) i -= N;
+	if (i < -N/2) i += N;
+	int j = (i < 0 ? -i : i) << 1;
+	const varray<T>& data2 = data1[N];
+	if (i == 0) {
+		val[0] = data1[0];
+		val[1] = data2[0];
+	} else if (j == N) {
+		val[0] = data1[N-1];
+		val[1] = data2[N-1];
+	} else if (i < 0) {
+		val[0] = data1[j-1] + data2[j];
+		val[1] = data2[j-1] - data1[j];
+	} else {
+		val[0] = data1[j-1] - data2[j];
+		val[1] = data2[j-1] + data1[j];
+	}
+}
+
+static bspline<T,S> *rfft_spline(varray<T>& dat, int j)
+{
+	int N = dat.size();
+	size_t A = dat.atom();
+	poly_array<T> Y(Int{N, 2, int(A)});
+	varray<S> X(size_t(N+1), A);
+	const varray<T>& data = *Y;
+	for (int i = 0; i < N; ++i) {
+		X[i] = T(i - N/2);
+		int r = i < N/2 ? N/2 - i : i - N/2;
+		if (i == 0 && N%2 == 0) {
+			data[0] = dat[2*r-1];
+			data[1] = T();
+		} else if (i == N/2) {
+			data[2*i] = dat[0];
+			data[2*i+1] = T();
+		} else {
+			data[2*i] = dat[2*r-1];
+			data[2*i+1] = dat[2*r] * T(i < N/2 ? -1 : 1);
+		}
+	}	X[N] = T(N - N/2);
+	return new bspline<T,S>(Y, X, N+1, j, 1);
+}
+
+static varray<T> real_mul(const varray<T>& data1, const varray<T>& data2)
+{
+	size_t N = data1.size();
+	size_t A = data1.atom();
+	varray<T> result(N, A);
+	for (size_t i = 0; i <= N; i += 2) {
+		if (i == 0) result[ i ] = data1[ i ] * data2[ i ]; else
+		if (i == N) result[N-1] = data1[N-1] * data2[N-1]; else
+		{
+			result[i-1] = data1[i-1]*data2[i-1] - data1[i]*data2[ i ];
+			result[ i ] = data1[i-1]*data2[ i ] + data1[i]*data2[i-1];
+		}
+	}
+	return result;
+}
+
+static varray<T> half_mul(const varray<T>& data)
+{
+	size_t n = data.size(), N = n >> 1;
+	size_t A = data.atom();
+	varray<T> vect((T*)data, N, A);
+	return real_mul(vect, data[N]);
+}
+
+};	// end of fft;
+
+#endif