?? func.h

?? C++常用算法,包含了大部分矩陣運算,簡單有效
?? H
字號:
#ifndef FUNC_H
#define FUNC_H

#include <math.h>

#include "matrix.h"

#ifndef DOUBLE
#define DOUBLE double
#endif

class cmatrix;

DOUBLE gamma(DOUBLE x); // 計算伽馬函數
DOUBLE gamma2(DOUBLE a, DOUBLE x); // 計算不完全伽馬函數
DOUBLE erf(DOUBLE x); // 計算誤差函數
DOUBLE beta(DOUBLE a,DOUBLE b,DOUBLE x); // 計算不完全貝塔函數
DOUBLE gass(DOUBLE a,DOUBLE d,DOUBLE x); // 給定均值a，標準差d的正態分布函數
DOUBLE student(DOUBLE t, size_t n);	// t-分布函數
DOUBLE chii(DOUBLE x,size_t n); // X-方分布函數
DOUBLE fdisp(DOUBLE f,size_t n1,size_t n2); // F-分布函數
DOUBLE integral(DOUBLE (*f)(DOUBLE),DOUBLE a, DOUBLE b, DOUBLE eps=defaulterr);
 // 函數f,在(a,b)區間積分,采用勒讓德高斯求積法
DOUBLE sinn(DOUBLE x);	// 正弦積分函數
DOUBLE coss(DOUBLE x);	// 余弦積分函數
DOUBLE expp(DOUBLE x);	// 指數積分函數
DOUBLE getroot(DOUBLE (*f)(DOUBLE), DOUBLE x0=0.9, DOUBLE eps=defaulterr);
 // 求函數f(x)=0在x0附近的根，返回此根，如找不到根，則丟出例外
class algo;
DOUBLE getroot(algo & alg, DOUBLE x0=0.9, DOUBLE eps=defaulterr);
 // 同上，但函數為algo類變量


class algo	// 算法類
{
 public:
	DOUBLE yfactor;		// 乘因子，初始化為1
	DOUBLE xfactor;		// x軸放大因子，初始化為1
	DOUBLE addconst;	// 加和，初始化為0
	DOUBLE xshift;		// x平移量，初始化為0
	unsigned refnum;		// 引用數,初始化為1
	algo():refnum(1),yfactor(1.0),xfactor(1.0),addconst(0.0),xshift(0.0){};
	 // 構造函數,產生y=x線性函數
	algo(DOUBLE xs, DOUBLE xf,DOUBLE adc=0, DOUBLE yf=1):refnum(1),yfactor(yf),
		addconst(adc),xshift(xs),xfactor(xf){};
	algo(DOUBLE a):refnum(1),yfactor(0.0),xfactor(1.0),addconst(a),xshift(0.0){};
	 // 常函數的構造
	algo(algo & alg):yfactor(alg.yfactor),xfactor(alg.xfactor),
		addconst(alg.addconst),xshift(alg.xshift),refnum(1){}; // 拷貝構造函數
	virtual ~algo(){}; // 虛析構函數
	DOUBLE cal(DOUBLE x); // 計算算法值
	virtual DOUBLE calculate(DOUBLE x)
		{return x;}; // 本身算法,將被繼承子類改寫
	virtual algo * clone(); // 克隆自己，必須被繼承子類改寫
	algo * mul(DOUBLE a);	// 乘a
	algo * add(DOUBLE a);	// 加a
	algo * neg(); // 取負
	algo * setxfactor(DOUBLE x);		// 設置x軸因子
	algo * xroom(DOUBLE x);	// 將xfactor擴大x倍
	algo * setxshift(DOUBLE x); // 設置xshift的值
	algo * xshiftas(DOUBLE x);	// 從當前開始平移x
	DOUBLE integ(DOUBLE a, DOUBLE b, DOUBLE eps = defaulterr); // 在(a,b)區間積分
			// 采用勒讓德高斯求積法
};

enum	method {cadd,csub,cmul,cdiv,cpow,ccom}; // 枚舉加減乘除乘方復合這四種運算

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

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

class algogass : public algo	// 正態分布函數
{
 public:
	algogass(DOUBLE a, DOUBLE d):algo(a,1.0/d){};	// 用均值a和標準差d進行初始化
	algogass(algogass& alg):algo(alg){}; // 拷貝構造函數
	virtual DOUBLE calculate(DOUBLE x);	// 實施函數算法
	virtual algo * clone(); // 克隆自己
};

class algoinverse : public algo	// 根據一個算法求反函數的算法
	// 通過不斷求f(x)-y=0在給定的各個y值下的根來進行
{
 public:
	algo * al;
	algoinverse(algo * a):al(a){if(al) al->refnum++;};	// a 是要求反函數的算法
	algoinverse(algoinverse& alg):algo(alg),al(alg.al){
   	al->refnum++;	}; // 拷貝構造函數
	~algoinverse() {
		if(al) {
			al->refnum--;
			if(!al->refnum)
				delete al;
		}
	};		// 析構函數
	virtual DOUBLE calculate(DOUBLE x);	// 實施函數算法
	virtual algo * clone(); // 克隆自己
};

class algoregress : public algo // 線性回歸算法產生線性函數
{
 public:
	algoregress(matrix & xy, matrix* dt=0); // xy為n行2列的矩陣為n個樣本點
		// dt必須指向一個6列一行的矩陣向量，六個數依次為偏差平方和，平均標準
		// 偏差，回歸平方和，最大偏差，最小偏差，偏差平均值
};

class algopoly : public algo	// 多項式
{
 public:
	matrix data;	//	n乘1矩陣，存放n-1次多項式的系數a(0)到a(n-1)
	algopoly(){}; // 缺省構造函數，給子類作調用
	algopoly(matrix& d):data(d){};	// 用矩陣構造多項式
	algopoly(algopoly& alg):algo(alg),data(alg.data){}; // 拷貝構造函數
	virtual DOUBLE calculate(DOUBLE x);	// 實施函數算法
	virtual algo * clone();	// 克隆自己
	cmatrix getroots();	// 求出此多項式的所有根
};

class algopair : public algopoly // 最小二乘擬合類
{
 public:
	algopair(matrix& xy, size_t m, DOUBLE & t0,DOUBLE &t1,DOUBLE &t2);
		// m為擬合多項式的項數，dt0為誤差平方和，dt1為誤差絕對值和，
		// dt2為最大誤差絕對值
	algopair(algopair& alg):algopoly(alg){}; // 拷貝構造函數
};

class algoenter2 : public algo	// 一元全區間不等距插值
{
 public:
	matrix data;	//	n乘2矩陣，n個坐標，先x后y,x必須從小到大
	algoenter2(matrix& d):data(d){};	// 用矩陣構造多項式
	algoenter2(algoenter2& alg):algo(alg),data(alg.data){}; // 拷貝構造函數
	virtual DOUBLE calculate(DOUBLE x);	// 實施函數算法
	virtual algo * clone();	// 克隆自己
};

class algoenter : public algo	// 一元全區間等距插值
{
 public:
	DOUBLE x0;		// 起始點
	DOUBLE h;		// 步長
	matrix data;	//	n乘1矩陣，n個函數值
	algoenter(matrix& d,DOUBLE xx0, DOUBLE hh):
		data(d),x0(xx0),h(hh){};
	algoenter(algoenter& alg):algo(alg),data(alg.data),
		x0(alg.x0),h(alg.h){}; // 拷貝構造函數
	virtual DOUBLE calculate(DOUBLE x);	// 實施函數算法
	virtual algo * clone();	// 克隆自己
};

enum funckind {polyfunc, enter2func, gammafunc}; // 函數種類

class func {	// 函數類
 public:
	algo * alg;	// 決定函數的算法

	func();	// 缺省構造函數
	func(DOUBLE a);	// 常函數的構造函數
	func(DOUBLE (*fun)(DOUBLE));	// 函數指針的構造函數
	func(func & fn);	// 拷貝構造函數
	func(algo * a); // 算法構造函數
   func(algo& a); // 算法構造函數
	func(DOUBLE a, DOUBLE d);	// 產生正態分布函數a為均值，d為標準差
	func(matrix& m, funckind kind=polyfunc);	// 構造數值相關函數，
				// 如kind = polyfunc, 則m為nX1矩陣，是n-1階多項式系數，
				// 其中m(0,0)為常數項，m(n-1,0)為n-1次項。
				// 如kind = enter2func, 則m為nX2矩陣，代表n個坐標點
				// 其中第1列是由小到大排過序的各點的x坐標
	func(matrix& m, DOUBLE x0, DOUBLE h); // 構造等距插值函數
			// 其中m是nX1階矩陣，代表n個y值，x0是起始點，h是步長（采樣間隔）
	virtual ~func() {		// 析構函數
		if(alg) {
			alg->refnum--;	// 引用數減一，如再無其它引用，則刪除算法
			if(!alg->refnum)
				delete alg;
		}
	};

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

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

	func& neg(); // 自身取負
	func operator-(); // 產生負函數

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

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

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

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

	func& power(func& f);	// 函數的f次乘冪，函數自身改變
	func& power(DOUBLE a);	// 函數的a次冪，函數自身改變
	func operator^(func & fn);	// 函數的fn次乘冪，產生新函數，原函數不變
	func operator^(DOUBLE a);  // 函數的a次冪，產生新函數，原函數不變

	func operator()(func & fn);	// 復合函數，產生新的函數

	DOUBLE integ(DOUBLE a, DOUBLE b, DOUBLE eps=defaulterr);
		// 從a到b計算函數的定積分
	DOUBLE singleroot(DOUBLE x=0.9, DOUBLE eps = defaulterr);
		// 計算函數f(x)=0的一個單根
	func inverse();	// 產生反函數

	void getab(DOUBLE& a,DOUBLE& b) {	// 主要被線性回歸子類用，返回線性因子
   												// 和加常數
		a = alg->yfactor;
		b = alg->addconst;
	};
};

inline func operator+(DOUBLE a, func& f) // 常數加函數
{	return f+a; }

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

func operator-(DOUBLE a, func& f); // 常數減函數
func operator-(DOUBLE (*f)(DOUBLE),func& fn); // 函數指針減函數

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

func operator/(DOUBLE a, func& f); // 常數除以函數
func operator/(DOUBLE (*f)(DOUBLE),func& fn); // 函數指針除以函數

class funcgass : public func // 正態分布函數
{
 public:
	funcgass(DOUBLE a=0.0, DOUBLE d=1.0):func(new algogass(a,d)){};
	void setmandd(DOUBLE a, DOUBLE d){
		alg->xshift = a;
		alg->xfactor = 1.0/d; }; // 設置均值和標準差
	void getmandd(DOUBLE &a, DOUBLE &d) {
		a = alg->xshift; d=1.0/alg->xfactor;}; // 獲得均值和標準差
};

class funcpoly : public func	// 多項式函數
{
 public:
	funcpoly(matrix& d):func(new algopoly(d)){};
	matrix& getdata(){return ((algopoly*)alg)->data;};
	cmatrix getroots(){return ((algopoly*)alg)->getroots();};
};

class funcenter2 : public func // 一元全區間不等距插值
{
 public:
	funcenter2(matrix& d):func(new algoenter2(d)){};
	matrix& getdata(){return ((algoenter2*)alg)->data;};
};

class funcenter : public func // 一元全區間等距插值
{
 public:
	funcenter(matrix& d, DOUBLE x0, DOUBLE h):
		func(new algoenter(d,x0,h)){};
	matrix& getdata(DOUBLE &xx0, DOUBLE &hh){
		xx0 = ((algoenter*)alg)->x0; hh = ((algoenter*)alg)->h;
		return ((algoenter*)alg)->data; };
};

class funcpair : public func // 最小二乘擬合函數
{
 public:
	funcpair(matrix& xy, size_t m, DOUBLE & t0,DOUBLE &t1,DOUBLE &t2);
		// xy為n行2列數組，存放n個樣本點
			// m為擬合多項式的項數，dt0為誤差平方和，dt1為誤差絕對值和，
		// dt2為最大誤差絕對值
	matrix & getdata(){return ((algopair*)alg)->data;};
	 // 返回結果擬合系數一維矩陣
	cmatrix getroots(){return ((algopoly*)alg)->getroots();};
		// 求出所有根
};

class funcregress : public func // 線性回歸函數，其實就是線性函數ax+b
	// 但由數據樣本點構成a與b
{
 public:
	funcregress(matrix & xy, matrix* dt=0);  // xy為n行2列的矩陣為n個樣本點
		// dt必須指向一個6列一行的矩陣向量，六個數依次為偏差平方和，平均標準
		// 偏差，回歸平方和，最大偏差，最小偏差，偏差平均值
};

#endif // FUNC_H
?? 文件大小 50 K
?? 上傳用戶 gqingwei
?? 所屬分類數學計算
??? 相關標簽

#算法 #分 #矩陣運算
?? 快捷鍵說明

復制代碼 Ctrl + C
搜索代碼 Ctrl + F
全屏模式 F11
切換主題 Ctrl + Shift + D
顯示快捷鍵 ?
增大字號 Ctrl + =
減小字號 Ctrl + -
亚洲欧美第一页_禁久久精品乱码_粉嫩av一区二区三区免费野_久草精品视频

?? func.h

?? 快捷鍵說明
