pspline 5.0.5 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dacedf68daad7cf3e2b1e3f8aa1e59ccce2408d
-  data.tar.gz: 948d586d9d991821a7e0d640ad9ef63fd98fc074
+  metadata.gz: 1f7cd8119c7e0de6c4f6a72d40a7a40c170835ec
+  data.tar.gz: e8a52f742dc9fb6ead4d2676ebee54f2e12a2cda
 SHA512:
-  metadata.gz: c61c3af1bfaed26c57d94e144ad9e6546a5e7a21e2b194d3a703f90640b2beafc87450e4752b1399cc452ecba6cf41e154dee27359912ef5977ba396946dd5d5
-  data.tar.gz: 386924860c51388e0ddbd74fc6e95dca67dd771556c13b2d58500e3b833bb476003cd40b539bd496862012f11371e9ecd4e8a1999cb05a4bea2baaba376244bb
+  metadata.gz: 5905c1d7434b3ce52b8502f418ec027f63a02c0f21de53c584dc455b79fdee10db99e64f5597674712c926bd679be88971c308aa3b5aac40fb08efecc77f4378
+  data.tar.gz: 03acfcff0d95f0762c69cd4d1a16d0ae6a82d3dd189793bd24f6db6229cfdb8c0082f4b19eebdca608d16ef2c12e8672f3960dc11277057b27e677208667734a

data/Gemfile

@@ -1,5 +1,5 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pspline.gemspec
-gemspec
-gem "rake-compiler"
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pspline.gemspec
+gemspec
+gem "rake-compiler"

data/README.md

@@ -1,43 +1,44 @@
-# Pspline
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/pspline`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'pspline'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install pspline
-
-## Usage
-
-See pspline.wiki at https://github.com/vsp2old/pspline .
-
-## Revision history
-
-5.0.0   Upload for test.   
-5.0.1	Upload for test.   
-5.0.2	Upload for release.   
-5.0.3	Add class PSPLINE::Rfft, class PSPLINE::Cfft.   
-5.0.4	Add method line_integral.   
-5.0.5	Add Multiple Bspline.   
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/vsp2old/pspline .
-
+# Pspline
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/pspline`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pspline'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pspline
+
+## Usage
+
+See pspline.wiki at https://github.com/vsp2old/pspline .
+
+## Revision history
+
+5.0.0   Upload for test.   
+5.0.1	Upload for test.   
+5.0.2	Upload for release.   
+5.0.3	Add class PSPLINE::Rfft, class PSPLINE::Cfft.   
+5.0.4	Add method line_integral.   
+5.0.5	Add Multiple Bspline.   
+5.1.0	4 double precision arithmetic.   
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/vsp2old/pspline .
+

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require "rake/extensiontask"
-
-Rake::ExtensionTask.new "pspline" do |ext|
-  ext.lib_dir = "lib/pspline"
-end
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "pspline" do |ext|
+  ext.lib_dir = "lib/pspline"
+end

data/bin/console

@@ -1,14 +1,14 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "pspline"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pspline"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -1,8 +1,8 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/pspline/basis.cpp

@@ -1,351 +1,394 @@
-#include <cstring>
-#include <cstdlib>
-#include <cstddef>
-#include <cstdio>
-#include <cassert>
-#include "bspline_Config.h"
-#include "basis/util.h"
-#include "basis/basis.h"
-
-static const double eps = 1.0e-10;
-
-/*******************************************************************************
-	de Boor-Cox の漸化式によるＢ−スプライン関数値の計算
-	  k: Ｂスプラインの階数（j+1）
-	  q: 節点の配列
-	cox: Ｂスプラインの基底数
-	  t: データ点の座標（q[j] <= t <= q[cox]）
-	  d: d > 0 ? スプライン階数 : 微分階数
-*******************************************************************************/
-template <typename T>
-int deboor(int k, T *q, int c, T t, T *b, int& kset, int d)
-{
-	int h = c-1, i = k-1, j, K = d > 0 ? d : k, L = k + d;
-	T a, q1, q2, dt;
-	
-	while (i < h) { if(q[i] <= t && t < q[i+1]) break; i++; }
-	kset = i; if (q[h] <= t && t < q[c] + eps) kset = h;
-	b[0] = 1;
-	for (j = 1; j < K; ++j) {
-		if (L) --L;
-		b[j] = 0;
-		for (i = 0; i < j; ++i) {
-			h = j - i;
-			if (L) {
-				q1 = q[kset + h] - t;
-				q2 = t - q[kset - i];
-				dt = q1 + q2;
-				a = 0; if (dt > 0.0) a = b[h-1] / dt;
-				b[ h ] += a * q2;	// 決定項
-				b[h-1]  = a * q1;	// 準備項
-			} else {
-				dt = q[kset + h] - q[kset - i];
-				a = 0; if (dt > 0.0) a = b[h-1] * (T)j / dt;
-				b[ h ] += a;	// 決定項
-				b[h-1] = -a;	// 準備項
-			}
-		}
-	}
-	return kset - j + 1;
-}
-/*******************************************************************************
-	de Boor-Cox の漸化式によるＢ−スプライン関数値の計算
-	  K: Ｂスプラインの階数（j+1）
-	  q: 節点の配列
-	cox: Ｂスプラインの基底数
-	  t: データ点の座標（q[j] <= t <= q[cox]）
-	  J: 漸化式の適用回数
-	  L: (0 >= L >= -j) ? 微分階数
-*******************************************************************************/
-template<typename T>
-void deboor_cox(int K, T *q, int cox, T t, T *b, int &kset, int J, int L)
-{
-	int M = J + L;
-	int H = M + K + L;
-	if (J == 0 && M >= 0) {
-		int j = K - 1, c = cox - 1;
-		for(int i=j;i<c;++i)if(q[i]<=t && t<q[i+1]){kset=i;break;}
-		if(q[c]<=t && t<=q[cox]+eps){kset=c;}
-		b[0] = 1;
-	} else if (M >= 0 || H < 0) {
-		int j = J - (M < 0 ? M + 1 : 0);
-		T *b0 = &b[j+1];
-		deboor_cox(K, q, cox, t, b0, kset, J-1, L+1);
-		b[j] = 0.0;
-		for(int i = 0; i < j; ++i) {
-			int h = j - i;
-			T a, q1, q2, dt;
-			if (L >= 0) {
-				q1 = q[kset + h] - t;
-				q2 = t - q[kset - i];
-				dt = q1 + q2;
-				a = 0; if (dt > 0.0) a = b0[h-1] / dt;
-				b[ h ] += a * q2;
-				b[h-1]  = a * q1;
-			} else {
-				dt = q[kset + h] - q[kset - i];
-				a = 0; if (dt > 0.0) a = b0[h-1] * (T)j / dt;
-				b[ h ] += a;
-				b[h-1] = -a;
-			}
-		}
-	}
-}
-/*******************************************************************************
-	シェーンバーグ・ホイットニー条件を満たす節点の設定
-    q0, ..., qj, qk, ..., qi, ..., qc-1, qc, ..., qc+j
-    x0, ..., x0, | , ..., | , ..., | , xn-1, ..., xn-1
-            (x0+xk)/2 (xi-k+xi)/2 (xn-k-1+xn-1)/2
-	 q : 節点の配列
-	 m : 節点配列の長さ (c + k)
-	 c : スプライン基底の個数
-	 n : データ点の個数
-	 k : スプライン階数 (k <= n)
-	 d : 境界条件数 (d < k)
-	 s : 周期
-	 x : データ点の配列（x == NULL: パラメトリックスプラインを示す）
-	ms : 
-*******************************************************************************/
-template<typename T>
-void setten(T *q, int m, int c, int n, int k, int d = 0, int s = 0, const T *x = NULL, const int *ms = NULL)
-{
-	if (s == 0)
-		for (int i = 0; i < m; i++)
-			if (x)		/* シェーンバーグ・ホイットニー条件 */
-				q[i] = i < k ? x[0] : i < c ? (x[i-k] + x[i-d]) / 2.0 : x[n-1];
-			else		/* パラメトリック */
-				q[i] = i < k ? 0 : i < c ? i - T(k+d) / 2.0 : n-1;
-	else
-	if (s > 0)			/* 周期境界条件による節点の設定 */
-		for (int i = 0; i < m; i++) {
-			 int j = i - k + 1;
-			if (x)
-				q[i] = j < 0 ? x[0] + x[j+s] - x[s] : j <= s ? x[j] : x[s] + x[j-s] - x[0];
-			else
-				q[i] = j;
-		}
-	else
-	if (ms) {
-		int k0 = k, n1, k1;
-		while (s++) {
-			n1 = *ms++; k1 = *ms++;
-			setten(q, k0+n1-1, k0+n1-1, n1, k0, 0, 0, x);
-			q += k0+n1-1; m -= k0+n1-1; c -= n1-1; n -= n1-1; k0 = k1; x += n1-1;
-		}	setten(q, m, c, n, k0, 0, 0, x);
-	}
-}
-/*******************************************************************************
-	初期化（d == 0 ? 境界条件のないスプライン補間）
-	n: データ点の個数
-	x: データ点の座標	x[0,...,n-1]
-	j: スプラインの次数（スプライン階数 K = j + 1）
-	d: d >= 0 ? データ点に追加される境界条件数 : 周期境界条件（d = T - n - 1)
-	T: 周期（境界条件数 = d + K）
-	d > j : 多重節点の付加、m = {n1, k1, ... }
-*******************************************************************************/
-template <typename S>
-base_spline<S>::base_spline(int n, const S *x, int j, int d, int *m)
-{
-	int s = 0;
-	if (d > j) { s = j - d; d = 0; }
-//	周期境界条件フラグ
-	shuki = d < 0 ? 1 : 0;
-//	スプライン階数
-	rank = j + 1;
-//	スプライン次数
-	jisu = j;
-//	周期（データ点の個数）
-	imax = n + d + shuki;
-//	Ｂスプライン関数基底の個数
-	icox = imax + jisu * shuki;
-//	節点の個数
-	maxq = icox + rank;
-//	節点の配列
-	knots = new S[maxq];
-//	節点の配列を初期化
-	setten(knots, maxq, icox, n, rank, d, s + imax * shuki, x, m);
-}
-/*******************************************************************************
-	初期化
-	q: ノットベクトル
-	c: スプライン関数基底の個数
-	k: スプライン階数
-	s: 周期指定
-*******************************************************************************/
-template <typename S>
-base_spline<S>::base_spline(const S *q, int k, int c, int s)
-{
-	assert(s == 0 || s == 1);
-	assert(k - (k-1)*s <= c);
-//	周期境界条件フラグ
-	shuki = s;
-//	スプライン階数
-	rank = k;
-//	スプライン次数
-	jisu = k - 1;
-//	周期（データ点の個数）
-	imax = c - jisu * shuki;
-//	Ｂスプライン関数基底の個数
-	icox = c;
-//	節点の個数
-	maxq = icox + rank;
-//	節点の配列
-	knots = new S[maxq];
-//	節点の配列を初期化
-	for (int i = 0; i < maxq; i++) knots[i] = q[i];
-}
-//	コピーコンストラクター
-template <typename S>
-base_spline<S>::base_spline(const base_spline& b)
- : imax(b.imax), icox(b.icox), rank(b.rank), jisu(b.jisu), shuki(b.shuki), maxq(b.maxq)
-{
-	knots = new S[maxq];
-	memcpy(knots, b.knots, maxq * sizeof(S));
-}
-//	代入オペレーター
-template <typename S>
-base_spline<S>& base_spline<S>::operator=(const base_spline& b)
-{
-	if (this != &b) {
-		delete[] knots;
-		imax = b.imax; icox = b.icox; rank = b.rank;
-		jisu = b.jisu; shuki = b.shuki; maxq = b.maxq;
-		knots = new S[maxq];
-		memcpy(knots, b.knots, maxq * sizeof(S));
-	}
-	return *this;
-}
-/*******************************************************************************
-    Ｂスプライン関数値の計算 Ｂi,K(t): i = kset-jisu,...,kset
-	  t: データ点の座標値
-	c,b: 結果を入れる配列（c:サイズ，b:配列へのポインタ）
-	  k: k > 0 ? Ｂi,k(x) : k == 0 ? Ｂi,rank(x) : k < 0 ? Ｄ-kＢi,rank(x)
-*******************************************************************************/
-template <typename S>
-int base_spline<S>::basic(S t, int c, S* b, int k) const
-{
-	int kset = 0, j = k > 0 ? k : rank;
-	S bc[j];
-	int ks = deboor<S>(rank, knots, icox, t, bc, kset, k);
-	if (c <= j)
-		for (int i=0;i<c;++i) b[i] = bc[ks < 0 ? i - ks : i];
-	else
-		for (int i=0;i<c;++i) b[i] = (ks <= i) && (i <= kset) ? bc[i - ks] : 0;
-	return kset;
-}
-/*******************************************************************************
-    係数行列の構成
-*******************************************************************************/
-static void shuki_spline(int k, double *b, int n, double *bc)
-{
-	int j = k - 1;
-	int m = k / 2;	/* m = Mjis = (Jisu+1)/2 = kai/2 */
-	int m_1 = j - m;
-	int i, o = n - m + 1;
-	for (i = 0; i < m; i++) bc[i] = b[i+m_1] + b[i+m_1+n];
-	for (i = m; i < o; i++) bc[i] = b[i+m_1];
-	for (i = o; i < n; i++) bc[i] = b[i+m_1] + b[i+m_1-n];
-}
-
-template <typename S>
-void base_spline<S>::gyoretu(S **bd, int n, const S *x, const int *d) const
-{
-	if (shuki == 0)
-		for (int j = 0; j < n; j++)
-			basic((x ? x[j] : j), imax, bd[j], (d ? -d[j] : 0));
-	else {
-		S *b = new S[icox];	/* 周期スプライン係数行列の計算 */
-		for (int j = 0; j < n; j++) {
-			basic((x ? x[j] : j), icox, b, (d ? -d[j] : 0));
-			shuki_spline(rank, b, imax, bd[j]);
-		}
-		delete[] b;
-	}
-}
-
-template <typename S>
-parray<S> base_spline<S>::basis(S t, int jbn) const
-{
-	S data[rank];
-	int kset, offset = deboor<S>(rank, knots, icox, t, data, kset, -jbn);
-	parray<S> result(offset, rank, 1);
-	S *p = *result; for (int i = 0; i < rank; ++i) p[i] = data[i];
-	return result;
-}
-	
-template <typename S>
-parray<S> base_spline<S>::bases(S t, int jbn) const
-{
-	int N = 1; for (int i = 2; i <= rank; i++) N += i;
-	S *bv = new S[N];
-	int kset; deboor_cox<S>(rank, knots, icox, t, bv, kset, jisu);
-	int offset = kset - jisu, k = jbn + 1;
-	parray<S> data(offset, rank, k);
-	S *mp = *data;
-	for (int j = 0; j <= jbn; ++j) {
-		if (j > 0) deboor_cox<S>(rank, knots, icox, t, bv, kset, rank-j, -rank);
-		for(int i = 0; i < rank; ++i) *mp++ = bv[i];
-	}
-	delete[] bv;
-	return data;
-}	
-/*******************************************************************************
-	微分係数の計算
-*******************************************************************************/
-template <typename S> void base_spline<S>::bibun_keisu(int Jbn, int n, S** ad) const
-{
-	S zk;
-	S *a0, *a1, *q = knots;
-
-	for (int j = 0; j < Jbn; j++) {
-		a0 = ad[j];
-		a1 = ad[j+1];
-		a1[0] = 0.0;
-		for (int i = 1; i < n; i++) {
-			if ((zk = q[i+Jbn-j] - q[i]) != 0.0)
-				a1[i] = (Jbn-j)*(a0[i] - a0[i-1])/zk;
-			else
-				a1[i] = 0.0;
-		}
-	}
-}
-/*******************************************************************************
-	積分係数の計算
-*******************************************************************************/
-static double qvalue(int m, double *q, int i, int j, int c)
-{
-	int k = i - c + j;
-	return ((k < m) ? q[k] : qvalue(m, q, k, j, c)) + q[c] - q[j];
-}
-
-#define QVALUE(i) ((i)<m ? q[i] : shuki ? qvalue(m,q,i,jisu,icox) : q[m-1])
-
-template <typename S> void base_spline<S>::sekibun_keisu(int Jsk, int n, S** ai) const
-{
-	int ki = rank, m = Maxq();
-	S *a0, *a1, *q = knots;
-
-	for (int js = 1; js <= Jsk; js++) {
-		a0 = ai[(js-1)%2];
-		a1 = ai[js%2];
-		a1[0] = a0[0] * (QVALUE(ki)-q[0])/ki;
-		for (int j = 1; j < n; j++)
-			a1[j] = a1[j-1] + a0[j]*(QVALUE(j+ki)-q[j])/ki;
-		ki++;
-	}
-}
-
-template <typename S> int base_spline<S>::Kset(S x) const
-{
-	int L = 0; S *q = knots;
-	for(int i = jisu; i < icox; ++i)
-		if (q[i] <= x && x <  q[i+1]){ L = i; break;}
-	if(q[icox-1] <= x && x <= q[icox]+eps){ L = icox-1;}
-	return L;
-}
-
-
-
-
-template class base_spline<double>;
-
+#include "bspline.h"
+
+/*******************************************************************************
+	de Boor-Cox の漸化式によるＢ−スプライン関数値の計算
+	  k: Ｂスプラインの階数（j+1）
+	  q: 節点の配列
+	  c: Ｂスプラインの基底数
+	  t: データ点の座標（q[j] <= t <= q[cox]）
+	  d: d > 0 ? スプライン階数 : 微分階数
+*******************************************************************************/
+template <typename P, typename T>
+//	P = varray<double>, T = poly<double>;
+int deboor(int k, const P& q, int c, const T& t, P& b, int& kset, int d)
+{
+	static const T eps(1.0e-10);
+
+	int h = c-1, i = k-1, j, K = d > 0 ? d : k, L = k + d;
+	
+	while (i < h) { if(q[i] <= t && t < q[i+1]) break; i++; }
+	kset = i; if (q[h] <= t && t < q[c] + eps) kset = h;
+	b[0] = 1.0;
+	for (j = 1; j < K; ++j) {
+		if (L > 0) --L;
+		b[j] = 0.0;
+		for (i = 0; i < j; ++i) {
+			h = j - i;
+			T q1 = q[kset + h] - t;
+			T q2 = t - q[kset - i];
+			T dt = q1 + q2;
+			T a = 0.0; if (dt > 0.0) a = b[h-1] / dt;
+			if (L > 0) {
+				b[ h ] += a * q2;	// 決定項
+				b[h-1]  = a * q1;	// 準備項
+			} else {
+				a *= j;
+				b[ h ] += a;	// 決定項
+				b[h-1] = -a;	// 準備項
+			}
+		}
+	}
+	return kset - j + 1;
+}
+/*******************************************************************************
+	de Boor-Cox の漸化式によるＢ−スプライン関数値の計算
+	  K: Ｂスプラインの階数（j+1）
+	  q: 節点の配列
+	cox: Ｂスプラインの基底数
+	  t: データ点の座標（q[j] <= t <= q[cox]）
+	  J: 漸化式の適用回数
+	  L: (0 >= L >= -j) ? 微分階数
+*******************************************************************************/
+template<typename P, typename T>
+//	P = varray<double>, T = poly<double>;
+void deboor_cox(int K, const P& q, int cox, const T& t, P& b, int &kset, int J, int L)
+{
+	static const T eps(1.0e-10);
+
+	int I = J + L;
+	int H = I + K + L;
+	if (J == 0 && I >= 0) {
+		int j = K - 1, c = cox - 1;
+		for(int i=j;i<c;++i)if(q[i]<=t && t<q[i+1]){kset=i;break;}
+		if(q[c]<=t && t<=q[cox]+eps){kset=c;}
+		b[0] = 1.0;
+	} else if (I >= 0 || H < 0) {
+		int j = J - (I < 0 ? I + 1 : 0);
+		const P& b0 = b[j+1];
+		deboor_cox(K, q, cox, t, const_cast<P&>(b0), kset, J-1, L+1);
+		b[j] = 0.0;
+		for(int i = 0; i < j; ++i) {
+			int h = j - i;
+			T q1 = q[kset + h] - t;
+			T q2 = t - q[kset - i];
+			T dt = q1 + q2;
+			T a = 0.0; if (dt > 0.0) a = b0[h-1] / dt;
+			if (L >= 0) {
+				b[ h ] += a * q2;
+				b[h-1]  = a * q1;
+			} else {
+				a *= j;
+				b[ h ] += a;
+				b[h-1] = -a;
+			}
+		}
+	}
+}
+/*******************************************************************************
+	シェーンバーグ・ホイットニー条件を満たす節点の設定
+    q0, ..., qj, qk, ..., qi, ..., qc-1, qc, ..., qc+j
+    x0, ..., x0, | , ..., | , ..., | , xn-1, ..., xn-1
+            (x0+xk)/2 (xi-k+xi)/2 (xn-k-1+xn-1)/2
+	 q : 節点の配列
+	 m : 節点配列の長さ (c + k)
+	 c : スプライン基底の個数
+	 n : データ点の個数
+	 k : スプライン階数 (k <= n)
+	 d : 境界条件数 (d < k)
+	 s : 周期
+	 x : データ点の配列（x == NULL: パラメトリックスプラインを示す）
+	ms : 
+*******************************************************************************/
+template<typename T>
+void setten(varray<T>& q, int m, int c, int n, int k, int d, int s, const varray<T>& x, const int *ms = NULL)
+{
+	if (s == 0)
+		for (int i = 0; i < m; i++)
+			if ((T*)x)		/* シェーンバーグ・ホイットニー条件 */
+				q[i] = i < k ? x[0] : i < c ? (x[i-k] + x[i-d]) / 2.0 : x[n-1];
+			else		/* パラメトリック */
+				q[i] = i < k ? 0.0 : i < c ? real<T>(T(i)) - real<T>(T(k + d)) / 2.0 : real<T>(T(n - 1));
+	else
+	if (s > 0)			/* 周期境界条件による節点の設定 */
+		for (int i = 0; i < m; i++) {
+			 int j = i - k + 1;
+			if ((T*)x)
+				q[i] = j < 0 ? x[0] + x[j+s] - x[s] : j <= s ? x[j] : x[s] + x[j-s] - x[0];
+			else
+				q[i] = j;
+		}
+	else
+	if (ms) {
+		int k0 = k, k1, n0, n1;
+		varray<T> p(q), y(x);
+		while (s++) {
+			n1 = *ms++; k1 = *ms++; n0 = n1 + 1;
+			setten(p, n0, n0, n0, k0, 0, 0, y, NULL);
+			p = p[n0]; m -= n0; c -= n0; n -= n1; k0 = k1; y = y[n1];
+		}
+		setten(p, m, c, n, k0, c - n, 0, y, NULL);
+	}
+}
+/*******************************************************************************
+	初期化（d == 0 ? 境界条件のないスプライン補間）
+	n: データ点の個数
+	x: データ点の座標	x[0,...,n-1]
+	j: スプラインの次数（スプライン階数 K = j + 1）
+	d: d >= 0 ? データ点に追加される境界条件数 : 周期境界条件（d = T - n - 1)
+	T: 周期（境界条件数 = d + K）
+	d > j : 多重節点の付加、m = {n1, k1, ... }
+*******************************************************************************/
+template <typename T>
+base_spline<T>::base_spline(int n, const varray<T>& x, int j, int d, int *m)
+{
+	int s = 0;
+	if (d > j) { s = j - d; d = 0; }
+//	周期境界条件フラグ
+	shuki = d < 0 ? 1 : 0;
+//	スプライン階数
+	rank = j + 1;
+//	スプライン次数
+	jisu = j;
+//	周期（データ点の個数）
+	imax = n + d + shuki;
+//	Ｂスプライン関数基底の個数
+	icox = imax + jisu * shuki;
+//	節点の個数
+	maxq = icox + rank;
+//	節点の配列
+	knots = new varray<T>(size_t(maxq), x.atom());
+//	節点の配列を初期化
+	setten(*knots, maxq, icox, n, rank, d, s + imax * shuki, x, m);
+}
+/*******************************************************************************
+	初期化
+	q: ノットベクトル
+	c: スプライン関数基底の個数
+	k: スプライン階数
+	s: 周期指定
+*******************************************************************************/
+template <typename T>
+base_spline<T>::base_spline(const varray<T>& q, int k, int c, int s)
+{
+	assert(s == 0 || s == 1);
+	assert(k - (k-1)*s <= c);
+//	周期境界条件フラグ
+	shuki = s;
+//	スプライン階数
+	rank = k;
+//	スプライン次数
+	jisu = k - 1;
+//	周期（データ点の個数）
+	imax = c - jisu * shuki;
+//	Ｂスプライン関数基底の個数
+	icox = c;
+//	節点の個数
+	maxq = icox + rank;
+//	節点の配列
+	knots = new varray<T>(size_t(maxq), q.atom());
+//	節点の配列を初期化
+	for (int i = 0; i < maxq; i++) (*knots)[i] = q[i];
+}
+//	コピーコンストラクター
+template <typename T>
+base_spline<T>::base_spline(const base_spline& b)
+ : imax(b.imax), icox(b.icox), rank(b.rank), jisu(b.jisu), shuki(b.shuki), maxq(b.maxq), knots(new varray<T>(*b.knots)) {}
+//	代入オペレーター
+template <typename T>
+base_spline<T>& base_spline<T>::operator=(const base_spline& b)
+{
+	if (this != &b) {
+		delete knots;
+		imax = b.imax; icox = b.icox; rank = b.rank; jisu = b.jisu; shuki = b.shuki; maxq = b.maxq;
+		knots = new varray<T>(*b.knots);
+	}
+	return *this;
+}
+/*******************************************************************************
+    Ｂスプライン関数値の計算 Ｂi,K(t): i = kset-jisu,...,kset
+	  t: データ点の座標値
+	c,b: 結果を入れる配列（c:サイズ，b:配列へのポインタ）
+	  j: j > 0 ? Ｂi,j(x) : j == 0 ? Ｂi,rank(x) : j < 0 ? Ｄ(-j)Ｂi,rank(x)
+*******************************************************************************/
+template <typename S>
+int base_spline<S>::basic(const real<S>& t, int c, varray<S>& b, int j) const
+{
+	int kset = 0, k = j > 0 ? j : rank;
+	assert(c >= k);
+	const varray<S>& bc = b[c - k];
+	int ks = deboor(rank, *knots, icox, t, const_cast<varray<S>&>(bc), kset, j);
+	if (c != k) {
+		int kmax = ((c - 1) == kset ? ks : c);
+		for (int i = 0; i < kmax; ++i)
+			b[i] = (ks <= i) && (i <= kset) ? bc[i - ks] : 0.0;
+	}
+	return ks;
+}
+/*******************************************************************************
+    係数行列の構成
+*******************************************************************************/
+template <typename T>
+static void shuki_spline(int k, const varray<T>& b, int n, varray<T>& bc)
+{
+	int j = k - 1;
+	int m = k / 2;	/* m = Mjis = (Jisu+1)/2 = kai/2 */
+	int m_1 = j - m;
+	int i, o = n - m + 1;
+	for (i = 0; i < m; i++) bc[i] = b[i+m_1] + b[i+m_1+n];
+	for (i = m; i < o; i++) bc[i] = b[i+m_1];
+	for (i = o; i < n; i++) bc[i] = b[i+m_1] + b[i+m_1-n];
+}
+
+template <typename T>
+void base_spline<T>::gyoretu(marray<T>& bd, int n, const varray<T>& x, const int *d) const
+{
+	if (shuki == 0)
+		for (int j = 0; j < n; j++) {
+			varray<T> bc = bd.row(j);
+			basic(( (T*)x ? x[j] : real<T>(T(j)) ), imax, bc, (d ? -d[j] : 0));
+		}
+	else {
+		varray<T> b(size_t(icox), x.atom());	/* 周期スプライン係数行列の計算 */
+		for (int j = 0; j < n; j++) {
+			basic(( (T*)x ? x[j] : real<T>(T(j)) ), icox, b, (d ? -d[j] : 0));
+			varray<T> bc = bd.row(j);
+			shuki_spline(rank, b, imax, bc);
+		}
+	}
+}
+
+template <typename T>
+marray<T> base_spline<T>::gyoretu(const Int& a, const varray<T>& x, const int *d) const
+{
+	size_t n = a[0];
+	marray<T> bd(n, n, a.atom());
+	gyoretu(bd, n, x, d);
+	return bd;
+}
+
+template <typename T>
+parray<T> base_spline<T>::basis(const real<T>& t, int jbn) const
+{
+	int h = rank - (jbn < 0 ? jbn : 0);
+	int j = jbn < 0 ? h : -jbn;
+	varray<T> data(size_t(h), t.atom());
+	int kset, offset = deboor(rank, *knots, icox, t, data, kset, j);
+	parray<T> result(offset, h, 1, t.atom());
+	varray<T> m = result[0];
+	for (int i = 0; i < h; ++i) m[i] = data[i];
+	return result;
+}
+	
+template <typename T>
+parray<T> base_spline<T>::bases(const real<T>& t, int jbn) const
+{
+	int N = 1; for (int i = 2; i <= rank; i++) N += i;
+	varray<T> data(size_t(N), t.atom());
+	int kset; deboor_cox(rank, *knots, icox, t, data, kset, jisu);
+	int offset = kset - jisu, k = jbn + 1;
+	parray<T> result(offset, rank, k, t.atom());
+	for (int j = 0; j <= jbn; ++j) {
+		varray<T> m = result[j];
+		if (j > 0) deboor_cox(rank, *knots, icox, t, data, kset, rank-j, -rank);
+		for(int i = 0; i < rank; ++i) m[i] = data[i];
+	}
+	return result;
+}
+
+template <typename S>
+parray<S> base_spline<S>::sekibun(const real<S>& x, int Jsk) const
+{
+	assert(Jsk < 0);
+	const varray<S>& q = *knots;
+	int K = rank, J = K - 1, R = K - Jsk;
+	varray<S> B(size_t(R), x.atom());
+	int kset, ks = deboor(K, q, icox, x, B, kset, R);
+	int offset = kset - J;
+	parray<S> pc(offset, K, 1, x.atom());
+	varray<S> ac(size_t(kset+1), x.atom()), sum = pc[0];
+	for (int i = 0; i < K; ++i) {
+		int Jsc = -Jsk;
+		for (int j = 0; j <= kset; ++j)
+			ac[j] = 0.0;
+			ac[i+offset] = 1;
+		while(Jsc) {
+			for (int j = 0; j <= kset; ++j)
+				ac[j] = (j > 0 ? ac[j-1] : 0.0) + ac[j] * (q[j+(R-Jsc)] - q[j]) / S(R-Jsc);
+			Jsc--;
+		}	sum[i] = 0.0;
+		for (int j = (ks >= 0 ? ks : 0); j <= kset; ++j)
+			sum[i] += ac[j] * B[j - ks];
+	}
+	return pc;
+}
+/*******************************************************************************
+	微分係数の計算
+*******************************************************************************/
+template <typename S>
+void base_spline<S>::bibun_keisu(int Jbn, marray<S>& ad) const
+{
+	real<S> zk; int n = ad.cols();
+	const varray<S>& q = *knots;
+
+	for (int j = 0; j < Jbn; j++) {
+		varray<S> a0 = ad.row(j);
+		varray<S> a1 = ad.row(j+1);
+		a1[0] = 0.0;
+		for (int i = 1; i < n; i++) {
+			if ((zk = q[i+Jbn-j] - q[i]) != 0.0)
+				a1[i] = (Jbn-j)*(a0[i] - a0[i-1])/zk;
+			else
+				a1[i] = 0.0;
+		}
+	}
+}
+/*******************************************************************************
+	積分係数の計算
+*******************************************************************************/
+template <typename S>
+static real<S> qvalue(int m, const varray<S>& q, int i, int j, int c)
+{
+	int k = i - c + j;
+	return ((k < m) ? q[k] : qvalue(m, q, k, j, c)) + q[c] - q[j];
+}
+
+#define QVALUE(i) ((i)<m ? q[i] : shuki ? qvalue(m,q,i,jisu,icox) : q[m-1])
+
+template <typename S>
+void base_spline<S>::sekibun_keisu(int Jsk, marray<S>& ai) const
+{
+	int ki = rank, m = Maxq(), n = ai.cols();
+	const varray<S>& q = *knots;
+
+	assert(n <= icox);
+	for (int js = 1; js <= Jsk; js++) {
+		real<S> a0 = ai.row((js-1)%2);
+		real<S> a1 = ai.row(js%2);
+		for (int j = 0; j < n; j++)
+			a1[j] = (j > 0 ? a1[j-1] : 0.0) + a0[j]*(QVALUE(j+ki)-q[j])/ki;
+		ki++;
+	}
+}
+
+template <typename S>
+int base_spline<S>::Kset(const real<S>& x) const
+{
+	static const S eps = S(1.0e-10);
+
+	int L = 0;
+	const varray<S>& q = *knots;
+	for(int i = jisu; i < icox; ++i)
+		if (q[i] <= x && x <  q[i+1]){ L = i; break;}
+	if(q[icox-1] <= x && x <= q[icox]+eps){ L = icox-1;}
+	return L;
+}
+
+template <typename S>
+void base_spline<S>::print() const
+{
+	printf("<K = %d, C = %d, I = %d, J = %d, S = %d\n", rank, icox, imax, jisu, shuki);
+	knots->print("%g>\n");
+}
+
+template class base_spline<double>;
+