pspline 5.0.5 → 5.1.0

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

@@ -0,0 +1,35 @@
+#ifndef _GABS_H_
+#define _GABS_H_
+
+#include <stdlib.h>
+
+#ifdef USE_COMPLEX
+#include <complex.h>
+#ifdef I
+#undef I
+#endif
+#endif
+
+#ifdef USE_RATIONAL
+#include <boost/rational.hpp>
+typedef boost::rational<int> Rational;
+#include <iostream>
+#endif
+/*******************************************************************************
+	define global absolute.
+*******************************************************************************/
+template <class T> inline T gabs(T);
+
+template <> inline         int gabs(        int a) { return   abs(a); }
+template <> inline    long int gabs(   long int a) { return  labs(a); }
+template <> inline      double gabs(     double a) { return  fabs(a); }
+template <> inline       float gabs(      float a) { return fabsf(a); }
+template <> inline long double gabs(long double a) { return fabsl(a); }
+#ifdef USE_COMPLEX
+template <> inline double gabs(std::complex<double> c) { return abs(c); }
+#endif
+#ifdef USE_RATIONAL
+template <> inline Rational gabs(Rational r) { return abs(r); }
+#endif
+
+#endif

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

@@ -0,0 +1,568 @@
+#ifndef _MARRAY_CLASS_H_
+#define _MARRAY_CLASS_H_
+
+#include "basis/util.h"
+
+template <typename T = double> class varray
+{
+	struct add {
+		static real<T> apply(const real<T>& l, const real<T>& r) { return l + r; }
+		static real<T> apply(T l, const real<T>& r) { return l + r; }
+		static real<T> apply(const real<T>& l, T r) { return l + r; }
+	};
+	struct sub {
+		static real<T> apply(const real<T>& l, const real<T>& r) { return l - r; }
+		static real<T> apply(T l, const real<T>& r) { return l - r; }
+		static real<T> apply(const real<T>& l, T r) { return l - r; }
+	};
+	struct mul {
+		static real<T> apply(const real<T>& l, const real<T>& r) { return l * r; }
+		static real<T> apply(T l, const real<T>& r) { return l * r; }
+		static real<T> apply(const real<T>& l, T r) { return l * r; }
+	};
+	struct div {
+		static real<T> apply(const real<T>& l, const real<T>& r) { return l / r; }
+		static real<T> apply(T l, const real<T>& r) { return l / r; }
+		static real<T> apply(const real<T>& l, T r) { return l / r; }
+	};
+	template <class L, class Op, class R> class expr_
+	{
+		const L& _l; const R& _r;
+	public:
+		expr_(const L& l, const R& r) : _l(l), _r(r) {}
+		real<T> operator[](size_t i) const { return Op::apply(_l[i], _r); }
+	};
+	template <class L, class Op, class R> class expr
+	{
+		const L& _l; const R& _r;
+	public:
+		expr(const L& l, const R& r) : _l(l), _r(r) {}
+		real<T> operator[](size_t i) const { return Op::apply(_l[i], _r[i]); }
+		expr<expr,add,varray<T> > operator + (const varray<T> & v) { return expr<expr,add,varray<T> >(*this, v); }
+		expr<expr,sub,varray<T> > operator - (const varray<T> & v) { return expr<expr,sub,varray<T> >(*this, v); }
+		expr<expr,mul,varray<T> > operator * (const varray<T> & v) { return expr<expr,mul,varray<T> >(*this, v); }
+		expr<expr,div,varray<T> > operator / (const varray<T> & v) { return expr<expr,div,varray<T> >(*this, v); }
+		expr_<expr,add,T> operator + (const T& d) { return expr_<expr,add,T>(*this, d); }
+		expr_<expr,sub,T> operator - (const T& d) { return expr_<expr,sub,T>(*this, d); }
+		expr_<expr,mul,T> operator * (const T& d) { return expr_<expr,mul,T>(*this, d); }
+		expr_<expr,div,T> operator / (const T& d) { return expr_<expr,div,T>(*this, d); }
+	};
+	template <class Op> class expr<varray<T>, Op, real<T> >
+	{
+		const varray<T>& _l; const real<T>& _r;
+	public:
+		expr(const varray<T>& l, const real<T>& r) : _l(l), _r(r) {}
+		real<T> operator[](size_t i) const { return Op::apply(_l[i], _r); }
+	};
+	template <class Op> class expr<real<T>, Op, varray<T> >
+	{
+		const real<T>& _l; const varray<T>& _r;
+	public:
+		expr(const real<T>& l, const varray<T>& r) : _l(l), _r(r) {}
+		real<T> operator[](size_t i) const { return Op::apply(_l, _r[i]); }
+	};
+	template <class Op> class expr<varray<T>, Op, T>
+	{
+		const varray<T>& _l; T _r;
+	public:
+		expr(const varray<T>& l, T r) : _l(l), _r(r) {}
+		real<T> operator[](size_t i) const { return Op::apply(_l[i], _r); }
+	};
+	template <class Op> class expr<T, Op, varray<T> >
+	{
+		T _l; const varray<T>& _r;
+	public:
+		expr(T l, const varray<T>& r) : _l(l), _r(r) {}
+		real<T> operator[](size_t i) const { return Op::apply(_l, _r[i]); }
+	};
+
+  protected:
+
+	size_t _size, N; T *w; int _st, _f;
+
+  public:
+	varray() : _size(), N(), w(NULL), _st(0), _f(0) {}
+	varray(size_t n, size_t m = 0, int st = 1) : _size(n), N(m), w(new T[n*(m+1)]), _st(st), _f(1) {}
+	varray(T t, size_t n, size_t m = 0, int st = 1, int f = 1) : _size(n), N(m), w(new T[n*(m+1)*st]), _st(st), _f(f)
+	{
+		for (size_t i = 0; i < n; ++i) {
+			 real<T> z(m, &w[i*(m+1)*st], 0); z = t;
+		}
+	}
+	varray(T t, T s, size_t m = 0, int st = 1, int f = 1) : _size(2), N(m), w(new T[2*(m+1)*st]), _st(st), _f(f)
+	{
+		real<T> z0(m, w, 0); z0 = t;
+		real<T> z1(m, &w[(m+1)*st], 0); z1 = s;
+	}
+	varray(T *dat, size_t n, size_t m = 0, int st = 1, int f = 0) : _size(n), N(m), w(dat), _st(st), _f(f)
+	{
+		if (_f) {
+			size_t s = n*(m+1)*st; w = new T[s];
+			for (size_t i = 0; i < s; ++i) w[i] = dat[i];
+		}
+	}
+	varray(const varray& v) : _size(v._size), N(v.N), w(new T[v._size*(v.N+1)]), _st(1), _f(1)
+	{
+		for (size_t i = 0; i < _size; ++i)
+			for (size_t j = 0; j <= N; ++j)
+				w[i*(N+1)+j] = v.w[i*(N+1)*v._st+j];
+	}
+	~varray() { if (_f) delete[] w; }
+	varray& operator = (const varray& v)
+	{
+		if (this != &v) {
+			if (_size < v._size) { delete[] w; w = NULL; }
+			if (w == NULL) {
+				_size = v._size; N = v.N; size_t size = _size * (N + 1);
+				if (size) { w = new T[size]; _st = _f = 1; } else { _st = _f = 0; }
+			}	assert(_size >= v._size && N == v.N);
+			size_t at = (N + 1) * _st, vat = (v.N + 1) * v._st;
+			if (_size > v._size)
+			{
+				int h, i, j, k(_size - v._size), m((k + 1) / 2), o(k - m), s(_size), t(v._size), u(N);
+				for(i=m-1,k=s-m;i>=0;--i){ j=i+k; T *p = &w[j*at], *q = &v.w[i*vat]; for(h=0;h<=u;++h)p[h]=q[h];}
+				for(i=t-1,k=o;  i>=0;--i){ j=i+k; T *p = &w[j*at], *q = &v.w[i*vat]; for(h=0;h<=u;++h)p[h]=q[h];}
+				for(i=o-1,k=t;  i>=0;--i){ j=i+k; T *p = &w[i*at], *q = &w[j*at];    for(h=0;h<=u;++h)p[h]=q[h];}
+			}
+			else if (w != v.w)
+				for (size_t i = 0; i < _size; ++i) 
+					for (size_t j = 0; j <= N; ++j)
+						w[i*at+j] = v.w[i*vat+j];
+		}
+		return *this;
+	}
+	template <class E> varray& operator = (const E& e)
+	{
+		for (size_t i = 0; i < _size; ++i) (*this)[i] = e[i];
+		return *this;
+	}
+	varray& operator = (T a)
+	{
+		for (size_t i = 0; i < _size; ++i) {
+			T *p = (*this)(i); p[0] = a;
+			for (size_t j = 1; j <= N; ++j) p[j] = 0.0;
+		}
+		return *this;
+	}
+	operator T* () const { return w; }
+real<T>& operator * () { return *(real<T>*)this; }
+T * operator () (size_t n) const { return &w[n*(N+1)*_st]; }
+real<T> operator [] (size_t n) const { return real<T>(varray(&w[n*(N+1)*_st], _size - n, N, _st)); }
+	varray operator -() const { varray r(*this); for (size_t i = 0; i < _size; ++i) r[i] *= -1.0; return r; }
+friend varray abs(const varray& v) { varray r(v._size, v.N); for (size_t i = 0; i < r._size; ++i) r[i] = abs(v[i]); return r; }
+friend real<T> dot(const varray& u, const varray& v)
+{
+	assert(u._size == v._size);
+	real<T> w(u.N > v.N ? u.N : v.N);
+	for (size_t i = 0; i < u._size; ++i) w += u[i] * v[i];
+	return sqrt(w);
+}
+	size_t size() const { return _size; }
+	size_t atom() const { return     N; }
+	int  stride() const { return   _st; }
+	size_t data_size() const { return _size * (N + 1) * _st; }
+	varray& operator += (T t) { for (size_t i = 0; i < _size; ++i) (*this)[i] += t; return *this; }
+	varray& operator -= (T t) { for (size_t i = 0; i < _size; ++i) (*this)[i] -= t; return *this; }
+	varray& operator *= (T t) { for (size_t i = 0; i < _size; ++i) (*this)[i] *= t; return *this; }
+	varray& operator /= (T t) { for (size_t i = 0; i < _size; ++i) (*this)[i] /= t; return *this; }
+	varray& operator += (const real<T>& r) { for (size_t i = 0; i < _size; ++i) (*this)[i] += r; return *this; }
+	varray& operator -= (const real<T>& r) { for (size_t i = 0; i < _size; ++i) (*this)[i] -= r; return *this; }
+	varray& operator *= (const real<T>& r) { for (size_t i = 0; i < _size; ++i) (*this)[i] *= r; return *this; }
+	varray& operator /= (const real<T>& r) { for (size_t i = 0; i < _size; ++i) (*this)[i] /= r; return *this; }
+	template <class E> varray& operator += (const E& e) { for (size_t i = 0; i < _size; ++i) (*this)[i] += e[i]; return *this; }
+	template <class E> varray& operator -= (const E& e) { for (size_t i = 0; i < _size; ++i) (*this)[i] -= e[i]; return *this; }
+	template <class E> varray& operator *= (const E& e) { for (size_t i = 0; i < _size; ++i) (*this)[i] *= e[i]; return *this; }
+	template <class E> varray& operator /= (const E& e) { for (size_t i = 0; i < _size; ++i) (*this)[i] /= e[i]; return *this; }
+	template <class R> friend expr<varray,add,R> operator + (const varray& l, const R& r) { return expr<varray,add,R>(l, r); }
+friend expr<varray,add,varray> operator + (const varray& l, const varray& r) { return expr<varray,add,varray>(l, r); }
+friend expr<varray,sub,varray> operator - (const varray& l, const varray& r) { return expr<varray,sub,varray>(l, r); }
+friend expr<varray,mul,varray> operator * (const varray& l, const varray& r) { return expr<varray,mul,varray>(l, r); }
+friend expr<varray,div,varray> operator / (const varray& l, const varray& r) { return expr<varray,div,varray>(l, r); }
+friend expr<varray,add,real<T> > operator + (const varray& l, const real<T>& r) { return expr<varray,add,real<T> >(l, r); }
+friend expr<varray,sub,real<T> > operator - (const varray& l, const real<T>& r) { return expr<varray,sub,real<T> >(l, r); }
+friend expr<varray,mul,real<T> > operator * (const varray& l, const real<T>& r) { return expr<varray,mul,real<T> >(l, r); }
+friend expr<varray,div,real<T> > operator / (const varray& l, const real<T>& r) { return expr<varray,div,real<T> >(l, r); }
+friend expr<real<T>,add,varray> operator + (const real<T>& l, const varray& r) { return expr<real<T>,add,varray>(l, r); }
+friend expr<real<T>,sub,varray> operator - (const real<T>& l, const varray& r) { return expr<real<T>,sub,varray>(l, r); }
+friend expr<real<T>,mul,varray> operator * (const real<T>& l, const varray& r) { return expr<real<T>,mul,varray>(l, r); }
+friend expr<real<T>,div,varray> operator / (const real<T>& l, const varray& r) { return expr<real<T>,div,varray>(l, r); }
+friend expr<varray,add,T> operator + (const varray& l, T r) { return expr<varray,add,T>(l, r); }
+friend expr<varray,sub,T> operator - (const varray& l, T r) { return expr<varray,sub,T>(l, r); }
+friend expr<varray,mul,T> operator * (const varray& l, T r) { return expr<varray,mul,T>(l, r); }
+friend expr<varray,div,T> operator / (const varray& l, T r) { return expr<varray,div,T>(l, r); }
+friend expr<T,add,varray> operator + (const T l, const varray& r) { return expr<T,add,varray>(l, r); }
+friend expr<T,sub,varray> operator - (const T l, const varray& r) { return expr<T,sub,varray>(l, r); }
+friend expr<T,mul,varray> operator * (const T l, const varray& r) { return expr<T,mul,varray>(l, r); }
+friend expr<T,div,varray> operator / (const T l, const varray& r) { return expr<T,div,varray>(l, r); }
+	char *to_s(const char *f = "%g") const;
+	void fprint(FILE *f, const char *fmt = "%g\n") const { gprint(*this, f, fmt); }
+	void print(const char *fmt = "%g\n") const { this->fprint(stdout, fmt); }
+};
+
+#include "basis/real_inline.h"
+
+template <typename T = double> class marray_view;
+
+template <typename T = double> class marray
+{
+	size_t r, c, a; T **index, *data;
+  public:
+	marray() : r(), c(), a(), index(nullptr), data(nullptr) {}
+	marray(size_t nr, size_t nc, size_t na = 0, const T *dat = NULL) : r(nr), c(nc), a(na)
+	{
+		index = create_marray<T>(r, c, a); data = *index;
+		if (dat) for (size_t i = 0; i < r * c * (a + 1); ++i) data[i] = dat[i];
+	}
+	marray(const marray& m) : r(m.r), c(m.c), a(m.a)
+	{
+		index = create_marray<T>(r, c, a); data = *index;
+		for (size_t i = 0; i < r; ++i)
+			for (size_t j = 0; j < c; ++j)
+				for (size_t k = 0; k <= a; ++k)
+					index[i][j*(a+1)+k] = m.index[i][j*(a+1)+k];
+	}
+	marray(const marray_view<T>& m) : r(m.rows()), c(m.cols()), a(m.atom())
+	{
+		index = create_marray<T>(r, c, a); data = *index;
+		T **m_index = m;
+		for (size_t i = 0; i < r; ++i)
+			for (size_t j = 0; j < c; ++j)
+				for (size_t k = 0; k <= a; ++k)
+					index[i][j*(a+1)+k] = m_index[i][j*(a+1)+k];
+	}
+	~marray() { free((void*)index); }
+	marray& operator = (const marray& m)
+	{
+		if (this != &m) {
+			free((void*)index);
+			r = m.r; c = m.c; a = m.a;
+			index = create_marray<T>(r, c, a); data = *index;
+			for (size_t i = 0; i < r; ++i)
+				for (size_t j = 0; j < c; ++j)
+					for (size_t k = 0; k <= a; ++k)
+						index[i][j*(a+1)+k] = m.index[i][j*(a+1)+k];
+		}
+		return *this;
+	}
+    operator T** () const { return index; }
+T * operator * () const { return data; }
+varray<T> operator [] (size_t i) const { return varray<T>(index[i], c, a); }
+T * operator () (size_t i, size_t j) const { return &index[i][j*(a+1)]; }
+	void row_swap(size_t i, size_t j) { T *w = index[i]; index[i] = index[j]; index[j] = w; }
+	void col_swap(size_t i, size_t j);
+	size_t rows() const { return r; }
+	size_t cols() const { return c; }
+	size_t atom() const { return a; }
+	size_t data_size() const { return r * c * (a + 1); }
+	varray<T> row(size_t i) const { return varray<T>(index[i], c, a); }
+	varray<T> col(size_t i) const { return varray<T>(data + i*(a+1), r, a, c); }
+	char *to_s(const char *f = "%g") const;
+	void fprint(FILE *f, const char *fmt = "%g\n") const { gprint(*this, f, fmt); }
+	void print(const char *fmt = "%g\n") const { this->fprint(stdout, fmt); }
+};
+
+template <typename T> void marray<T>::col_swap(size_t i, size_t j)
+{
+	if (i == j) return;
+	T *u = &data[i * (a + 1)], v = &data[j * (a + 1)], w[a + 1];
+	for (size_t k = 0; k < r; ++k, u += c * (a + 1), v += c * (a + 1)) {
+		qd_ass(a, w, u); qd_ass(a, u, v); qd_ass(a, v, w);
+	}
+}
+
+template <typename T> class marray_view
+{
+	size_t r, c, a; T **index, *data;
+  public:
+	marray_view(T *dat, size_t nr, size_t nc, size_t na = 0) : r(nr), c(nc), a(na)
+	{
+		index = (T**)malloc(r * sizeof(T*)); data = dat;
+		index[0] = data;
+		for (size_t i = 1; i < r; ++i) index[i] = index[i-1] + c * (a + 1);
+	}
+	marray_view(const marray<T>& m) : r(m.rows()), c(m.cols()), a(m.atom())
+	{
+		index = (T**)malloc(r * sizeof(T*)); data = *m;
+		T **m_index = m;
+		for (size_t i = 0; i < r; ++i) index[i] = m_index[i];
+	}
+	marray_view(const marray_view& m) : r(m.r), c(m.c), a(m.a)
+	{
+		index = (T**)malloc(r * sizeof(T*)); data = m.data;
+		T **m_index = m;
+		for (size_t i = 0; i < r; ++i) index[i] = m_index[i];
+	}
+	~marray_view() { free((void*)index); }
+	marray_view& operator = (const marray_view&) = delete;
+	operator T** () const { return index; }
+T * operator * () const { return data; }
+varray<T> operator [] (size_t i) const { return varray<T>(index[i], c, a); }
+T * operator () (size_t i, size_t j) const { return &index[i][j*(a+1)]; }
+	void row_swap(size_t i, size_t j) { T *w = index[i]; index[i] = index[j]; index[j] = w; }
+	void col_swap(size_t i, size_t j);
+	size_t rows() const { return r; }
+	size_t cols() const { return c; }
+	size_t atom() const { return a; }
+	size_t data_size() const { return r * c * (a + 1); }
+	varray<T> row(size_t i) const { return varray<T>(index[i], c, a); }
+	varray<T> col(size_t i) const { return varray<T>(data + i*(a+1), r, a, c); }
+	char *to_s(const char *f = "%g") const;
+	void fprint(FILE *f, const char *fmt = "%g\n") const { gprint(*this, f, fmt); }
+	void print(const char *fmt = "%g\n") const { this->fprint(stdout, fmt); }
+};
+
+template <typename T> void marray_view<T>::col_swap(size_t i, size_t j)
+{
+	if (i == j) return;
+	T *u = &data[i * (a + 1)], v = &data[j * (a + 1)], w[a + 1];
+	for (size_t k = 0; k < r; ++k, u += c * (a + 1), v += c * (a + 1)) {
+		qd_ass(a, w, u); qd_ass(a, u, v); qd_ass(a, v, w);
+	}
+}
+
+template <typename T = double>
+void kronecker(const varray<T>& p, const varray<T>& q, const varray<T>& r)
+{
+	size_t s = p.size(), t = q.size(), a = r.atom();
+	for (size_t i = 0; i < s; i++)
+		for (size_t j = 0; j < t; j++)
+			qd_mul(a, r(i*t+j), p(i), q(j));
+}
+
+template <typename T = double>
+void kronecker(const marray<T>& p, const marray<T>& q, const marray<T>& r)
+{
+	size_t s = p.rows(), t = q.rows();
+	for (size_t i = 0; i < s; i++)
+		for (size_t j = 0; j < t; j++)
+			kronecker(p.row(i), q.row(j), r.row(i*t+j));
+}
+
+template <typename T = double>
+marray<T> operator^(const marray<T>& p, const marray<T>& q)
+{
+	size_t r = p.rows() * q.rows(), c = p.cols() * q.cols(), a = p.atom();
+	assert(a == q.atom());
+	marray<T> result(r, c, a);
+	kronecker(p, q, result);
+	return result;
+}
+
+#ifdef CROUT
+#include "basis/matrix_luc_ext.h"
+#else
+#include "basis/matrix_lud_ext.h"
+#endif
+
+template <typename T= double> class marray_lu : public marray<T>
+{
+	size_t *p; int s;
+
+  public:
+	marray_lu(const marray<T>& ma) : marray<T>(ma), p(new size_t[ma.rows()])
+	{
+		lu_decomp<T,marray<T> >(*this, p, s);
+	}
+	marray_lu(const marray_view<T>& ma) : marray<T>(ma), p(new size_t[ma.rows()])
+	{
+		lu_decomp<T,marray<T> >(*this, p, s);
+	}
+	marray_lu(const marray_lu&) = delete;
+	~marray_lu() { delete[] p; }
+	marray_lu& operator = (const marray_lu&) = delete;
+	template <class S> void solve(const varray<S>& b, varray<S>& x)
+	{
+		if (&x != &b) for (size_t i = 0; i < x.size(); ++i) x[i] = b[i];
+		lu_subst<T,marray<T> >(*this, p, x);
+	}
+	template <class S> void solve(const marray<S>& b, marray<S>& x)
+	{
+		if (&x != &b) memcpy(*x, *b, x.data_size() * sizeof(T));
+		size_t K = x.cols();
+		for (size_t i = 0; i < K; ++i) {
+			varray<T> v = x.col(i);
+			lu_subst<T,marray<T> >(*this, p, v);
+		}
+	}
+	template <class S> S solve(const S& b)
+	{
+		S result(b);
+		lu_subst<T,marray<T> >(*this, p, result);
+		return result;
+	}
+	real<T> det()
+	{
+		size_t N = this->rows(), a = this->atom();
+		real<T> result(a); result = s; T *u = result;
+		for (size_t k = 0; k < N; ++k) qd_mul(a, u, u, (*this)(k,k)); // det *= A[k][k];
+		return result;
+	}
+
+};	// end of marray_lu;
+
+template <typename T = double> class marray_lu_view : public marray_view<T>
+{
+	size_t *p; int s;
+
+  public:
+	marray_lu_view(const marray<T>& ma) : marray_view<T>(ma), p(new size_t[ma.rows()])
+	{
+		lu_decomp<T,marray_view<T>>(*this, p, s);
+	}
+	marray_lu_view(const marray_view<T>& ma) : marray_view<T>(ma), p(new size_t[ma.rows()])
+	{
+		lu_decomp<T,marray_view<T>>(*this, p, s);
+	}
+	marray_lu_view(const marray_lu_view&) = delete;
+	~marray_lu_view() { delete[] p; }
+	marray_lu_view& operator = (const marray_lu_view&) = delete;
+	template <class S> void solve(const varray<S>& b, varray<S>& x)
+	{
+		if (&x != &b) for (size_t i = 0; i < x.size(); ++i) x[i] = b[i];
+		lu_subst<T,marray_view<T> >(*this, p, x);
+	}
+	template <class S> void solve(const marray_view<S>& b, marray_view<S>& x)
+	{
+		if (&x != &b) memcpy(*x, *b, x.data_size() * sizeof(T));
+		lu_subst<T,marray_view<T> >(*this, p, x);
+	}
+	template <class S> S solve(const S& b)
+	{
+		S result(b);
+		lu_subst<T,marray_view<T> >(*this, p, result);
+		return result;
+	}
+	real<T> det()
+	{
+		size_t N = this->rows(), a = this->atom();
+		real<T> result(a); result = s; T *u = result;
+		for (size_t k = 0; k < N; ++k) qd_mul(a, u, u, (*this)(k,k)); // det *= A[k][k];
+		return result;
+	}
+
+};	// end of marray_lu_view;
+
+template <typename T = double> class carray
+{
+	size_t n, *s, a; T **index, *data;
+  public:
+	carray(size_t ns, size_t *sp, size_t na): n(ns), s(new size_t[ns]), a(na)
+	{
+		for (size_t i = 0; i < n; i++) s[i] = sp[i];
+		index = create_carray<T>(n, s, a); data = index[0];
+	}
+	carray(const carray& ca) : n(ca.n), s(new size_t[ca.n]), a(ca.a)
+	{
+		size_t size = 0;
+		for (size_t i = 0; i < n; i++) { s[i] = ca.s[i]; size += s[i]*(a+1); }
+		index = create_carray<T>(n, s, a); data = index[0];
+		for (size_t i = 0; i < size; ++i) data[i] = ca.data[i];
+	}
+	~carray() { free((void*)index); delete[] s; }
+	carray& operator = (const carray&) = delete;
+    operator T** () const { return index; }
+T * operator * () const { return data; }
+varray<T> operator [] (size_t i) const { return varray<T>(index[i], s[i], a); }
+T * operator () (size_t i, size_t j) const { return &index[i][j*(a+1)]; }
+	size_t size(size_t i) const { return s[i]; }
+	size_t rows() const { return n; }
+	size_t atom() const { return a; }
+	varray<T> row(size_t i) const { return varray<T>(index[i], s[i], a); }
+};	// end of carray;
+
+template <typename T = double> class carray_view
+{
+	size_t n, *s, a; T **index, *data;
+  public:
+	carray_view(const carray<T>& ca) : n(ca.rows()), s(new size_t[n]), a(ca.atom())
+	{
+		index = (T**)malloc(n * sizeof(T*)); data = *ca;
+		for (size_t i = 0; i < n; ++i) {
+			s[i] = ca.size(i);
+			if (i == 0) index[0] = data;
+			else index[i] = index[i-1] + s[i-1]*(a+1);
+		}
+	}
+	carray_view(size_t ns, size_t *sp, size_t na, T *dat) : n(ns), s(new size_t[n]), a(na)
+	{
+		index = (T**)malloc(n * sizeof(T*)); data = dat;
+		for (size_t i = 0; i < n; ++i) {
+			s[i] = sp[i];
+			if (i == 0) index[0] = data;
+			else index[i] = index[i-1] + s[i-1]*(a+1);
+		}
+	}
+	carray_view(const carray_view& cv) : n(cv.n), s(new size_t[n]), a(cv.a)
+	{
+		index = (T**)malloc(n * sizeof(T*)); data = cv.data;
+		for (size_t i = 0; i < n; ++i) {
+			s[i] = cv.s[i];
+			if (i == 0) index[0] = data;
+			else index[i] = index[i-1] + s[i-1]*(a+1);
+		}
+	}
+	~carray_view() { free((void*)index); delete[] s; }
+	carray_view& operator = (const carray_view&) = delete;
+    operator T** () const { return index; }
+T * operator * () const { return data; }
+varray<T> operator [] (size_t i) const { return varray<T>(index[i], s[i], a); }
+T * operator () (size_t i, size_t j) const { return &index[i][j*(a+1)]; }
+	size_t size(size_t i) const { return s[i]; }
+	size_t rows() const { return n; }
+	size_t atom() const { return a; }
+	varray<T> row(size_t i) const { return varray<T>(index[i], s[i], a); }
+// end of carray_view;
+};
+
+template <typename T = double> class parray
+{
+	T **index, *data; int o, s, k, a;
+  public:
+	parray(int no, int ns, int nk, int na) : o(no), s(ns), k(nk), a(na)
+	{
+		index = create_marray<T>(k, s, a); data = index[0];
+	}
+	parray(const parray& p) : o(p.o), s(p.s), k(p.k), a(p.a)
+	{
+		index = create_marray<T>(k, s, a); data = index[0];
+		for (int i = 0; i < s * k * (a + 1); ++i) data[i] = p.data[i];
+	}
+	~parray() { free((void*)index); }
+	parray& operator=(const parray&) = delete;
+    operator T** () const { return index; }
+T * operator * () const { return data; }	// return index block;
+varray<T> operator [] (int i) const { assert(i < k); return varray<T>(index[i], s, a); }
+T * operator () (int i, int j) const { return &index[j][i*(a+1)]; }
+int operator () (int i) { return i == 0 ? o : i == 1 ? s : i == 2 ? k : a; }
+	int offset() const { return o; }
+	int   size() const { return s; }
+	int   rows() const { return k; }
+	int   atom() const { return a; }
+	varray<T> row(int i) const { assert(i < k); return varray<T>(index[i], s, a); }
+	varray<T> col(int i) const { assert(i < s); return varray<T>(data + i * (a + 1), k, a, s); }
+	real<T> saylor(int i, const real<T>& h)
+	{
+		real<T> q((size_t)a);
+		for (int j = k; j > 0; --j) {
+			real<T> r(size_t(a), (*this)(i, j-1), 0);
+			q = (q + r) * h / T(j);
+		}
+		return q;
+	}
+	real<T> taylor(int i, const real<T>& h)
+	{
+		real<T> q((size_t)a);
+		for (int j = k; j > 0; --j) {
+			real<T> r(size_t(a), (*this)(i, j-1), 0);
+			q = q * h / T(j) + r;
+		}
+		return q;
+	}
+};
+
+typedef int * narray;
+typedef varray<double> Vector;
+typedef marray<double> Matrix;
+typedef marray_view<double> Matrix_view;
+
+#endif