pspline 5.0.4 → 5.0.5

data/ext/pspline/include/bspline_Config.h

@@ -1,2 +1,2 @@
-#define bspline_VERSION 5.0
-#define bspline_TYPE 5
+#define bspline_VERSION 5.0
+#define bspline_TYPE 5

data/ext/pspline/plotsub.cpp

@@ -11,6 +11,7 @@
 #include "basis/basis.h"
 #include "basis/pspline.h"
 
+// 偏微分プロット
 template <typename T, typename S>
 int plot(const pspline<T,S>& B, const comb_array<S>& x, S **Xp, T **Yp, int Dp, const int *b)
 {
@@ -32,6 +33,9 @@ int plot(const pspline<T,S>& B, const comb_array<S>& x, S **Xp, T **Yp, int Dp,
 	return Npx;
 }
 
+template int plot(const pspline<double>&, const comb_array<double>&, double**, double**, int, const int*);
+
+// 全微分プロット
 template <typename T, typename S>
 int plot(const pspline<T,S>& B, const comb_array<S>& x, S **Xp, T **Yp, int Dp, int Jbn, S *jb)
 {
@@ -53,11 +57,13 @@ int plot(const pspline<T,S>& B, const comb_array<S>& x, S **Xp, T **Yp, int Dp,
 	return Npx;
 }
 
+template int plot(const pspline<double>&, const comb_array<double>&, double**, double**, int, int, double*);
+
+// １変数関数積プロット
 template <typename T, typename S>
 int plot(const pspline<T,S>& B, int n, S *x, S **Xp, T **Yp, int Dp, int b)
 {
 	int K = B.Unit_size();
-	int jb[] = {b};
 
 	int Npx = (n - 1) * Dp + 1;
 	*Xp = T_ALLOC(S, Npx);
@@ -68,15 +74,17 @@ int plot(const pspline<T,S>& B, int n, S *x, S **Xp, T **Yp, int Dp, int b)
 		for (int Nd = N0; Nd <= Dp; Nd++) {
 			int Np = Nd + (L-1) * Dp;
 			S Tp = x[L-1] + Nd * DT;
-			poly<S> Sp(1, Tp, (S)0);
 			(*Xp)[Np] = Tp;
-			poly_array<T> Z = B(Sp, jb);
+			poly_array<T> Z = B(Tp, b);
 			for (int i = 0; i < K; ++i) Yp[i][Np] = Z[i];
 		}
 	}
 	return Npx;
 }
 
+template int plot(const pspline<double>&, int, double *, double **, double **, int, int);
+
+// １変数関数プロット（インデックス）
 template <typename T, typename S>
 int plot(const bspline<T,S>& B, const comb_array<S>& x, S **Xp, T **Yp, int Dp, int Jbn)
 {
@@ -102,6 +110,9 @@ int plot(const bspline<T,S>& B, const comb_array<S>& x, S **Xp, T **Yp, int Dp,
 	return Npx;
 }
 
+template int plot(const bspline<double>&, const comb_array<double>&, double **, double **, int, int);
+
+// １変数関数プロット
 template <typename T, typename S>
 int plot(const bspline<T,S>& B, int n, S *x, S **Xp, T **Yp, int Dp, int b)
 {
@@ -124,9 +135,5 @@ int plot(const bspline<T,S>& B, int n, S *x, S **Xp, T **Yp, int Dp, int b)
 	return Npx;
 }
 
-template int plot(const pspline<double,double>&, const comb_array<double>&, double**, double**, int, const int*);
-template int plot(const pspline<double,double>&, const comb_array<double>&, double**, double**, int, int, double*);
-template int plot(const pspline<double,double>&, int, double *, double **, double **, int, int);
-template int plot(const bspline<double,double>&, const comb_array<double>&, double **, double **, int, int);
-template int plot(const bspline<double,double>&, int, double *, double **, double **, int, int);
+template int plot(const bspline<double>&, int, double *, double **, double **, int, int);
 

data/ext/pspline/pspline.cpp

@@ -540,6 +540,8 @@ try {
 	return Wrap_bspline(cBspline, result);
 }
 
+static VALUE _wrap_bspline_mul(VALUE self, VALUE varg);
+
 static void
 _wrap_Init_bspline(void)
 {
@@ -552,6 +554,7 @@ _wrap_Init_bspline(void)
 	rb_define_method(cBspline, "sekibun", VALUEFUNC(_wrap_bspline_sekibun), 1);
 	rb_define_method(cBspline, "plot", VALUEFUNC(_wrap_bspline_plot), -1);
 	rb_define_method(cBspline, "line_integral", VALUEFUNC(_wrap_bspline_lint), -1);
+	rb_define_method(cBspline, "*", VALUEFUNC(_wrap_bspline_mul), 1);
 	rb_define_module_function(mPspline, "fft_complex_transform", VALUEFUNC(_wrap_complex_trans), 2);
 	rb_define_module_function(mPspline, "fft_complex_get", VALUEFUNC(_wrap_complex_get), 2);
 	rb_define_module_function(mPspline, "fft_complex_bspline", VALUEFUNC(_wrap_complex_bspline), 2);
@@ -725,33 +728,41 @@ _wrap_pspline_bracket(int argc, VALUE *argv, VALUE self)
 	Get_pspline(self, bsp);
 	int N = bsp->Grid();
 	int K = bsp->Unit_size();
-
-	vargs = make_list(argc, argv);
-	argc = RARRAY_LEN(vargs);
-	int M = argc / N;
+	mresult = rb_ary_new();
 try {
-	if (argc % N == 0) {
-		mresult = rb_ary_new();
-		for (int m = 0; m < M; ++m) {
+	for (int m = 0; m < argc; ++m) {
+		vargs = argv[m];
+		poly_array<double> val;
+		if (TYPE(vargs) == T_ARRAY) {
+			int L = RARRAY_LEN(vargs);
+			if (L != N)
+				rb_raise(rb_eArgError, "Array length = %d, it should be %d.", L, N);
 			double args[N+1];
 			for (int i = 0; i < N; ++i)
-				args[i] = NUM2DBL(RARRAY_PTR(vargs)[N*m+i]);
+				args[i] = NUM2DBL(RARRAY_PTR(vargs)[i]);
 			poly<double> arg(args, N);
-			poly_array<double> val = (*bsp)[arg];
-			if (K == 1) 
-				vresult = rb_float_new(val[0]);
-			else {
-				vresult = rb_ary_new();
-				for (int j = 0; j < K; ++j)
-					rb_ary_push(vresult, rb_float_new(val[j]));
-			}
-			rb_ary_push(mresult, vresult);
+			val = (*bsp)[arg];
+		} else
+			val = (*bsp)[NUM2DBL(vargs)];
+		if (K == 1) 
+			vresult = rb_float_new(val[0]);
+		else {
+			vresult = rb_ary_new();
+			for (int j = 0; j < K; ++j)
+				rb_ary_push(vresult, rb_float_new(val[j]));
 		}
-	} else rb_raise(rb_eArgError, "wrong argument []");
+		rb_ary_push(mresult, vresult);
+	}
 } catch (const char *c) {
 	rb_raise(rb_eRuntimeError, "%s", c);
 }
-	return M == 1 ? rb_ary_shift(mresult) : mresult;
+	return argc == 1 ? rb_ary_shift(mresult) : mresult;
+}
+
+void ps_eArgError(VALUE err)
+{
+	VALUE str = rb_String(err);
+	rb_raise(rb_eArgError, "wrong argument %s", StringValuePtr(str));
 }
 /*******************************************************************************
 	関数値
@@ -766,7 +777,7 @@ _wrap_pspline_value(int argc, VALUE *argv, VALUE self)
 	VALUE varg1, varg2, varg3;
 	pspline<double> *arg0;
 	int argn, arg2 = 0, *carg2 = NULL;
-	double *carg3 = NULL;
+	double arg1, *args, *carg3 = NULL;
 	VALUE vargs, vresult = Qnil;
 
 	rb_scan_args(argc, argv, "12", &varg1, &varg2, &varg3);
@@ -779,51 +790,67 @@ _wrap_pspline_value(int argc, VALUE *argv, VALUE self)
 		arg2 = NUM2INT(varg2);
 		carg3 = new double[N];
 		Check_Type(varg3, T_ARRAY);
+		if (RARRAY_LEN(varg3) != N) ps_eArgError(varg3);
 		for (int i = 0; i < N; ++i)
 			carg3[i] = NUM2DBL(RARRAY_PTR(varg3)[i]);
 	}
 	// 偏微分
 	if (argc == 2) {
-		carg2 = new int[N];
-		Check_Type(varg2, T_ARRAY);
-		for (int i = 0; i < N; ++i)
-			carg2[i] = NUM2INT(RARRAY_PTR(varg2)[i]);
+		if (TYPE(varg2) == T_ARRAY && RARRAY_LEN(varg2) == N) {
+			carg2 = new int[N];
+			for (int i = 0; i < N; ++i)
+				carg2[i] = NUM2INT(RARRAY_PTR(varg2)[i]);
+		} else if (TYPE(varg1) != T_ARRAY) {
+			arg2 = NUM2INT(varg2);
+			argc = 0;
+		} else ps_eArgError(varg2);
 	}
 	// Argument list
-	Check_Type(varg1, T_ARRAY);
-	argn = RARRAY_LEN(varg1);
-	vargs = make_list(argn, RARRAY_PTR(varg1));
-	argn = RARRAY_LEN(vargs);
-	if (argn == N) {
-		double args[N+1];
-		for (int i = 0; i < N; ++i)
-			args[i] = NUM2DBL(RARRAY_PTR(vargs)[i]);
-		poly_array<double> val;
+	poly<double> arg;
+	args = NULL;
+	if (TYPE(varg1) == T_ARRAY) {
+		argn = RARRAY_LEN(varg1);
+		vargs = make_list(argn, RARRAY_PTR(varg1));
+		argn = RARRAY_LEN(vargs);
+		if (argn == N) {
+			args = new double[N+1];
+			for (int i = 0; i < N; ++i)
+				args[i] = NUM2DBL(RARRAY_PTR(vargs)[i]);
+		} else ps_eArgError(varg1);
+	} else
+		if (argc <= 1) arg1 = NUM2DBL(varg1);
+		else ps_eArgError(varg1);
+	if (argc < 2) argc ^= 1;
+	if (args) arg = poly<double>(args, N);
+	poly_array<double> val;
 try {
-		poly<double> arg(args, N);
-		switch (argc) {
-			case 1: 	// 関数値
-				val = (*arg0)(arg);
-				break;
-			case 2: 	// 偏微分 (partial derivative)
-				val = (*arg0)(arg, carg2);
-				delete[] carg2;
-				break;
-			case 3: 	// 全微分 (total derivative)
-				val = (*arg0)(arg, arg2, carg3);
-				delete[] carg3;
-		}
+	switch (argc) {
+		case 0: 	// 関数値
+			val = args ? (*arg0)(arg) : (*arg0)(arg1);
+			delete[] args;
+			break;
+		case 1: 	// 関数積の微分
+			val = (*arg0)(arg1, arg2);
+			delete[] args;
+			break;
+		case 2: 	// 偏微分 (partial derivative)
+			val = (*arg0)(arg, carg2);
+			delete[] carg2;
+			break;
+		case 3: 	// 全微分 (total derivative)
+			val = (*arg0)(arg, arg2, carg3);
+			delete[] carg3;
+	}
 } catch (const char *c) {
 	rb_raise(rb_eRuntimeError, "%s", c);
 }
-		if (K == 1) 
-			vresult = rb_float_new(val[0]);
-		else {
-			vresult = rb_ary_new();
-			for (int j = 0; j < K; ++j)
-				rb_ary_push(vresult, rb_float_new(val[j]));
-		}
-	} else rb_raise(rb_eArgError, "wrong argument value");
+	if (K == 1) 
+		vresult = rb_float_new(val[0]);
+	else {
+		vresult = rb_ary_new();
+		for (int j = 0; j < K; ++j)
+			rb_ary_push(vresult, rb_float_new(val[j]));
+	}
 	return vresult;
 }
 
@@ -840,10 +867,13 @@ _wrap_pspline_sekibun(int argc, VALUE *argv, VALUE self)
 	vargs = make_list(argc, argv);
 	argc = RARRAY_LEN(vargs);
 try {
-	if (argc == N) {
+	if (argc == N || argc == 1) {
 		double s[N+1];
 		for (int i = 0; i < N; ++i)
-			s[i] = NUM2DBL(RARRAY_PTR(vargs)[i]);
+			if (i == 0 || argc == N)
+				s[i] = NUM2DBL(RARRAY_PTR(vargs)[i]);
+			else
+				s[i] = s[i-1];
 		poly<double> args(s, N);
 		poly_array<double> val = bsp->sekibun(args);
 		if (K == 1) 
@@ -875,13 +905,15 @@ _wrap_pspline_plot(int argc, VALUE *argv, VALUE self)
 	double *arg1[N], *arg2[K];
 	arg3 = NUM2INT(vdp);
 	if (argc > 2) {
-		Check_Type(vjbn, T_ARRAY);
-		int n = RARRAY_LEN(vjbn);
-		if (n != N)
-			rb_raise(rb_eArgError, "Differential orders = %d, it should be %d", n, N);
 		arg4 = new int[N];
-		for (int i = 0; i < N; ++i)
-			arg4[i] = NUM2INT(RARRAY_PTR(vjbn)[i]);
+		if (TYPE(vjbn) == T_ARRAY) {
+			int n = RARRAY_LEN(vjbn);
+			if (n != N)
+				rb_raise(rb_eArgError, "Differential orders = %d, it should be %d", n, N);
+			for (int i = 0; i < N; ++i)
+				arg4[i] = NUM2INT(RARRAY_PTR(vjbn)[i]);
+		} else
+			arg4[0] = NUM2INT(vjbn);
 	}
 	Check_Type(varg, T_ARRAY);
 	N = RARRAY_LEN(varg);
@@ -889,10 +921,16 @@ _wrap_pspline_plot(int argc, VALUE *argv, VALUE self)
 	int result;
 	for (int i = 0; i < N; ++i) rb_ary_push(vstu, rb_ary_shift(varg));
 try {
-	comb_array<double> stu = make_var(N, vstu);
-//		printf("dp = %d, jbn = %d\n", arg3, arg4);
-//		stu.print("\n");
-	result = plot<double>(*arg0, stu, arg1, arg2, arg3, arg4);
+	if (TYPE(RARRAY_PTR(vstu)[0]) == T_ARRAY) {
+		comb_array<double> stu = make_var(N, vstu);
+		result = plot<double>(*arg0, stu, arg1, arg2, arg3, arg4);
+	} else {
+		double *x = new double[N];
+		for (int i = 0; i < N; i++) x[i] = NUM2DBL(RARRAY_PTR(vstu)[i]);
+		result = plot<double>(*arg0, N, x, arg1, arg2, arg3, arg4[0]);
+		delete[] x;
+		N = 1;
+	}
 } catch (const char *c) {
 	rb_raise(rb_eRuntimeError, "%s", c);
 }
@@ -913,6 +951,61 @@ try {
 	return INT2NUM(result);
 }
 
+static VALUE
+_wrap_bspline_mul(VALUE self, VALUE varg)
+{
+	bspline<double> *arg0;
+	Get_bspline(self, arg0);
+	pspline<double> *result;
+	if (rb_obj_is_kind_of(varg, cBspline)) {
+		bspline<double> *arg1;
+	    Data_Get_Struct(varg, bspline<double>, arg1);
+	    if (!arg1) rb_raise(rb_eArgError, "Not Bspline object");
+		result = new pspline<double>((*arg0) * (*arg1));
+	} else if (rb_obj_is_kind_of(varg, cPspline)) {
+		pspline<double> *arg1;
+	    Data_Get_Struct(varg, pspline<double>, arg1);
+	    if (!arg1) rb_raise(rb_eArgError, "Not Pspline Object");
+		result = new pspline<double>((*arg0) * (*arg1));
+	} else {
+		double a = NUM2DBL(varg);
+		bspline<double> *result = new bspline<double>(*arg0);
+		double *p = *result;
+		int k = result->Unit_size();
+		int c = ((base_spline<double>*)result)->Icox();
+		for (int i = 0; i < c * k; i++) p[i] *= a;
+		return Wrap_bspline(cBspline, result);
+	}
+	return Wrap_pspline(cPspline, result);
+}
+
+static VALUE
+_wrap_pspline_mul(VALUE self, VALUE varg)
+{
+	pspline<double> *arg0;
+	Get_pspline(self, arg0);
+	pspline<double> *result;
+	if (rb_obj_is_kind_of(varg, cBspline)) {
+		bspline<double> *arg1;
+	    Data_Get_Struct(varg, bspline<double>, arg1);
+	    if (!arg1) rb_raise(rb_eArgError, "Not Bspline object");
+		result = new pspline<double>((*arg0) * (*arg1));
+	}/* else if (rb_obj_is_kind_of(varg, cPspline)) {
+		pspline<double> *arg1;
+	    Data_Get_Struct(varg, pspline<double>, arg1);
+	    if (!arg1) rb_raise(rb_eArgError, "Not Pspline object");
+		result = new pspline<double>((*arg0) * (*arg1));
+	}*/ else {
+		double a = NUM2DBL(varg);
+		result = new pspline<double>(*arg0);
+		double *p = *result;
+		const Int& c = result->values->icox;
+		int s = c.grid_size();
+		for (int i = 0; i < s; i++) p[i] *= a;
+	}
+	return Wrap_pspline(cPspline, result);
+}
+
 static void
 _wrap_Init_pspline(void)
 {
@@ -924,6 +1017,7 @@ _wrap_Init_pspline(void)
 	rb_define_method(cPspline, "value", VALUEFUNC(_wrap_pspline_value), -1);
 	rb_define_method(cPspline, "sekibun", VALUEFUNC(_wrap_pspline_sekibun), -1);
 	rb_define_method(cPspline, "plot", VALUEFUNC(_wrap_pspline_plot), -1);
+	rb_define_method(cPspline, "*", VALUEFUNC(_wrap_pspline_mul), 1);
 }
 
 #ifdef __cplusplus

data/lib/pspline.rb

@@ -1,63 +1,71 @@
-require "pspline/version"
-require "pspline.so"
-
-module PSPLINE
-
-class Rfft
-
-	def initialize(data)
-		@R = fft_real_transform(data, 1)
-	end
-	def [] (t)
-		fft_real_get(@R, t)
-	end
-	def spline(j)
-		@V = []
-		fft_real_bspline(@R, j) {|t, z| @V.push t}
-	end
-	def axis
-		@V.dup
-	end
-	def inverse
-		fft_real_transform(@R, -1)
-	end
-	def backword
-		fft_real_transform(@R, 0)
-	end
-	def real
-		@R.dup
-	end
-
-end
-
-class Cfft
-
-	def initialize(data)
-		@F = fft_complex_transform(data, 1)
-	end
-	def [] (t)
-		fft_complex_get(@F, t)
-	end
-	def spline(j)
-		@V = []
-		fft_complex_bspline(@F, j) {|t, z| @V.push t}
-	end
-	def inverse
-		fft_complex_transform(@F, -1)
-	end
-	def backword
-		fft_real_transform(@F, 0)
-	end
-	def axis
-		@V.dup
-	end
-	def real
-		@F[0].dup
-	end
-	def imag
-		@F[1].dup
-	end
-
-end
-
-end
+require "pspline/version"
+require "pspline.so"
+
+module PSPLINE
+
+class Rfft < Array
+
+	def initialize(data)
+		super(fft_real_transform(data, 1))
+	end
+	def [] (t)
+		fft_real_get(self, t)
+	end
+	def spline order:
+		@V = []
+		fft_real_bspline(self, order) {|t, z| @V.push t}
+	end
+	def axis
+		@V.dup
+	end
+	def inverse
+		fft_real_transform(self, -1)
+	end
+	def backword
+		fft_real_transform(self, 0)
+	end
+
+end
+
+class Cfft < Array
+
+	def initialize(data)
+		super(fft_complex_transform(data, 1))
+	end
+	def [] (t)
+		fft_complex_get(self, t)
+	end
+	def spline order:
+		@V = []
+		fft_complex_bspline(self, order) {|t, z| @V.push t}
+	end
+	def inverse
+		fft_complex_transform(self, -1)
+	end
+	def backword
+		fft_real_transform(self, 0)
+	end
+	def axis
+		@V.dup
+	end
+	def real
+		self.first.dup
+	end
+	def image
+		self.last.dup
+	end
+
+end
+
+end
+
+class Array
+
+	def fft_complex_forward
+		PSPLINE::Cfft.new(self)
+	end
+	def fft_real_forward
+		PSPLINE::Rfft.new(self)
+	end
+
+end