VFUNC.H
上传用户:zengbais
上传日期:2022-08-08
资源大小:49k
文件大小:10k
开发平台:

C++ Builder

  1. #ifndef VFUNC_H
  2. #define VFUNC_H
  3. #include <math.h>
  4. #include "matrix.h"
  5. class valgo // 矩阵算法类
  6. {
  7.  private:
  8. DOUBLE yfactor; // 乘因子,初始化为1
  9. DOUBLE xfactor; // x轴放大因子,初始化为1
  10. DOUBLE addconst; // 加和,初始化为0
  11. DOUBLE xshift; // x平移量,初始化为0
  12.  public:
  13. unsigned refnum; // 引用数,初始化为1
  14. valgo():refnum(1),yfactor(1.0),xfactor(1.0),addconst(0.0),xshift(0.0){};
  15.  // 构造函数,产生y=x线性函数
  16. valgo(DOUBLE xs, DOUBLE xf,DOUBLE adc=0, DOUBLE yf=1):refnum(1),yfactor(yf),
  17. addconst(adc),xshift(xs),xfactor(xf){}; // 为子类的调用而存在的构造函数
  18. valgo(DOUBLE a):refnum(1),yfactor(0.0),xfactor(1.0),addconst(a),xshift(0.0){};
  19.  // 常函数的构造,输出结构与输入矩阵同样阶数的常数矩阵
  20. valgo(valgo & alg):yfactor(alg.yfactor),xfactor(alg.xfactor),
  21. addconst(alg.addconst),xshift(alg.xshift),refnum(1){}; // 拷贝构造函数
  22. virtual ~valgo(){};
  23. matrix cal(matrix & x); // 计算算法值
  24. virtual matrix& calculate(matrix & x)
  25. {return x;}; // 本身算法,将被继承子类改写, 返回的引用须与x同
  26. virtual valgo * clone(); // 克隆自己,必须被继承子类改写
  27. valgo * mul(DOUBLE a); // 乘a
  28. valgo * add(DOUBLE a); // 加a
  29. valgo * neg(); // 取负
  30. valgo * setxfactor(DOUBLE x); // 设置x轴因子
  31. valgo * xroom(DOUBLE x); // 将xfactor扩大x倍
  32. valgo * setxshift(DOUBLE x); // 设置xshift的值
  33. valgo * xshiftas(DOUBLE x); // 从当前开始平移x
  34. };
  35. #ifndef FUNC_H
  36. enum method {cadd,csub,cmul,cdiv,cpow,ccom}; // 枚举加减乘除乘方复合这四种运算
  37. #endif
  38. class valgojoin : public valgo // 结合算法
  39. {
  40.  public:
  41. valgo * leftalgo; // 左算法,初始化为0
  42. valgo * rightalgo; // 右算法,初始化为0
  43. method met; // 指明算法
  44. valgojoin(valgo * l, valgo * r, method m):leftalgo(l),
  45. rightalgo(r), met(m)
  46. { if(leftalgo)
  47. leftalgo->refnum++;
  48.   if(rightalgo)
  49. rightalgo->refnum++;
  50. };
  51. valgojoin(valgojoin& alg):valgo(alg),
  52. leftalgo(alg.leftalgo),rightalgo(alg.rightalgo),met(alg.met){
  53. if(leftalgo)
  54. leftalgo->refnum++;
  55. if(rightalgo)
  56. rightalgo->refnum++;};
  57. // 拷贝构造函数
  58. virtual ~valgojoin() {
  59. if(leftalgo) { // 如左或者右算法已经没有被引用,则删除
  60. leftalgo->refnum--;
  61. if(!leftalgo->refnum) delete leftalgo;
  62. }
  63. if(rightalgo) {
  64. rightalgo->refnum--;
  65. if(!rightalgo->refnum) delete rightalgo;
  66. }
  67. };
  68. virtual valgo * clone(); // 克隆自己
  69. virtual matrix& calculate(matrix& x); // 实施结合算法
  70. };
  71. class valgofun : public valgo // 函数算法
  72. {
  73.  public:
  74. matrix& (*f)(matrix&); // 函数指针
  75. valgofun(matrix& (*fun)(matrix&)):f(fun){}; // 用函数指针进行初始化
  76. valgofun(valgofun& alg):valgo(alg),f(alg.f){}; // 拷贝构造函数
  77. virtual matrix& calculate(matrix& x); // 实施函数算法
  78. virtual valgo * clone(); // 克隆自己
  79. };
  80. class valgofun1 : public valgo // 标量到向量的函数算法
  81. {
  82.  public:
  83. matrix (*f)(DOUBLE); // 标量到向量的函数指针
  84. valgofun1(matrix (*fun)(DOUBLE)):f(fun){}; // 用函数指针进行初始化
  85. valgofun1(valgofun1& alg):valgo(alg),f(alg.f){}; // 拷贝构造函数
  86. virtual matrix& calculate(matrix& x); // 实施函数算法
  87. virtual valgo * clone(); // 克隆自己
  88. };
  89. class valgodiff : public valgo // 微分方程组函数算法
  90. {
  91.  public:
  92. matrix (*f)(DOUBLE,matrix&); // 表示f(t,y)的函数指针,y为向量
  93. DOUBLE t0; // 初始变量
  94. matrix y0; // 初值或称边界条件
  95. DOUBLE tnow; // 最近值
  96. matrix ynow; // 最近算得的y值
  97. valgodiff(matrix (*fun)(DOUBLE,matrix&), DOUBLE tt0, matrix& yy0):
  98. f(fun),t0(tt0),y0(yy0),tnow(tt0),ynow(yy0){};
  99. valgodiff(valgodiff& alg):valgo(alg),f(alg.f),t0(alg.t0),y0(alg.y0),
  100. tnow(alg.tnow),ynow(alg.ynow){}; // 拷贝构造函数
  101. virtual matrix& calculate(matrix& x); // 实施函数算法
  102. virtual valgo * clone(); // 克隆自己
  103. matrix& calcul(DOUBLE t, DOUBLE eps=defaulterr); // 标量算法
  104. };
  105. class vfunc { // 矩阵函数类
  106.  public:
  107. valgo * alg; // 决定函数的算法
  108. vfunc(); // 缺省构造函数
  109. vfunc(DOUBLE a); // 常函数的构造函数
  110. vfunc(matrix& (*fun)(matrix&)); // 函数指针的构造函数
  111. vfunc(matrix (*fun)(DOUBLE t)); // 标量到向量的函数指针构造函数
  112. vfunc(vfunc & fn); // 拷贝构造函数
  113. vfunc(valgo * a):alg(a){} // 算法构造函数,使用要小心,不能将一个算法产生
  114. // 两个函数,除非自己控制引用数的增加
  115. virtual ~vfunc() { // 析构函数
  116. if(alg) {
  117. alg->refnum--; // 引用数减一,如再无其它引用,则删除算法
  118. if(!alg->refnum)
  119. delete alg;
  120. }
  121. };
  122. matrix operator()(matrix& x){return alg->cal(x);}; // 计算x的函数值
  123. vfunc& operator=(vfunc& fn); // 赋值运算符
  124. vfunc& operator=(matrix& (*fn)(matrix&)); // 用函数指针的赋值运算符
  125. vfunc& operator=(DOUBLE a); // 常函数的赋值运算符
  126. vfunc& operator+=(vfunc& fn); // 自身加一个函数
  127. vfunc& operator+=(DOUBLE a){alg=alg->add(a);return (*this);};//自身加一个常数
  128. vfunc& operator+=(matrix& (*f)(matrix&)); // 自身加一个函数指针
  129. vfunc operator+(vfunc& fn); // 相加产生新函数
  130. vfunc operator+(DOUBLE a); // 与常数相加产生新函数
  131. friend vfunc operator+(DOUBLE a, vfunc& f); // 同上但常数在前
  132. vfunc operator+(matrix& (*f)(matrix&)); // 加一个函数指针产生新函数
  133. friend vfunc operator+(matrix& (*f)(matrix&),vfunc& fn);
  134.  // 同上但函数指针在前
  135. vfunc& neg(); // 自身取负
  136. vfunc operator-(); // 产生负函数
  137. vfunc& operator-=(vfunc& fn); // 自身减一个函数
  138. vfunc& operator-=(DOUBLE a){alg=alg->add(-a);return (*this);};
  139. //自身减一个常数
  140. vfunc& operator-=(matrix& (*f)(matrix&)); // 自身减一个函数指针
  141. vfunc operator-(vfunc& fn); // 相减产生新函数
  142. vfunc operator-(DOUBLE a); // 与常数相减产生新函数
  143. friend vfunc operator-(DOUBLE a, vfunc& f); // 同上但常数在前
  144. vfunc operator-(matrix& (*f)(matrix&)); // 减一个函数指针产生新函数
  145. friend vfunc operator-(matrix& (*f)(matrix&),vfunc& fn); // 函数指针减函数
  146. vfunc& operator*=(vfunc& fn); // 自身乘一个函数
  147. vfunc& operator*=(DOUBLE a){alg=alg->mul(a);return (*this);};//自身乘一个常数
  148. vfunc& operator*=(matrix& (*f)(matrix&)); // 自身乘一个函数指针
  149. vfunc operator*(vfunc& fn); // 相乘产生新函数
  150. vfunc operator*(DOUBLE a); // 与常数相乘产生新函数
  151. friend vfunc operator*(DOUBLE a, vfunc& f); // 同上但常数在前
  152. vfunc operator*(matrix& (*f)(matrix&)); // 乘一个函数指针产生新函数
  153. friend vfunc operator*(matrix& (*f)(matrix&),vfunc& fn); // 函数指针乘函数
  154. vfunc& operator/=(vfunc& fn); // 自身除以一个函数
  155. vfunc& operator/=(DOUBLE a){alg=alg->mul(1.0/a);return (*this);
  156. };//自身除以常数
  157. vfunc& operator/=(matrix& (*f)(matrix&)); // 自身除以一个函数指针
  158. vfunc operator/(vfunc& fn); // 相除产生新函数
  159. vfunc operator/(DOUBLE a); // 与常数相除产生新函数
  160. friend vfunc operator/(DOUBLE a, vfunc& f); // 常数除以函数
  161. vfunc operator/(matrix& (*f)(matrix&)); // 除以一个函数指针产生新函数
  162. friend vfunc operator/(matrix& (*f)(matrix&),vfunc& fn); // 函数指针除以函数
  163. vfunc operator()(vfunc & fn); // 复合函数,产生新的函数
  164. void setxfactor(DOUBLE a); // 设置x因子为a
  165. void xroom(DOUBLE a);   // x方向扩大a倍
  166. void setxshift(DOUBLE a); // 设置函数沿x轴平移a
  167. void shiftxas(DOUBLE a); // 函数沿x轴右移a
  168. };
  169. class vfuncdiff : public vfunc // 微分方程函数
  170. {
  171.  public:
  172. vfuncdiff(matrix (*fun)(DOUBLE,matrix&), DOUBLE t0, matrix& y0):
  173. vfunc(new valgodiff(fun,t0,y0)){}; // 构造函数,fun为微分方程右端函数
  174. // 的函数指针,t0起始时间,y0为起始值
  175. matrix& operator()(DOUBLE t) {
  176. return ((valgodiff*)alg)->calcul(t); };
  177. };
  178. class linemodel  // 线性动态观测系统模型
  179. // 用作测试卡尔曼滤波器而产生仿真观测数据
  180. {
  181.  public:
  182. matrix x; // 当前状态变量
  183. matrix a; // 当前状态转移矩阵
  184. matrix h; // 当前观测矩阵
  185. gassvector w; // 模型噪声源
  186. gassvector v; // 观测噪声源
  187. matrix y; // 当前观测向量
  188. linemodel(matrix& va, matrix & vh, matrix & q, matrix & r, matrix & vx);
  189. // 构造函数,va初始状态转移矩阵,vh初始观测矩阵,q当前模型噪声协
  190. // 方差阵,r当前观测噪声协方差阵,vx初始状态变量
  191. void setdata(matrix& va, matrix & vh, matrix & q, matrix & r);
  192. void seta(matrix& va);
  193. void seth(matrix& vh);
  194. void setq(matrix& q);
  195. void setr(matrix& r);
  196. matrix & next(); // 计算下一级x值并返回新的x对应的y值
  197. };
  198. class kalman  // 卡尔曼滤波类
  199. {
  200.  public:
  201. matrix x; // 当前状态变量的估值
  202. matrix p; // 当前估值的误差协方差阵
  203. matrix a; // 当前状态转移矩阵
  204. matrix h; // 当前观测矩阵
  205. matrix y; // 当前观测向量
  206. matrix q; // 当前模型噪声协方差阵
  207. matrix r; // 当前观测噪声协方差阵
  208. kalman(matrix &va,matrix& vq,matrix& vr,matrix& vh,matrix& vx,matrix& vp);
  209. // 构造函数,va为状态转移矩阵,vh观测矩阵,vq模型噪声协方差阵,
  210. // vr当前观测噪声协方差阵,vx初始状态变量估值,vp初始估值协方差阵
  211. void setdata(matrix &va,matrix& vq,matrix& vr,matrix& vh);
  212. // 为时变系统随时设置系统参数,va为状态转移矩阵,vh观测矩阵,vq模型噪
  213. // 声协方差阵,vr当前观测噪声协方差阵
  214. void seta(matrix& va);
  215. void seth(matrix& vh);
  216. void setq(matrix& vq);
  217. void setr(matrix& vr);
  218. matrix& next(matrix& y); // 根据下一个观测值获得新的状态变量的估值
  219. };
  220. inline vfunc operator+(DOUBLE a, vfunc& f) // 常数加函数
  221. { return f+a; }
  222. inline vfunc operator+(matrix& (*f)(matrix&),vfunc& fn) // 函数指针加函数
  223. { return fn+f;}
  224. vfunc operator-(DOUBLE a, vfunc& f); // 常数减函数
  225. vfunc operator-(matrix& (*f)(matrix&),vfunc& fn); // 函数指针减函数
  226. inline vfunc operator*(DOUBLE a, vfunc& f) // 常数乘函数
  227. { return f*a; }
  228. inline vfunc operator*(matrix& (*f)(matrix&),vfunc& fn) // 函数指针乘函数
  229. { return fn*f;}
  230. vfunc operator/(DOUBLE a, vfunc& f); // 常数除以函数
  231. vfunc operator/(matrix& (*f)(matrix&),vfunc& fn); // 函数指针除以函数
  232. class regress // 多元线性回归分析类
  233. {
  234.  public:
  235. matrix a; // 算出的回归系数m+1维向量
  236. matrix v; // 算出的偏相关系数m维向量
  237. DOUBLE q; // 偏差平方和
  238. DOUBLE s; // 平均标准偏差
  239. DOUBLE r; // 复相关系数
  240. DOUBLE u; // 回归平方和
  241. regress(matrix& x, matrix& y); // x为mXn维矩阵,y为n个观测值
  242. DOUBLE operator()(matrix& x); // 回归后的线性函数,x是自变量
  243. };
  244. #endif // VFUNC_H