#ifndef CFUNC_H
#define CFUNC_H

#include <math.h>

#include "matrix.h"
#include "cmatrix.h"
#include "func.h"

class calgo	// 復數(shù)算法類,專門生成自變量為實數(shù)，運算結果為復數(shù)的算法
{
 private:
	COMPLEX yfactor;		// 乘因子，初始化為1
	DOUBLE xfactor;		// x軸放大因子，初始化為1
	COMPLEX addconst;	// 加和，初始化為0
	DOUBLE xshift;		// x平移量，初始化為0
 public:
	unsigned refnum;		// 引用數(shù),初始化為1
	calgo():refnum(1),yfactor(1.0),xfactor(1.0),addconst(0.0),xshift(0.0){};
	 // 構造函數(shù),產(chǎn)生y=x線性函數(shù)
	calgo(DOUBLE xs, DOUBLE xf,COMPLEX adc=0.0, COMPLEX yf=1.0):refnum(1),
		yfactor(yf),addconst(adc),xshift(xs),xfactor(xf){};
	calgo(COMPLEX a):refnum(1),yfactor(0.0),xfactor(1.0),addconst(a),xshift(0.0)
		{};	 // 常函數(shù)的構造
	calgo(calgo & alg):yfactor(alg.yfactor),xfactor(alg.xfactor),
		addconst(alg.addconst),xshift(alg.xshift),refnum(1){}; // 拷貝構造函數(shù)
	virtual ~calgo(){}; // 虛析構函數(shù)
	COMPLEX cal(DOUBLE x); // 計算算法值
	virtual COMPLEX calculate(DOUBLE x)
		{return x;}; // 本身算法,將被繼承子類改寫
	virtual calgo * clone(); // 克隆自己，必須被繼承子類改寫
	calgo * mul(COMPLEX a);	// 乘a
	calgo * add(COMPLEX a);	// 加a
	calgo * neg(); // 取負
	calgo * setxfactor(DOUBLE x);		// 設置x軸因子
	calgo * xroom(DOUBLE x);	// 將xfactor擴大x倍
	calgo * setxshift(DOUBLE x); // 設置xshift的值
	calgo * xshiftas(DOUBLE x);	// 從當前開始平移x
};

class calgojoin : public calgo // 結合算法
{
 public:
	calgo * leftalgo;	// 左算法，初始化為0
	calgo * rightalgo; // 右算法，初始化為0
	method met;	// 指明算法
	calgojoin(calgo * l, calgo * r, method m):leftalgo(l),
		rightalgo(r), met(m)
		{ if(leftalgo)
				leftalgo->refnum++;
		  if(rightalgo)
				rightalgo->refnum++;
		};
	calgojoin(calgojoin& alg):calgo(alg),
		leftalgo(alg.leftalgo),rightalgo(alg.rightalgo),met(alg.met){
			if(leftalgo)
				leftalgo->refnum++;
			if(rightalgo)
				rightalgo->refnum++;};
			// 拷貝構造函數(shù)
	virtual ~calgojoin() {
		if(leftalgo) {	// 如左或者右算法已經(jīng)沒有被引用，則刪除
			leftalgo->refnum--;
			if(!leftalgo->refnum) delete leftalgo;
		}
		if(rightalgo) {
			rightalgo->refnum--;
			if(!rightalgo->refnum) delete rightalgo;
		}
	};
	virtual calgo * clone(); // 克隆自己
	virtual COMPLEX calculate(DOUBLE x);	// 實施結合算法
};

class calgofun : public calgo	// 函數(shù)算法
{
 public:
	COMPLEX (*f)(DOUBLE);	// 函數(shù)指針
	calgofun(COMPLEX (*fun)(DOUBLE)):f(fun){};	// 用函數(shù)指針進行初始化
	calgofun(calgofun& alg):calgo(alg),f(alg.f){}; // 拷貝構造函數(shù)
	virtual COMPLEX calculate(DOUBLE x);	// 實施函數(shù)算法
	virtual calgo * clone(); // 克隆自己
};

class calgopoly : public calgo	// 復多項式
{
 public:
	cmatrix data;	//	n乘1矩陣，存放n-1次多項式的系數(shù)a(0)到a(n-1)
	calgopoly(cmatrix& d):data(d){};	// 用矩陣構造多項式
	calgopoly(calgopoly& alg):calgo(alg),data(alg.data){}; // 拷貝構造函數(shù)
	virtual COMPLEX calculate(DOUBLE x);	// 實施函數(shù)算法
	virtual calgo * clone();	// 克隆自己
};

class calgoenter : public calgo	// 等間隔插值算法
{
 public:
	algoenter * er;
	algoenter * ei;	// 兩個插值算法構成結果的實部與虛部
	calgoenter(matrix& ver, matrix& vei, DOUBLE x0, DOUBLE h):
		er(new algoenter(ver,x0,h)), ei(new algoenter(vei,x0,h)) {};
	calgoenter(calgoenter& alg):calgo(alg),er(alg.er),ei(alg.ei) {
		er->refnum++; ei->refnum++;} // 拷貝構造函數(shù)
	virtual ~calgoenter(){
		er->refnum--;
		if(!er->refnum) delete er;
		ei->refnum--;
		if(!ei->refnum) delete ei;};
	virtual COMPLEX calculate(DOUBLE x);	// 實施函數(shù)算法
	virtual calgo * clone();	// 克隆自己
};

class cfunc {	// 復函數(shù)類,計算自變量為實數(shù)而結果是復數(shù)的類
 public:
	calgo * alg;	// 決定函數(shù)的算法

	cfunc();	// 缺省構造函數(shù)
	cfunc(COMPLEX a);	// 常函數(shù)的構造函數(shù)
	cfunc(COMPLEX (*fun)(DOUBLE));	// 函數(shù)指針的構造函數(shù)
	cfunc(cfunc & fn);	// 拷貝構造函數(shù)
	cfunc(calgo * a):alg(a){} // 算法構造函數(shù)，使用要小心，不能將一個算法產(chǎn)生
									// 兩個函數(shù)，除非自己控制引用數(shù)的增加
	cfunc(cmatrix& m);	// 構造多項式，m為nX1矩陣，是n-1階多項式系數(shù)，
				// 其中m(0,0)為常數(shù)項，m(n-1,0)為n-1次項。

	virtual ~cfunc() {		// 析構函數(shù)
		if(alg) {
			alg->refnum--;	// 引用數(shù)減一，如再無其它引用，則刪除算法
			if(!alg->refnum)
				delete alg;
		}
	};

	COMPLEX operator()(DOUBLE x){return alg->cal(x);}; // 計算x的函數(shù)值
	cfunc& operator=(cfunc& fn);	// 賦值運算符
	cfunc& operator=(COMPLEX (*fn)(DOUBLE)); // 用函數(shù)指針的賦值運算符
	cfunc& operator=(COMPLEX a); // 常函數(shù)的賦值運算符

	cfunc& operator+=(cfunc& fn);	// 自身加一個函數(shù)
	cfunc& operator+=(COMPLEX a){alg=alg->add(a);return (*this);};
			//自身加一個常數(shù)
	cfunc& operator+=(COMPLEX (*f)(DOUBLE)); // 自身加一個函數(shù)指針
	cfunc operator+(cfunc& fn);	// 相加產(chǎn)生新函數(shù)
	cfunc operator+(COMPLEX a);	// 與常數(shù)相加產(chǎn)生新函數(shù)
	friend cfunc operator+(COMPLEX a, cfunc& f); // 同上但常數(shù)在前
	cfunc operator+(COMPLEX (*f)(DOUBLE)); // 加一個函數(shù)指針產(chǎn)生新函數(shù)
	friend cfunc operator+(COMPLEX (*f)(DOUBLE),cfunc& fn);
		// 同上但函數(shù)指針在前

	cfunc& neg(); // 自身取負
	cfunc operator-(); // 產(chǎn)生負函數(shù)

	cfunc& operator-=(cfunc& fn); // 自身減一個函數(shù)
	cfunc& operator-=(COMPLEX a){alg=alg->add(-a);return (*this);};
			//自身減一個常數(shù)
	cfunc& operator-=(COMPLEX (*f)(DOUBLE)); // 自身減一個函數(shù)指針
	cfunc operator-(cfunc& fn);	// 相減產(chǎn)生新函數(shù)
	cfunc operator-(COMPLEX a);	// 與常數(shù)相減產(chǎn)生新函數(shù)
	friend cfunc operator-(COMPLEX a, cfunc& f); // 同上但常數(shù)在前
	cfunc operator-(COMPLEX (*f)(DOUBLE)); // 減一個函數(shù)指針產(chǎn)生新函數(shù)
	friend cfunc operator-(COMPLEX (*f)(DOUBLE),cfunc& fn); // 函數(shù)指針減函數(shù)

	cfunc& operator*=(cfunc& fn);	// 自身乘一個函數(shù)
	cfunc& operator*=(COMPLEX a){alg=alg->mul(a);return (*this);};
		//自身乘一個常數(shù)
	cfunc& operator*=(COMPLEX (*f)(DOUBLE)); // 自身乘一個函數(shù)指針
	cfunc operator*(cfunc& fn);	// 相乘產(chǎn)生新函數(shù)
	cfunc operator*(COMPLEX a);	// 與常數(shù)相乘產(chǎn)生新函數(shù)
	friend cfunc operator*(COMPLEX a, cfunc& f); // 同上但常數(shù)在前
	cfunc operator*(COMPLEX (*f)(DOUBLE)); // 乘一個函數(shù)指針產(chǎn)生新函數(shù)
	friend cfunc operator*(COMPLEX (*f)(DOUBLE),cfunc& fn); // 函數(shù)指針乘函數(shù)

	cfunc& operator/=(cfunc& fn);	// 自身除以一個函數(shù)
	cfunc& operator/=(COMPLEX a){alg=alg->mul(1.0/a);return (*this);
			};//自身除以常數(shù)
	cfunc& operator/=(COMPLEX (*f)(DOUBLE)); // 自身除以一個函數(shù)指針
	cfunc operator/(cfunc& fn);	// 相除產(chǎn)生新函數(shù)
	cfunc operator/(COMPLEX a);	// 與常數(shù)相除產(chǎn)生新函數(shù)
	friend cfunc operator/(COMPLEX a, cfunc& f); // 常數(shù)除以函數(shù)
	cfunc operator/(COMPLEX (*f)(DOUBLE)); // 除以一個函數(shù)指針產(chǎn)生新函數(shù)
	friend cfunc operator/(COMPLEX (*f)(DOUBLE),cfunc& fn); // 函數(shù)指針除以函數(shù)

	void setxfactor(DOUBLE a);	// 設置x因子為a
	void xroom(DOUBLE a);	  // x方向擴大a倍
	void setxshift(DOUBLE a);	// 設置函數(shù)沿x軸平移a
	void shiftxas(DOUBLE a); // 函數(shù)沿x軸右移a

	cfunc& power(cfunc& f);	// 函數(shù)的f次乘冪，函數(shù)自身改變
	cfunc& power(COMPLEX a);	// 函數(shù)的a次冪，函數(shù)自身改變
	cfunc operator^(cfunc & fn);	// 函數(shù)的fn次乘冪，產(chǎn)生新函數(shù)，原函數(shù)不變
	cfunc operator^(COMPLEX a);  // 函數(shù)的a次冪，產(chǎn)生新函數(shù)，原函數(shù)不變
};

inline cfunc operator+(COMPLEX a, cfunc& f) // 常數(shù)加函數(shù)
{	return f+a; }

inline cfunc operator+(COMPLEX (*f)(DOUBLE),cfunc& fn) // 函數(shù)指針加函數(shù)
{	return fn+f;}

cfunc operator-(COMPLEX a, cfunc& f); // 常數(shù)減函數(shù)
cfunc operator-(COMPLEX (*f)(DOUBLE),cfunc& fn); // 函數(shù)指針減函數(shù)

inline cfunc operator*(COMPLEX a, cfunc& f) // 常數(shù)乘函數(shù)
{	return f*a; }
inline cfunc operator*(COMPLEX (*f)(DOUBLE),cfunc& fn) // 函數(shù)指針乘函數(shù)
{	return fn*f;}

cfunc operator/(COMPLEX a, cfunc& f); // 常數(shù)除以函數(shù)
cfunc operator/(COMPLEX (*f)(DOUBLE),cfunc& fn); // 函數(shù)指針除以函數(shù)

class cfuncenter: public cfunc {	// 插值復函數(shù)
 public:
	cfuncenter(cmatrix& s,DOUBLE t0, DOUBLE dt);
};

cfunc fourier(func& f,DOUBLE tb, DOUBLE te, DOUBLE dt, DOUBLE df);
	// 利用fft技術對函數(shù)f作傅里葉變換，其中tb為采樣窗口的起始點，te為結束點，
	// 必須te>tb，dt為采樣間隔，df為頻率采樣間隔，但返回的cfunc是作了插值的
	// 插值函數(shù)

#endif // CFUNC_H