pspline 5.0.5 → 5.1.0

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

@@ -0,0 +1,454 @@
+#ifndef _POLY_H_
+#define _POLY_H_
+
+template <typename T>
+void poly_subst(int n, T *w)
+{
+	for (int i = 0; i <= n; ++i) w[i] = T(0);
+}
+
+template <typename T, class... Args>
+void poly_subst(int n, T *w, T car, Args... cdr)
+{
+	w[0] = car; if (n > 0) poly_subst<T>(n-1, &w[1], cdr...);
+}
+
+/*******************************************************************************
+	poly<T,N>(T[N]);
+	[T0,...,TN]
+*******************************************************************************/
+template<typename T> class poly
+{
+
+	size_t N; T *w;	// data fields
+
+public:
+// constructor
+poly() : N(0), w(NULL) {}
+//	poly<N>(T0, ...);
+template<class... Args>
+poly(const T car, const Args... cdr) : N(sizeof...(cdr)), w(new T[N])
+{
+	w[0] = car; if (N > 0) poly_subst(N-1, &w[1], cdr...);
+}
+// copy construtor
+poly(const poly& p) : N(p.N), w(new T[N])
+{
+	for (size_t i = 0; i <= N; i++) w[i] = p.w[i];
+}
+// default destructor
+~poly() { delete[] w; }
+// assignment operator
+poly& operator = (const poly& p)
+{
+	if (this != &p) {
+		delete[] w;
+		N = p.N; w = new T[N];
+		for (size_t i = 0; i <= N; i++) w[i] = p.w[i];
+	}
+	return *this;
+}
+// assignment grid size
+poly& operator = (const T *a)
+{
+	for(size_t i = 0; i < N; ++i) w[i] = a[i];
+	return *this;
+}
+// assignment unit size
+poly& operator = (const T a)
+{
+	w[N] = a;
+	return *this;
+}
+char *to_s(const char *f = "%g") const
+{
+	str_buf c;
+	c += '<';
+	for (size_t i = 0; i <= N; i++) {
+		sprintg(c, w[i], f);
+		if (i < N) c += ',';
+	}
+	c += '>';
+	char *result = new char[c.size() + 1];
+	strcpy(result, c.c_str());
+	return result;
+}
+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); }
+
+};	// end of poly;
+
+typedef unsigned short UTYPE;
+
+const size_t _Z = 7;
+
+template <> class poly<int>
+{
+	UTYPE w[_Z+1];
+
+  public:
+
+// default constructor
+poly() { for (UTYPE &z : w) z = 0; }
+// general constructor
+poly(size_t n)
+{
+	for (size_t i = 0; i < _Z; ++i) w[i] = 0;
+	w[_Z] = static_cast<UTYPE>(n);
+}
+template<class... Args>
+poly(const int car, const Args... cdr)
+{
+	size_t N = sizeof...(cdr);
+	assert(N < _Z);
+	w[0] = car; if (N > 0) poly_subst<UTYPE>(int(N-1), &w[1], cdr...);
+	w[_Z] = static_cast<UTYPE>(N);
+}
+poly(int n, int *s)
+{
+	size_t N = n;
+	assert(N < _Z);
+	for (size_t i = 0; i < _Z; ++i)
+		w[i] = (i <= N) ? static_cast<UTYPE>(s[i]) : 0;
+	w[_Z] = static_cast<UTYPE>(N);
+}
+poly(int n, const int *s, int m)
+{
+	size_t N = n;
+	assert(N < _Z);
+	for (size_t i = 0; i < _Z; ++i)
+		w[i] = (i < N) ? static_cast<UTYPE>(s[i]) : 0;
+		w[N] = m;
+	w[_Z] = static_cast<UTYPE>(N);
+}
+// default copy constructor
+// default destructor
+// assignment operator
+poly& operator = (const poly& p)
+{
+	if (this != &p) for (size_t i = 0; i <= _Z; ++i) w[i] = p.w[i];
+	return *this;
+}
+// assignment grid size
+poly& operator = (const int *s)
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	for (size_t i = 0; i < N; ++i)
+		w[i] = static_cast<UTYPE>(s[i]);
+	return *this;
+}
+// assignment unit size
+poly& operator = (int t)
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	w[N] = static_cast<UTYPE>(t);
+	return *this;
+}
+friend poly operator * (const poly& p, const poly& q)
+{
+	size_t N = static_cast<size_t>(q.w[_Z]);
+	assert(q.w[_Z] == p.w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i) result.w[i] = p.w[i] * q.w[i];
+	result.w[N] = p.w[N];
+	return result;
+}
+friend poly operator * (const poly& p, int a)
+{
+	int N = static_cast<int>(p.w[_Z]);
+	poly result(N);
+	for (int i=0;i<N;++i) result.w[i] = p.w[i] * static_cast<UTYPE>(a);
+	result.w[N] = p.w[N];
+	return result;
+}
+friend poly operator * (int a, const poly& p)
+{
+	return (p * a);
+}
+friend poly operator + (const poly& p, const poly& q)
+{
+	assert(q.w[_Z] == p.w[_Z]);
+	size_t N = static_cast<size_t>(p.w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i) result.w[i] = p.w[i] + q.w[i];
+	result.w[N] = p.w[N];
+	return result;
+}
+friend poly operator + (const poly& p, int a)
+{
+	size_t N = static_cast<size_t>(p.w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i) result.w[i] = p.w[i] + static_cast<UTYPE>(a);
+	result.w[N] = p.w[N];
+	return result;
+}
+friend poly operator + (int a, const poly& p)
+{
+	return (p + a);
+}
+friend poly operator - (const poly& p, const poly& q)
+{
+	assert(q.w[_Z] == p.w[_Z]);
+	size_t N = static_cast<size_t>(p.w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i) result.w[i] = p.w[i] - q.w[i];
+	result.w[N] = p.w[N];
+	return result;
+}
+friend poly operator - (const poly& p, int a)
+{
+	size_t N = static_cast<size_t>(p.w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i) result.w[i] = p.w[i] - static_cast<UTYPE>(a);
+	result.w[N] = p.w[N];
+	return result;
+}
+friend poly operator - (int a, const poly& p)
+{
+	size_t N = static_cast<size_t>(p.w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i) result.w[i] = static_cast<UTYPE>(a) - p.w[i];
+	result.w[N] = p.w[N];
+	return result;
+}
+poly operator % (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	poly result(N);
+	for (size_t i=0;i<N;++i)
+		result.w[i] = w[i] % a;
+		result.w[N] = w[N];
+	return result;
+}
+poly& operator += (int a)
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	for(size_t i=0;i<N;i++) w[i] += static_cast<UTYPE>(a);
+	return *this;
+}
+poly& operator -= (int a)
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	for(size_t i=0;i<N;i++) w[i] -= static_cast<UTYPE>(a);
+	return *this;
+}
+bool operator == (const poly& p) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i; for(i=0;i<=N;++i) if(w[i] != p.w[i]) break;
+	return i > N;
+}
+bool operator != (const poly& p) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i; for(i=0;i<=N;i++) if(w[i] != p.w[i]) break;
+	return i <= N;
+}
+bool operator > (const poly& p) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(w[_Z] == p.w[_Z]);
+	size_t i; for(i=0;i<N;++i) if(w[i] <= p.w[i]) break;
+	return i == N && w[N] == p.w[N];
+}
+bool operator >= (const poly& p) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(w[_Z] == p.w[_Z]);
+	size_t i; for(i=0;i<N;++i) if(w[i] < p.w[i]) break;
+	return i == N && w[N] == p.w[N];
+}
+bool operator < (const poly& p) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(w[_Z] == p.w[_Z]);
+	size_t i; for(i=0;i<N;i++) if(w[i] >= p.w[i]) break;
+	return i == N && w[N] == p.w[N];
+}
+bool operator <= (const poly& p) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(w[_Z] == p.w[_Z]);
+	size_t i; for(i=0;i<N;i++) if(w[i] > p.w[i]) break;
+	return i == N && w[N] == p.w[N];
+}
+bool operator == (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i;
+	for (i = 0; i < N; ++i) if (w[i] != a) break;
+	return i == N;
+}
+bool operator != (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i;
+	for (i = 0; i < N; ++i) if (w[i] != a) break;
+	return i != N;
+}
+bool operator < (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i;
+	for (i = 0; i < N; ++i) if (w[i] >= a) break;
+	return i == N;
+}
+bool operator >= (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i;
+	for (i = 0; i < N; ++i) if (w[i] < a) break;
+	return i == N;
+}
+bool operator > (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i;
+	for (i = 0; i < N; ++i) if (w[i] <= a) break;
+	return i == N;
+}
+bool operator <= (int a) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t i;
+	for (i = 0; i < N; ++i) if (w[i] > a) break;
+	return i == N;
+}
+// member function
+size_t length() const {return static_cast<size_t>(w[_Z]) + 1;}
+size_t grid() const { return static_cast<size_t>(w[_Z]); }
+size_t grid(size_t i) const { return static_cast<size_t>(w[i]); }
+size_t atom() const { return grid(static_cast<size_t>(w[_Z])); }
+size_t unit() const { return grid(static_cast<size_t>(w[_Z])-1); }
+size_t line() const { return grid(static_cast<size_t>(w[_Z])-2); }
+size_t plat() const { return grid(static_cast<size_t>(w[_Z])-3); }
+size_t cube() const { return grid(static_cast<size_t>(w[_Z])-4); }
+size_t grid_size(size_t n = 0) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(n <= N);
+	size_t z = 1;
+	for (size_t i = N - n; i > 0; --i) z *= static_cast<size_t>(w[i-1]);
+	return z;
+}
+size_t atom_size() const { return grid_size(0); }
+size_t unit_size() const { return grid_size(1); }
+size_t line_size() const { return grid_size(2); }
+size_t plat_size() const { return grid_size(3); }
+size_t cube_size() const { return grid_size(4); }
+// w[n] * ... * w[N-1] * w[N]
+size_t data_size(size_t n = 0) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t z = (n > N) ? 1 : (static_cast<size_t>(w[N]) + 1);
+	for(size_t i = N; i > n; --i) z *= static_cast<size_t>(w[i-1]);
+	return z;
+}
+// (w[m] + ... + w[n-1]) * w[N]
+size_t comb_size(size_t n = 0) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(n < N);
+	size_t z = 0;
+	for(size_t i = N; i > n; --i) z += static_cast<size_t>(w[i-1]);
+	return z * (static_cast<size_t>(w[N]) + 1);
+}
+// (w[m] + ... + w[n-1]) * w[N-1] * w[N]
+size_t cast_size(size_t n, size_t m = 0) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(0 < N && n < N && m <= n);
+	size_t z = 0;
+	for(size_t i = m; i < n; ++i) z += static_cast<size_t>(w[i]);
+	return z * data_size(N-1);
+}
+// w[0] + ... + w[N-1]
+size_t band() const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t z = 0;
+	for (size_t k = 0; k < N; ++k) z += static_cast<size_t>(w[k]);
+	return z;
+}
+size_t band_size(size_t i = 0) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	assert(i <= N);
+	size_t z = 0;
+	for (size_t k = 0; k < i; ++k) z += static_cast<size_t>(w[k]);
+	return z * (static_cast<size_t>(w[N]) + 1);
+}
+// calculate Atom Position
+size_t operator && (const poly& q) const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	size_t M = static_cast<size_t>(q.w[_Z]);
+	assert(N >= M);
+	size_t sum = static_cast<size_t>(q.w[M]) * data_size(M+1);
+	size_t sek = static_cast<size_t>(w[N]) + 1;
+	for (size_t i = N; i > 0; --i) {
+		if (i <= M)
+		sum += sek * static_cast<size_t>(q.w[i-1]);
+		sek *= static_cast<size_t>(w[i-1]);
+	}
+	return sum;
+}
+// Modular operation : Unit No. -> Poly Grid.
+friend poly operator % (size_t a, const poly& q)
+{
+	size_t N = static_cast<size_t>(q.w[_Z]);
+	poly p(N);
+	for (size_t i = N; i > 0; --i) {
+		size_t t = static_cast<size_t>(q.w[i-1]);
+		p.w[i-1] = static_cast<UTYPE>(a % t);
+		a /= t;
+	}	p.w[N] = 0;
+	return p;
+}
+// Referrece of element.
+int operator[] (int n) const { return static_cast<int>(w[n]); }
+UTYPE& operator[] (int i) { return w[i]; }
+poly operator<<(int i) const
+{
+	size_t N = static_cast<int>(w[_Z]), M = N - i;
+	poly z(M);
+	for (size_t j = 0; j <= M; ++j) z.w[j] = w[static_cast<size_t>(i)+j];
+	return z;
+}
+poly operator>>(int i) const
+{
+	size_t N = static_cast<int>(w[_Z]), M = N - i;
+	poly z(M);
+	size_t t = data_size(M);
+	for (size_t j = 0; j < M; ++j) z.w[j] = w[j];
+	z.w[M] = static_cast<UTYPE>(t);
+	return z;
+}
+char *to_s(const char *f = "%d") const
+{
+	size_t N = static_cast<size_t>(w[_Z]);
+	str_buf c;
+	c += '<';
+	if (N > 0) {
+		c += '{';
+		for (size_t i = 0; i < N; i++) {
+			sprintg(c, (int)w[i], f);
+			if (i < N-1) c += ',';
+		}
+		c += "},";
+	}	sprintg(c, (int)w[N], f);
+	c += '>';
+	char *result = new char[c.size() + 1];
+	strcpy(result, c.c_str());
+	return result;
+}
+void fprint(FILE *f, const char *fmt = "%d\n") const { gprint(*this, f, fmt); }
+void print(const char *fmt = "%d\n") const { this->fprint(stdout, fmt); }
+
+}; // end of poly<int>;
+
+typedef poly<int> Int;
+
+#include "basis/real.h"
+
+#endif