git-svn-id: svn://db.shs.com.ru/pip@342 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5

main.cpp

@@ -41,19 +41,13 @@ int asize(ssize_t s, size_t pid_rsize) {
 	return (1 << t);
 }
 int main(int argc, char *argv[]) {
-	PIDeque<double> in;
+	PIVector<float> in;
-	for (int i = 0; i < 5; ++i)
-		in << i%10;
-	/*PIFFTWd fft;
-	fft.preparePlan(50, PIFFTWd::foReal);
-	PIVector<complexd> out = fft.calcFFT(in);*/
-	piCout << in.data();
-	in.align();
-	piCout << in.data();
-	in = PIDeque<double>();
 	for (int i = 0; i < 50; ++i)
 		in << i%10;
-	piCout << in.data();
+	PIFFTWf fft;
+	fft.preparePlan(50, PIFFTWf::foReal);
+	PIVector<complexf> out = fft.calcFFT(in);
+	piCout << out;
 	/*for (int i = 0; i < 16; ++i) {
 		piCout << asize(i, 100);
 	}

src/math/pifft_p.h

@@ -42,6 +42,8 @@ class PIFFTW_Private
 public:
 	explicit PIFFTW_Private() {
 		plan = 0;
+		p_in = p_out = 0;
+		p_inr = 0;
 #ifdef PIP_FFTW
 //		fftwf_m
 #else
@@ -49,74 +51,94 @@ public:
 #endif
 		p_makeThreadSafe();
 	}
-	~PIFFTW_Private() {p_destroyPlan(plan);}
+	~PIFFTW_Private() {
+		p_destroyPlan(plan);
+		delVec(p_in);
+		delVec(p_out);
+		delVec(p_inr);
+	}
 
 	const PIVector<complex<T> > & calcFFT(const PIVector<complex<T> > & in) {
 		if (prepare != PlanParams(in.size(), fo_complex)) {
-			p_out.resize(in.size());
+			newVec(p_in, in.size());
+			newVec(p_out, in.size());
 			piCout << "[PIFFTW]" << "creating plan";
-			p_createPlan_c2c_1d(plan, in.size(), in.data(), p_out.data(), FFTW_FORWARD, FFTW_ESTIMATE | FFTW_UNALIGNED);
+			p_createPlan_c2c_1d(plan, in.size(), p_in, p_out, FFTW_FORWARD, FFTW_ESTIMATE);
+			v_out.resize(in.size());
 			prepare = PlanParams(in.size(), fo_complex);
 		}
-		p_executePlan_c2c(plan, in.data(), p_out.data());
+		memcpy(p_in, in.data(), sizeof(complex<T>) * in.size());
-		return p_out;
+		p_executePlan(plan);
+		memcpy(v_out.data(), p_out, sizeof(complex<T>) * v_out.size());
+		return v_out;
 	}
 	const PIVector<complex<T> > & calcFFT(const PIVector<T> & in) {
 		if (prepare != PlanParams(in.size(), fo_real)) {
-			p_out.resize(in.size());
+			newVec(p_inr, in.size());
+			newVec(p_out, in.size());
 			piCout << "[PIFFTW]" << "creating plan";
-			p_createPlan_r2c_1d(plan, in.size(), in.data(), p_out.data(), FFTW_ESTIMATE | FFTW_UNALIGNED);
+			p_createPlan_r2c_1d(plan, in.size(), p_inr, p_out, FFTW_ESTIMATE);
+			v_out.resize(in.size());
 			prepare = PlanParams(in.size(), fo_real);
 		}
-		p_executePlan_r2c(plan, in.data(), p_out.data());
+		memcpy(p_inr, in.data(), sizeof(T) * in.size());
-		return p_out;
+		p_executePlan(plan);
+		memcpy(v_out.data(), p_out, sizeof(complex<T>) * v_out.size());
+		return v_out;
 	}
 	const PIVector<complex<T> > & calcFFTinverse(const PIVector<complex<T> > & in) {
-		if (prepare != PlanParams(in.size(), fo_inverse)) {
+		if (prepare != PlanParams(in.size(), fo_complex)) {
-			p_out.resize(in.size());
+			newVec(p_in, in.size());
+			newVec(p_out, in.size());
 			piCout << "[PIFFTW]" << "creating plan";
-			p_createPlan_c2c_1d(plan, in.size(), in.data(), p_out.data(), FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_UNALIGNED);
+			p_createPlan_c2c_1d(plan, in.size(), p_in, p_out, FFTW_BACKWARD, FFTW_ESTIMATE);
-			prepare = PlanParams(in.size(), fo_inverse);
+			v_out.resize(in.size());
+			prepare = PlanParams(in.size(), fo_complex);
 		}
-		p_executePlan_c2c(plan, in.data(), p_out.data());
+		memcpy(p_in, in.data(), sizeof(complex<T>) * in.size());
-		return p_out;
+		p_executePlan(plan);
+		memcpy(v_out.data(), p_out, sizeof(complex<T>) * v_out.size());
+		return v_out;
 	}
 
 	enum FFT_Operation {fo_real, fo_complex, fo_inverse};
 
 	void preparePlan(int size, int op) {
-		p_inr.clear();
-		p_in.clear();
-		p_out.clear();
 		switch ((FFT_Operation)op) {
 			case fo_real:
-				p_inr.resize(size);
+				newVec(p_inr, size);
-				p_out.resize(size);
+				newVec(p_out, size);
-				p_createPlan_r2c_1d(plan, size, p_inr.data(), p_out.data(), FFTW_MEASURE | FFTW_UNALIGNED);
+				p_createPlan_r2c_1d(plan, size, p_inr, p_out, FFTW_MEASURE);
 			break;
 			case fo_complex:
-				p_in.resize(size);
+				newVec(p_in, size);
-				p_out.resize(size);
+				newVec(p_out, size);
-				p_createPlan_c2c_1d(plan, size, p_in.data(), p_out.data(), FFTW_FORWARD, FFTW_MEASURE | FFTW_UNALIGNED);
+				p_createPlan_c2c_1d(plan, size, p_in, p_out, FFTW_FORWARD, FFTW_MEASURE);
 			break;
 			case fo_inverse:
-				p_in.resize(size);
+				newVec(p_in, size);
-				p_out.resize(size);
+				newVec(p_out, size);
-				p_createPlan_c2c_1d(plan, size, p_in.data(), p_out.data(), FFTW_BACKWARD, FFTW_MEASURE | FFTW_UNALIGNED);
+				p_createPlan_c2c_1d(plan, size, p_in, p_out, FFTW_BACKWARD, FFTW_MEASURE);
 			break;
 			default:
 				size = 0;
 			break;
 		}
+		v_out.resize(size);
 		prepare = PlanParams(size, (FFT_Operation)op);
 	}
 
 	inline void p_createPlan_c2c_1d(void *& plan, int size, const void * in, void * out, int dir, int flags) {}
 	inline void p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) {}
+	inline void p_executePlan(void * plan) {}
 	inline void p_executePlan_c2c(void * plan, const void * in, void * out) {}
 	inline void p_executePlan_r2c(void * plan, const void * in, void * out) {}
 	inline void p_destroyPlan(void *& plan) {}
 	inline void p_makeThreadSafe() {}
+	template <typename VT>
+	inline void newVec(VT *& v, int size) {delVec(v); v = (VT*)amalloc(sizeof(VT) * size);}
+	template <typename VT>
+	inline void delVec(VT *& v) {if (v) afree(v); v = 0;}
 
 	struct PlanParams {
 		PlanParams() {size = 0; op = fo_complex;}
@@ -128,9 +150,9 @@ public:
 		FFT_Operation op;
 	};
 
-	PIVector<complex<T> > p_in;
+	complex<T> * p_in, * p_out;
-	PIVector<T> p_inr;
+	T * p_inr;
-	PIVector<complex<T> > p_out;
+	PIVector<complex<T> > v_out;
 	void * plan;
 	PlanParams prepare;
 };
@@ -141,6 +163,7 @@ template<> inline void PIFFTW_Private<float>::p_createPlan_c2c_1d(void *& plan,
 	plan = fftwf_plan_dft_1d(size, (fftwf_complex *)in, (fftwf_complex *)out, dir, flags);}
 template<> inline void PIFFTW_Private<float>::p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) {
 	plan = fftwf_plan_dft_r2c_1d(size, (float *)in, (fftwf_complex *)out, flags);}
+template<> inline void PIFFTW_Private<float>::p_executePlan(void * plan) {fftwf_execute((fftwf_plan)plan);}
 template<> inline void PIFFTW_Private<float>::p_executePlan_c2c(void * plan, const void * in, void * out) {fftwf_execute_dft((fftwf_plan)plan, (fftwf_complex *)in, (fftwf_complex *)out);}
 template<> inline void PIFFTW_Private<float>::p_executePlan_r2c(void * plan, const void * in, void * out) {fftwf_execute_dft_r2c((fftwf_plan)plan, (float *)in, (fftwf_complex *)out);}
 template<> inline void PIFFTW_Private<float>::p_destroyPlan(void *& plan) {if (plan) fftwf_destroy_plan((fftwf_plan)plan); plan = 0;}
@@ -150,6 +173,7 @@ template<> inline void PIFFTW_Private<double>::p_createPlan_c2c_1d(void *& plan,
 	plan = fftw_plan_dft_1d(size, (fftw_complex *)in, (fftw_complex *)out, dir, flags);}
 template<> inline void PIFFTW_Private<double>::p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) {
 	plan = fftw_plan_dft_r2c_1d(size, (double *)in, (fftw_complex *)out, flags);}
+template<> inline void PIFFTW_Private<double>::p_executePlan(void * plan) {fftw_execute((fftw_plan)plan);}
 template<> inline void PIFFTW_Private<double>::p_executePlan_c2c(void * plan, const void * in, void * out) {fftw_execute_dft((fftw_plan)plan, (fftw_complex *)in, (fftw_complex *)out);}
 template<> inline void PIFFTW_Private<double>::p_executePlan_r2c(void * plan, const void * in, void * out) {fftw_execute_dft_r2c((fftw_plan)plan, (double *)in, (fftw_complex *)out);}
 template<> inline void PIFFTW_Private<double>::p_destroyPlan(void *& plan) {if (plan) fftw_destroy_plan((fftw_plan)plan); plan = 0;}
@@ -160,6 +184,7 @@ template<> inline void PIFFTW_Private<ldouble>::p_createPlan_c2c_1d(void *& plan
 	plan = fftwl_plan_dft_1d(size, (fftwl_complex *)in, (fftwl_complex *)out, dir, flags);}
 template<> inline void PIFFTW_Private<ldouble>::p_createPlan_r2c_1d(void *& plan, int size, const void * in, void * out, int flags) {
 	plan = fftwl_plan_dft_r2c_1d(size, (ldouble *)in, (fftwl_complex *)out, flags);}
+template<> inline void PIFFTW_Private<ldouble>::p_executePlan(void * plan) {fftwl_execute((fftwl_plan)plan);}
 template<> inline void PIFFTW_Private<ldouble>::p_executePlan_c2c(void * plan, const void * in, void * out) {fftwl_execute_dft((fftwl_plan)plan, (fftwl_complex *)in, (fftwl_complex *)out);}
 template<> inline void PIFFTW_Private<ldouble>::p_executePlan_r2c(void * plan, const void * in, void * out) {fftwl_execute_dft_r2c((fftwl_plan)plan, (ldouble *)in, (fftwl_complex *)out);}
 template<> inline void PIFFTW_Private<ldouble>::p_destroyPlan(void *& plan) {if (plan) fftwl_destroy_plan((fftwl_plan)plan); plan = 0;}