pspline 5.0.2

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

@@ -0,0 +1,210 @@
+#ifndef _USPLINE_5_H_INCLUDED_
+#define _USPLINE_5_H_INCLUDED_
+
+template <typename T = double> struct Func { int jbn, jis; T val; };
+template <typename T = double> struct Bound { int pos, jbn; T val; };
+template <typename T = double> using Factor = T(*)(T);
+
+/*******************************************************************************
+	uspline<T>{base_spline*[N]}
+*******************************************************************************/
+template <typename T = double> class uspline : public base_spline<T>
+{
+
+T *data;
+
+//	汎関数線型項
+void hankansu1(const Func<T>& F, T *hr)
+{
+	T  *q = base_spline<T>::knots;
+	int K = base_spline<T>::rank, J = K - 1;
+	int Imax = base_spline<T>::imax;
+	T t = q[Imax];
+	T B[K];
+	int kset = base_spline<T>::basic(t, K, B);
+	int ks = kset - J;
+	for (int l = 0; l < Imax; ++l) {
+		T aj[Imax], ac[Imax];
+		for (int i = 0; i < Imax; ++i) ac[i] = 0;
+		ac[l] = 1;
+		aj[0] = ac[0] * (q[K] - q[0]) / K;
+		for (int j = 1; j < Imax; ++j)
+			aj[j] = aj[j-1] + ac[j] * (q[j+K] - q[j]) / K;
+		T rn = 0;
+		for (int i = ks; i <= kset; ++i)
+			rn += aj[i] * B[i - ks];
+		hr[l] += F.val * rn;
+	}
+}
+
+//	汎関数２乗項
+void hankansu2(const Func<T>& F, T *hl)
+{
+	T  *q = base_spline<T>::knots;
+	int K = base_spline<T>::rank, J = K - 1;
+	int Imax = base_spline<T>::imax;
+	T ld[K*2];
+	for (int l = 0; l < K*2; ++l) {
+		if (l == 0)
+			ld[l] = 1.0;
+		else
+			ld[l] = ld[l-1] * l;
+	}
+	int jb = F.jbn;
+	for (int l = 0; l < Imax; ++l) {
+		int ql = l + J;
+		T t = q[ql];
+		parray<T> fl = base_spline<T>::bases(t, J);
+		int ks = fl(0), kt = fl(1), kset = ks + J;
+		T *ft = *fl;
+		for (int i = ks; i <= kset; ++i) {
+			for (int j = ks; j <= kset; ++j) {
+				for (int r = jb; r < K; ++r) {
+					int rb = r - jb;
+					T Bik = ft[i - ks + r*kt];
+					for (int s = jb; s < K; ++s) {
+						int sb = s - jb;
+						T Bjk = ft[j - ks + s*kt];
+						int lm = rb + sb + 1;
+						T Ql = pow(q[ql+1] - q[ql], lm);
+						T p = Bik * Bjk * Ql / (ld[rb] * ld[sb] * lm);
+						hl[i*Imax + j] += F.val * p;
+					}
+				}
+			}
+		}
+	}
+}
+
+void gyoretu_ritz(double *hl, double *hr, double *Bd, double *Dy)
+{
+	int Imax = base_spline<T>::imax;
+	for (int l = 0; l < Imax; ++l) {
+		for (int i = 0; i < Imax; ++i)
+			Bd[l*Imax + i] = 2 * hl[l*Imax + i];
+			Dy[l] = -hr[l];
+	}
+}
+
+void zyoken(int lcc, int *ibd, const Bound<T> *Bs, T *Bd, T *Dx, T *Dy)
+{
+	int K = base_spline<T>::rank, J = K - 1;
+	int Imax = base_spline<T>::imax;
+	T B[K];
+	for (int l = 0; l < lcc; l++) {
+		T t = Dx[Bs[l].pos];
+		int jb = Bs[l].jbn;
+		int kset = base_spline<T>::basic(t, K, B, -jb);
+		int ks = kset - J;
+		for (int i = 0; i < Imax; i++)
+			Bd[ibd[l]*Imax + i] = (i < ks || kset < i) ? 0 : B[i - ks];
+			Dy[ibd[l]] = Bs[l].val;
+	}
+}
+
+public:
+uspline() : data(NULL) {}
+~uspline() {delete[] data;}
+uspline(int R, Func<T> *df, int n, T *x, int j, int d, int lcc, Bound<T> *bf, int *lbd)
+ : base_spline<T>(n, x, j, d)
+{
+	int Imax = base_spline<T>::imax;
+	T hl[Imax * Imax], hr[Imax];
+	T Bd[Imax][Imax], Dy[Imax];
+	for (int i = 0; i < Imax; ++i) {
+		for (int j = 0; j < Imax; ++j)
+			hl[i*Imax+j] = 0;
+			hr[i] = 0;
+	}
+	for (int term = 0; term < R; ++term)
+		if (df[term].jis == 2)
+			hankansu2(df[term], hl);
+		else
+			hankansu1(df[term], hr);
+	gyoretu_ritz(hl, hr, (T*)Bd, Dy);
+	zyoken(lcc, lbd, bf, (T*)Bd, x, Dy);
+	data = new T[Imax];
+	for (int i = 0; i < Imax; ++i) data[i] = Dy[i];
+	lu_solve((T*)Bd, Imax, data);
+}
+
+T operator [] (T t) const { return base_spline<T>::apply(t, data); }
+
+}; // end of uspline;
+
+/*******************************************************************************
+	nspline<T>{base_spline*[N]}
+*******************************************************************************/
+template <typename T> class nspline : public base_spline<T>
+{
+T *data;
+
+//	微分方程式左辺
+void sa_hen(T *Dx, int term, Func<T> *F, Factor<T> *C, T *Bd)
+{
+	int K = base_spline<T>::rank, J = K - 1;
+	int Imax = base_spline<T>::imax;
+	T B[K*(K+1)];
+	for (int l = 0; l < Imax; ++l) {
+		T t = Dx[l];
+		for (int k = 0; k < term; ++k) {
+			F[k].val = C[k](t);
+			int jb = F[k].jbn;
+			int kset = base_spline<T>::basic(t, K, B, -jb);
+			int ks = kset - J;
+			for (int i = 0; i < Imax; ++i)
+				Bd[l*Imax + i] += F[k].val * ((ks <= i && i <= kset) ? B[i - ks] : 0.0);
+		}
+	}
+}
+
+//	微分方程式右辺
+void u_hen(Factor<T>& f, int Imax, T *Dx, T *Dy)
+{
+	for (int i = 0; i < Imax; ++i) Dy[i] = f(Dx[i]);
+}
+
+void zyoken(int lcc, int *ibd, const Bound<T> *Bs, T *Bd, T *Dx, T *Dy)
+{
+	int K = base_spline<T>::rank, J = K - 1;
+	int Imax = base_spline<T>::imax;
+	T B[K];
+	for (int l = 0; l < lcc; l++) {
+		T t = Dx[Bs[l].pos];
+		int jb = Bs[l].jbn;
+		int kset = base_spline<T>::basic(t, K, B, -jb);
+		int ks = kset - J;
+		for (int i = 0; i < Imax; i++)
+			Bd[ibd[l]*Imax + i] = (i < ks || kset < i) ? 0 : B[i - ks];
+			Dy[ibd[l]] = Bs[l].val;
+	}
+}
+
+public:
+nspline() : data(NULL) {}
+~nspline(){delete[] data;}
+nspline(int R, Func<T> *df, Factor<T> *uf, int n, T *x, int j, int d, int lcc, Bound<T> *bf, int *lbd)
+ : base_spline<T>(n, x, j, d)
+{
+	int Imax = base_spline<T>::imax;
+	double Bd[Imax * Imax], Dy[Imax];
+	for (int i = 0; i < Imax; ++i) {
+		for (int j = 0; j < Imax; ++j)
+			Bd[i*Imax+j] = 0;
+			Dy[i] = 0;
+	}
+	sa_hen(x, R, df, uf, Bd);
+	u_hen(uf[R], Imax, x, Dy);
+	zyoken(lcc, lbd, bf, Bd, x, Dy);
+	data = new T[Imax];
+	for (int i = 0; i < Imax; ++i) data[i] = Dy[i];
+	lu_solve(Bd, Imax, data);
+}
+
+T operator [] (T t) const { return base_spline<T>::apply(t, data); }
+
+T operator () (T t, int Jbn = 0) const { return base_spline<T>::apply(t, data, Jbn); }
+
+}; // end of nspline
+
+#endif

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

@@ -0,0 +1,656 @@
+#ifndef _UTIL_H_INCLUDED_
+#define _UTIL_H_INCLUDED_
+
+#include <complex.h>
+
+//   Ｔ配列	[T0,...,Ti-1] : T*
+#define T_ALLOC(T,i) (T*)malloc((i)*sizeof(T))
+//   Ｔ行列	[[T00,...],...] : T**
+#define T_MALLOC(T,i,j) create_marray<T>((i),(j))
+// destructor
+#define FREE(m) free((char*)(m))
+
+template <typename T> inline
+T pow(T a, int n)
+{
+	return n == 0 ? 1 : a * pow(a, n-1);
+}
+
+template <typename T> T coeff(T**, const int*, int, int = 0);
+template <typename T> T total_derive(T**, const int*, int, int, const T*);
+
+/*******************************************************************************
+	define print utility.
+*******************************************************************************/
+template <class T> inline int sprintg(char* &c, T o);
+
+template <> inline int sprintg(char* &c, int a)    {return sprintf(c, "%d", a);}
+template <> inline int sprintg(char* &c, size_t a) {return sprintf(c, "%ld",a);}
+template <> inline int sprintg(char* &c, double a) {return sprintf(c, "%g", a);}
+
+template <class T> inline double gabs(T o);
+
+template <> inline double gabs(double a) {return fabs(a);}
+template <> inline double gabs(std::complex<double> c) {return abs(c);}
+
+template <typename T> void poly_to_s(char* &c, int N, const int *size, const T *data)
+{
+	int n = *size;
+	if (N == 0) {
+		if (n > 1) sprintf(c, "("); while(*c)++c;
+		for (int i = 0; i < n; ++i) {
+			sprintg<T>(c, data[i]); while(*c)++c;
+			if (i < n-1) sprintf(c, ","); while(*c)++c;
+		}
+		if (n > 1) sprintf(c, ")"); while(*c)++c;
+	}
+	else {
+		sprintf(c, "["); while(*c)++c;
+		int m = 1; for (int i = 1; i <= N; ++i) m *= size[i];
+		for (int i = 0; i < n; ++i) {
+			poly_to_s(c, N-1, size+1, &data[i*m]);
+			if (i < n-1) sprintf(c, ","); while(*c)++c;
+		}
+		sprintf(c, "]"); while(*c)++c;
+	}
+}
+
+/*******************************************************************************
+	Matrix operation
+*******************************************************************************/
+template <class T>
+void luc_decomp(T *, size_t, size_t*, int&);
+
+template <class T>
+void lud_decomp(T *, size_t, size_t*, int&);
+
+template <class T>
+void luc_decomp(T**, size_t, size_t*, int&);
+
+template <class T>
+void lud_decomp(T**, size_t, size_t*, int&);
+
+template <class T, class S = T>
+void luc_subst(T *, size_t, size_t*, S*);
+
+template <class T, class S = T>
+void lud_subst(T *, size_t, size_t*, S*);
+
+template <class T, class S = T>
+void luc_subst(T**, size_t, size_t*, S*);
+
+template <class T, class S = T>
+void lud_subst(T**, size_t, size_t*, S*);
+
+template <class T, class S = T>
+void luc_subst(T *, size_t, size_t*, S*, int);
+
+template <class T, class S = T>
+void lud_subst(T *, size_t, size_t*, S*, int);
+
+template <class T, class S = T>
+void luc_subst(T**, size_t, size_t*, S*, int);
+
+template <class T, class S = T>
+void lud_subst(T**, size_t, size_t*, S*, int);
+
+template <class T> T luc_solve(T * a, size_t n, T * b, int K = 1)
+{
+	size_t *p = new size_t[n];
+	int s;	luc_decomp(a, n, p, s);
+	if (K>1) luc_subst(a, n, p, b, K); else luc_subst(a, n, p, b);
+	T det = s;
+	for (size_t k = 0; k < n; ++k) det *= a[k*n+k];
+	delete[] p;
+	return det;
+}
+
+template <class T> T luc_solve(T ** a, size_t n, T * b, int K = 1)
+{
+	size_t *p = new size_t[n];
+	int s;	luc_decomp(a, n, p, s);
+	if (K>1) luc_subst(a, n, p, b, K); else luc_subst(a, n, p, b);
+	T det = s;
+	for (size_t k=0;k<n;++k) det *= a[k][k];
+	delete[] p;
+	return det;
+}
+
+template <class T> T lud_solve(T * a, size_t n, T * b, int K = 1)
+{
+	size_t *p = new size_t[n];
+	int s;	lud_decomp(a, n, p, s);
+	if (K>1) lud_subst(a, n, p, b, K); else lud_subst(a, n, p, b);
+	T det = s;
+	for (size_t k = 0; k < n; ++k) det *= a[k*n+k];
+	delete[] p;
+	return det;
+}
+
+template <class T> T lud_solve(T ** a, size_t n, T * b, int K = 1)
+{
+	size_t *p = new size_t[n];
+	int s;	lud_decomp(a, n, p, s);
+	if (K>1) lud_subst(a, n, p, b, K); else lud_subst(a, n, p, b);
+	T det = s;
+	for (size_t k = 0; k < n; ++k) det *= a[k][k];
+	delete[] p;
+	return det;
+}
+
+#define lu_decomp lud_decomp
+#define lu_subst  lud_subst
+#define lu_solve  lud_solve
+
+template <class T>
+T ** marray_alloc(char *mm, int nr, size_t sr, size_t sc)
+{
+	T **m = (T **)mm;
+	 m[0] = (T *)(mm = mm + sr);
+	for (int i = 1; i < nr; ++i) m[i] = (T *)(mm = mm + sc);
+	return m;
+}
+
+template <typename T>
+T ** create_marray(int nr, int nc)
+{
+	size_t sr = nr * sizeof(T *);
+	size_t sc = nc * sizeof(T);
+	char * mm = (char *)malloc(sr + nr * sc);
+	if (mm == NULL) throw "allocate error, create_marray";
+	return marray_alloc<T>(mm, nr, sr, sc);
+}
+
+template <typename T>
+T ** marray_view_alloc(T **m, int nr, int nc, T *v)
+{
+	m[0] = v;
+	for (int i = 1; i < nr; i++) m[i] = m[i-1] + nc;
+	m[nr] = v;
+	return m;
+}
+
+template <typename T>
+T ** create_marray_view(int nr, int nc, T *v)
+{
+	T **m = (T**)malloc((nr+1) * sizeof(T*));
+	return marray_view_alloc(m, nr, nc, v);
+}
+
+template <typename T>
+T ** carray_alloc(char *mm, size_t sr, size_t n, size_t *s)
+{
+	T **m = (T**)mm;
+	 m[0] = (T*)(mm = mm + sr);
+	for (size_t i = 1; i < n; ++i) m[i] = (T*)(mm = mm + s[i-1] * sizeof(T));
+	return m;
+}
+
+template <typename T>
+T ** create_carray(size_t n, size_t *s)
+{
+	size_t c = 0;
+	for (size_t i = 0; i < n; ++i) c += s[i];
+	size_t sr = n * sizeof(T *);
+	size_t sc = c * sizeof(T);
+	char * mm = (char *)malloc(sr + sc);
+	if (mm == NULL) throw "allocate error, create_carray";
+	return carray_alloc<T>(mm, sr, n, s);
+}
+
+template <typename T>
+T ** carray_view_alloc(T **m, size_t n, size_t *s, T *a)
+{
+	m[0] = a;
+	for (size_t i = 1; i < n; ++i) m[i] = m[i-1] + s[i-1];
+	m[n] = a;
+	return m;
+}
+
+template <typename T>
+T ** create_carray_view(size_t n, size_t *s, T *a)
+{
+	T **m = (T**)malloc((n+1) * sizeof(T*));
+	return a == NULL ? m : carray_view_alloc<T>(m, n, s, a);
+}
+
+template <typename T> class varray
+{
+	T *data; int s;
+  public:
+	varray(int n) : s(n)
+	{
+		data = (T*)malloc(s * sizeof(T));
+	}
+	varray(const varray& v) : s(v.s)
+	{
+		data = (T*)malloc(s * sizeof(T));
+		memcpy(data, v.data, s * sizeof(T));
+	}
+	~varray() { free((void*)data); }
+	varray& operator = (const varray& v)
+	{
+		if (this != &v) {
+			free((void*)data);
+			s = v.s;
+			data = (T*)malloc(s * sizeof(T));
+			memcpy(data, v.data, s * sizeof(T));
+		}
+		return *this;
+	}
+	operator T* () { return data; }
+T	operator * () { return *data; }
+T & operator [] (int i) { return data[i]; }
+	int size() const { return s; }
+};
+
+template <typename T> class varray_view
+{
+	T *data; int s, t;
+  public:
+	varray_view(T *v, int n, int st = 1) : data(v), s(n), t(st) {}
+	~varray_view() {}
+	varray_view& operator = (const varray_view& v)
+	{
+		if (this != &v) {
+			assert(s >= v.s);
+			if (s > v.s)
+			{
+				int i, j, k(s - v.s), m((k + 1) / 2), o(k - m);
+				for (i=m-1,  k=s-m;i>=0;--i) { j=i+k; data[j*t] = v.data[i*v.t]; }
+				for (i=v.s-1,k=o;  i>=0;--i) { j=i+k; data[j*t] = v.data[i*v.t]; }
+				for (i=o-1,  k=v.s;i>=0;--i) { j=i+k; data[i*t] =   data[j*t];   }
+			}
+			else if (data != v.data)
+				for (int i = 0; i < s; ++i) data[i*t] = v.data[i*v.t];
+		}
+		return *this;
+	}
+	operator T* () { return data; }
+T	operator * () { return *data; }
+T & operator [] (int i) const { return data[i*t]; }
+	int size() const { return s; }
+};
+
+template <typename T> class marray
+{
+	T **index; int r, c;
+  public:
+	marray(int nr, int nc) : r(nr), c(nc)
+	{
+		index = create_marray<T>(nr, nc);
+	}
+	marray(const marray& m) : r(m.r), c(m.c)
+	{
+		index = create_marray<T>(r, c);
+		memcpy(*index, *m, r * c * sizeof(T));
+	}
+	~marray() { free((void*)index); }
+	marray& operator = (const marray& m)
+	{
+		if (this != &m) {
+			free((void*)index);
+			r = m.r; c = m.c;
+			index = create_marray<T>(r, c);
+			memcpy(*index, *m, r * c * sizeof(T));
+		}
+		return *this;
+	}
+    operator T** () const { return index; }
+T * operator * () const { return (T*)(index + r); }
+T * operator [] (int i) { return index[i]; }
+	void swap(int i, int j) { T *w = index[i]; index[i] = index[j]; index[j] = w; }
+	int rows() const { return r; }
+	int cols() const { return c; }
+	varray_view<T> row(int i) const { return varray_view<T>(index[i], c); }
+	varray_view<T> col(int i) const { return varray_view<T>((T*)(index + r) + i, r, c); }
+};
+
+template <typename T> class marray_view
+{
+	T **index; int r, c;
+  public:
+	marray_view(T *m, int nr, int nc) : r(nr), c(nc)
+	{
+		index = create_marray_view<T>(r, c, m);
+	}
+	marray_view(const marray<T>& m) : r(m.rows()), c(m.cols())
+	{
+		index = create_marray_view<T>(r, c, *m);
+	}
+	marray_view(const marray_view& m) : r(m.r), c(m.c)
+	{
+		index = create_marray_view<T>(r, c, *m);
+	}
+	~marray_view() { free((void*)index); }
+	marray_view& operator = (const marray_view& m)
+	{
+		if (this != &m) {
+			free((void*)index);
+			r = m.r; c = m.c;
+			index = create_marray_view<T>(r, c, *m);
+		}
+		return *this;
+	}
+	operator T** () { return index; }
+T * operator * () { return index[r]; }
+T * operator [] (int i) const { return index[i]; }
+	void swap(int i, int j) { T *w = index[i]; index[i] = index[j]; index[j] = w; }
+	int rows() const { return r; }
+	int cols() const { return c; }
+	varray_view<T> row(int i) const { return varray_view<T>(index[i], c); }
+	varray_view<T> col(int i) const { return varray_view<T>(index[r] + i, r, c); }
+};
+
+template <typename T> class marray_lu
+{
+	int  n;
+	T ** m;
+	size_t *p;
+	int  s;
+  public:
+	marray_lu(int N, const T *dat) : n(N) {
+		m = create_marray<T>(N, N);
+		p = (size_t*)malloc(N * sizeof(size_t));
+		memcpy((T*)(m+n), dat, n * n * sizeof(T));
+		lu_decomp<T>(m, size_t(N), p, s);
+	}
+	marray_lu(const marray_lu& lu) : n(lu.n) {
+		m = create_marray<T>(n, n);
+		p = (size_t*)malloc(n * sizeof(size_t));
+		memcpy((T*)(m+n), *lu, n * n * sizeof(T));
+		memcpy(p, lu.p, n * sizeof(size_t));
+		s = lu.s;
+	}
+	~marray_lu() { FREE(p); FREE(m); }
+	marray_lu& operator= (const marray_lu& lu) {
+		if (this != &lu) {
+			FREE(p); FREE(m);
+			n = lu.n;
+			m = create_marray<T>(n, n);
+			p = (size_t*)malloc(n * sizeof(size_t));
+			memcpy((T*)(m+n), *lu, n * n * sizeof(T));
+			memcpy(p, lu.p, n * sizeof(size_t));
+			s = lu.s;
+		}
+		return *this;
+	}
+	T * operator[](int i) { return m[i]; }
+	T * operator * () { return (T*)(m + n); }
+	template <class S>
+	void solve(S * b, S * x, int K = 1) {
+		for (int i = 0; i < n*K; ++i) x[i] = b[i];
+		if (K > 1)
+			lu_subst<T,S>(m, size_t(n), p, x, K);
+		else
+			lu_subst<T,S>(m, size_t(n), p, x);
+	}
+	template <class S>
+	S *solve(S *b, int K = 1) {
+		S *result = new S[n*K];
+		for (int i = 0; i < n*K; ++i) result[i] = b[i];
+		if (K > 1)
+			lu_subst<T,S>(m, size_t(n), p, result, K);
+		else
+			lu_subst<T,S>(m, size_t(n), p, result);
+		return result;
+	}
+// end of marray_lu;
+};
+
+template <typename T>
+class marray_lu_view
+{
+	int  n;
+	T ** m;
+	int  s;
+	size_t *p;
+  public:
+	marray_lu_view(int N, T *dat) : n(N) {
+		m = create_marray_view<T>(n, n, dat);
+		p = (size_t*)malloc(n * sizeof(size_t));
+		lu_decomp<T>(m, size_t(n), p, s);
+	}
+	marray_lu_view(const marray<T>& mm) : n(mm.rows()) {
+		m = create_marray_view<T>(n, n, *mm);
+		p = (size_t*)malloc(n * sizeof(size_t));
+		lu_decomp<T>(m, size_t(n), p, s);
+	}
+	marray_lu_view(const marray_lu<T>& lu) : n(lu.n) {
+		m = create_marray_view<T>(n, n, *lu);
+		p = (size_t*)malloc(n * sizeof(size_t));
+		memcpy(p, lu.p, n * sizeof(size_t));
+		s = lu.s;
+	}
+	marray_lu_view(const marray_lu_view& lu) : n(lu.n) {
+		m = create_marray_view<T>(n, n, *lu);
+		p = (size_t*)malloc(n * sizeof(size_t));
+		memcpy(p, lu.p, n * sizeof(size_t));
+		s = lu.s;
+	}
+	~marray_lu_view() { FREE(p); FREE(m); }
+	marray_lu_view& operator= (const marray_lu_view& lu) {
+		if (this != &lu) {
+			FREE(p); FREE(m);
+			n = lu.n;
+			m = create_marray_view(n, n, *lu);
+			p = (size_t*)malloc(n * sizeof(size_t));
+			memcpy(p, lu.p, n * sizeof(size_t));
+			s = lu.s;
+		}
+		return *this;
+	}
+	T * operator[](int i) { return m[i]; }
+	T * operator * () { return m[n]; }
+	template <class S>
+	void solve(S * b, S * x, int K = 1) {
+		for (int i = 0; i < n*K; ++i)
+			x[i] = b[i];
+		if (K > 1)
+			lu_subst<T,S>(m, n, p, x, K);
+		else
+			lu_subst<T,S>(m, n, p, x);
+	}
+	template <class S>
+	S *solve(S *b, int K = 1) {
+		S *result = new S[n*K];
+		for (int i = 0; i < n*K; ++i)
+			result[i] = b[i];
+		if (K > 1)
+			lu_subst<T,S>(m, n, p, result, K);
+		else
+			lu_subst<T,S>(m, n, p, result);
+		return result;
+	}
+// end of marray_lu_view;
+};
+
+template <typename T>
+void kronecker(const varray_view<T>& p, const varray_view<T>& q, const varray_view<T>& r)
+{
+	int s = p.size(), t = q.size();
+	for (int i = 0; i < s; i++)
+		for (int j = 0; j < t; j++) 
+			r[i*t+j] = p[i] * q[j];
+}
+
+template <typename T>
+void kronecker(const marray<T>& p, const marray<T>& q, const marray<T>& r)
+{
+	int s = p.rows(), t = q.rows();
+	for (int i = 0; i < s; i++)
+		for (int j = 0; j < t; j++)
+			kronecker(p.row(i), q.row(j), r.row(i*t+j));
+}
+
+template <typename T>
+marray<T> operator^(const marray<T>& p, const marray<T>& q)
+{
+	int r = p.rows() * q.rows(), c = p.cols() * q.cols();
+	marray<T> result(r, c);
+	kronecker(p, q, result);
+	return result;
+}
+
+template <typename T> class carray
+{
+	size_t n, *s; T **data;
+  public:
+	carray(size_t ns, size_t *sp): n(ns), s(new size_t[ns])
+	{
+		for (size_t i = 0; i < n; i++) s[i] = sp[i];
+		data = create_carray<T>(n, s);
+	}
+	carray(const carray& ca) : n(ca.n), s(new size_t[ca.n])
+	{
+		size_t m = 0;
+		for (size_t i = 0; i < n; i++) {
+			s[i] = ca.s[i];
+			m += s[i];
+		}
+		data = create_carray<T>(n, s);
+		memcpy(data + n, ca.data + ca.n, m * sizeof(T));
+	}
+	~carray() { delete[] s; free((void*)data); }
+	carray& operator = (const carray& ca)
+	{
+		if (this != &ca) {
+			delete[] s; free((void*)data);
+			n = ca.n; s = new size_t[ca.n];
+			size_t m = 0;
+			for (size_t i = 0; i < n; i++) {
+				s[i] = ca.s[i];
+				m += s[i];
+			}
+			data = create_carray<T>(n, s);
+			memcpy(data + n, ca.data + ca.n, m * sizeof(T));
+		}
+		return *this;
+	}
+    operator T** () const { return data; }
+T * operator * () const { return (T*)(data + n); }
+T * operator [] (size_t i) const { return data[i]; }
+	size_t size(size_t i) const { return s[i]; }
+	varray_view<T> row(size_t i) const { return varray_view<T>(data[i], s[i]); }
+// end of carray;
+};
+
+template <typename T> class carray_view
+{
+	size_t n, *s; T **data;
+  public:
+	carray_view(size_t ns, size_t *sp) : n(ns), s(new size_t[ns])
+	{
+		data = (T**)malloc(n * sizeof(T*));
+		for (size_t i = 0; i < n; i++) s[i] = sp[i];
+	}
+	carray_view(size_t ns, size_t *sp, T *dat) : n(ns), s(sp)
+	{
+		data = create_carray_view<T>(n, s, dat);
+	}
+	carray_view(const carray_view& ca) : n(ca.n), s(new size_t[ca.n])
+	{
+		data = (T**)malloc(n * sizeof(T*));
+		memcpy(s, ca.s, n * sizeof(size_t));
+		memcpy(data, ca.data, n * sizeof(T*));
+	}
+	~carray_view() { delete[] s; free((void*)data); }
+	carray_view& operator = (const carray_view& ca)
+	{
+		if (this != &ca) {
+			delete[] s; free((void*)data);
+			n = ca.n; s = new size_t[ca.n];
+			data = (T**)malloc(n * sizeof(T*));
+			memcpy(s, ca.s, n * sizeof(size_t));
+			memcpy(data, ca.data, n * sizeof(T*));
+		}
+		return *this;
+	}
+    operator T** () const { return data; }
+T*& operator [] (size_t i) const { return data[i]; }
+	size_t size(size_t i) const { return s[i]; }
+	varray_view<T> row(size_t i) const { return varray_view<T>(data[i], s[i]); }
+// end of carray_view;
+};
+
+template <typename T> class parray
+{
+	T **data; int o, s, k;
+  public:
+	parray(int no, int ns, int nk) : o(no), s(ns), k(nk)
+	{
+		data = create_marray<T>(k, s);
+	}
+	~parray() { free((void*)data); }
+    operator T** () const { return data; }
+T * operator * () const { return (T*)(data + k); }
+T * operator [] (int i) { return data[i]; }
+int operator () (int i) { return i == 0 ? o : i == 1 ? s : k; }
+	int offset() const { return o; }
+	int size() const { return s; }
+	int rows() const { return k; }
+	varray_view<T> row(int i) const { return varray_view<T>(data[i], s); }
+	varray_view<T> col(int i) const { return varray_view<T>((T*)(data + k) + i, k, s); }
+	T saylor(int i, T h)
+	{
+		T q = 0.0;
+		for (int j=k;j>0;--j) q = (q + data[j-1][i]) * h / (T)j;
+		return q;
+	}
+	T taylor(int i, T h)
+	{
+		T q = 0.0;
+		for (int j=k;j>0;--j) q = q * h / (T)j + data[j-1][i];
+		return q;
+	}
+};
+
+typedef int * narray;
+typedef varray<double> vector;
+typedef marray<double> matrix;
+
+// 整数配列	[I0,...,Ii-1] : narray
+#define NALLOC(i) (int*)malloc((i)*sizeof(int))
+// 実数配列	[X0,...,Xi-1] : varray
+#define VALLOC(i) (double*)malloc((i)*sizeof(double))
+//  dis配列	[D0,...,Di-1] : di_array
+#define DI_ALLOC(i) (dis*)malloc((i)*sizeof(dis))
+//  bis配列	[B0,...,Bi-1] : bi_array
+#define BI_ALLOC(i) (bis*)malloc((i)*sizeof(bis))
+// tris配列	[R0,...,Ri-1] : tri_array
+#define TRI_ALLOC(i) (tris*)malloc((i)*sizeof(tris))
+//tetra配列	[E0,...,Ei-1] : tetra_array
+#define TETRA_ALLOC(i) (tetris*)malloc((i)*sizeof(tetris))
+// 実数行列	[[X00,...,X0(c-1)],...,[X(r-1)0,...,X(r-1)(c-1)]] : marray
+#define MALLOC(r,c) create_marray<double>(r,c)
+//  dis行列 [[D00,...,D0(c-1)],...,[D(r-1)0,...,D(r-1)(c-1)]] : di_marray
+#define DI_MALLOC(r,c) create_marray<dis>(r,c)
+//  bis行列 [[B00,...,B0(c-1)],...,[B(r-1)0,...,B(r-1)(c-1)]] : bi_marray
+#define BI_MALLOC(r,c) create_marray<bis>(r,c)
+// tris行列 [[R00,...,R0(c-1)],...,[R(r-1)0,...,R(r-1)(c-1)]] : tri_marray
+#define TRI_MALLOC(r,c) create_marray<tris>(r,c)
+//tetra行列 [[E00,...,E0(c-1)],...,[E(r-1)0,...,E(r-1)(c-1)]] : tetra_marray
+#define TETRA_MALLOC(r,c) create_marray<tetris>(r,c)
+// 実数行列	[[X00,...],...] : double**
+#define S_MALLOC(d) create_marray<double>(d[0],d[1])
+//  dis行列 [[D00,...],...] : dis**
+#define DIS_MALLOC(d) create_marray<dis>(d[0],d[1])
+//  bis行列 [[B00,...],...] : bis**
+#define BIS_MALLOC(d) create_marray<bis>(d[0],d[1])
+// tris行列 [[R00,...],...] : tris**
+#define TRIS_MALLOC(d) create_marray<tris>(d[0],d[1])
+//tetra行列 [[E00,...],...] : tetris**
+#define TETRIS_MALLOC(d) create_marray<tetris>(d[0],d[1])
+// ポインター演算
+#define CDR(T,N,p) (poly<T,N>*)(&(p)+1)
+#define CAR(T,N,p) *(poly<T,N>*)&(p)
+
+template<class T, class Object, T (Object::*getter) () const> class Rproperty
+{
+Object *orner;
+public:
+void operator()(Object* obj) { orner = obj; }
+operator T () { return (orner->*getter)(); }
+};
+
+#endif