开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
FUNC.CPP
资源名称：BCMATH.rar　[点击查看]
上传用户：zengbais
上传日期：2022-08-08
资源大小：49k
文件大小：12k
源码类别：

数值算法/人工智能

开发平台：

C++ Builder

FUNC.CPP：源码内容
  1. #include <values.h>
  2. #include <math.h>
  3. #include <stdio.h>
  4. #include "func.h"
  7. DOUBLE algo::cal(DOUBLE x) { // 基类的基本算法
  8. return yfactor*calculate(xfactor*(x-xshift))+addconst;
  9. }
  11. algo * algo::clone() // 克隆自己，必须被继承子类改写
  12. {
  13. return new algo(*this);
  14. }
  16. algo * algo::mul(DOUBLE a) // 乘a
  17. {
  18. algo * alg;
  19. alg = this;
  20. if(refnum>1) { refnum--;
  21. alg = clone(); // 如引用数大于1，则产生新的对象
  22. }
  23. alg->yfactor *= a;
  24. alg->addconst *= a;
  25. return alg;
  26. }
  28. algo * algo::add(DOUBLE a) // 加a
  29. {
  30. algo * alg;
  31. alg = this;
  32. if(refnum>1) { refnum--;
  33. alg = clone(); // 如引用数大于1，则产生新的对象
  34. }
  35. alg->addconst += a;
  36. return alg;
  37. }
  39. algo * algo::neg() // 取负
  40. {
  41. algo * alg;
  42. alg = this;
  43. if(refnum>1) { refnum--;
  44. alg = clone(); // 如引用数大于1，则产生新的对象
  45. }
  46. alg->addconst = -alg->addconst;
  47. alg->yfactor = -alg->yfactor;
  48. return alg;
  49. }
  51. algo * algo::setxfactor(DOUBLE x) // 设置x轴因子
  52. {
  53. algo * alg;
  54. alg = this;
  55. if(refnum>1) { refnum--;
  56. alg = clone(); // 如引用数大于1，则产生新的对象
  57. }
  58. alg->xfactor = x;
  59. return alg;
  60. }
  62. algo * algo::xroom(DOUBLE x) // 将xfactor扩大x倍
  63. {
  64. algo * alg;
  65. alg = setxfactor(x*xfactor);
  66. if(x!=0)alg->xshift/=x;
  67. return alg;
  68. }
  70. algo * algo::setxshift(DOUBLE x) // 设置xshift的值
  71. {
  72. algo * alg;
  73. alg = this;
  74. if(refnum>1) { refnum--;
  75. alg = clone(); // 如引用数大于1，则产生新的对象
  76. }
  77. alg->xshift = x;
  78. return alg;
  79. }
  81. algo * algo::xshiftas(DOUBLE x) // 从当前开始平移x
  82. {
  83. return setxshift(xshift+x);
  84. }
  86. algo * algojoin::clone() // 克隆自己
  87. {
  88. return new algojoin(*this);
  89. }
  91. DOUBLE algojoin::calculate(DOUBLE x) // 实施结合算法
  92. {
  93. if(leftalgo==0 || rightalgo==0)
  94. throw TMESSAGE("empty algo pointor!");
  95. DOUBLE a,b;
  96. if(met == ccom) // 复合函数
  97. return leftalgo->cal(rightalgo->cal(x));
  98. a = leftalgo->cal(x);
  99. b = rightalgo->cal(x);
  100. if(met == cadd) // 返回各结合运算值
  101. return a+b;
  102. else if(met == csub)
  103. return a-b;
  104. else if(met == cmul)
  105. return a*b;
  106. else if(met == cdiv)
  107. return a/b;
  108. else if(met == cpow)
  109. return pow(a,b);
  110. return 0.0;
  111. }
  113. algo * algofun::clone() // 克隆自己
  114. {
  115. return new algofun(*this);
  116. }
  118. DOUBLE algofun::calculate(DOUBLE x) // 实施函数算法
  119. {
  120. if(f)
  121. return f(x);
  122. return 0.0;
  123. }
  125. func::func()// 缺省构造函数，产生函数f(x)=x;
  126. {
  127. alg = new algo();
  128. }
  130. func::func(func & fn) // 拷贝构造函数
  131. {
  132. alg = fn.alg;
  133. alg->refnum++;
  134. }
  136. func::func(DOUBLE (*fun)(DOUBLE)) // 函数指针的构造函数
  137. {
  138. alg = new algofun(fun);
  139. }
  141. func::func(DOUBLE a) // 常函数构造函数
  142. {
  143. alg = new algo(a);
  144. }
  146. func::func(algo * a) // 算法的构造函数
  147. {
  148. if(a)
  149. alg = a;
  150. }
  152. func::func(algo& a) // 另一种算法构造函数
  153. {
  154. alg = a.clone(); // 克隆出一个同样的算法变量并将指针赋予alg.
  155. }
  157. func& func::operator=(func& fn) // 赋值运算符
  158. {
  159. if(this == &fn) return (*this); // 如果等于自己，干脆啥也别做
  160. if(alg) {
  161. alg->refnum--; // 原算法引用数减1
  162. if(!alg->refnum) // 如结果为0则删除原算法
  163. delete alg;
  164. }
  165. alg = fn.alg; // 将fn的算法移过来
  166. if(alg) alg->refnum++; // 引用数增加
  167. return (*this);
  168. }
  170. func& func::operator=(DOUBLE (*fn)(DOUBLE)) // 用函数指针的赋值运算符
  171. {
  172. if(alg) {
  173. alg->refnum--; // 原算法引用数减1
  174. if(!alg->refnum) // 如结果为0则删除原算法
  175. delete alg;
  176. }
  177. alg = new algofun(fn);
  178. return (*this);
  179. }
  181. func& func::operator=(DOUBLE a) // 常函数的赋值运算符
  182. {
  183. if(alg) {
  184. alg->refnum--; // 原算法引用数减1
  185. if(!alg->refnum) // 如结果为0则删除原算法
  186. delete alg;
  187. }
  188. alg = new algo(a);
  189. return (*this);
  190. }
  192. func& func::operator+=(func& fn) // 自身加一个函数
  193. {
  194. algo * a = new algojoin(alg, fn.alg, cadd);
  195. alg->refnum--; // 因为联合算法对两个算法都加了引用数，因此再减回来
  196. alg = a; // 将新指针赋给alg
  197. return (*this);
  198. }
  200. func& func::operator+=(DOUBLE (*f)(DOUBLE)) // 自身加一个函数指针
  201. {
  202. func fn(f); // 将函数指针包装为函数类
  203. operator+=(fn); // 实施加操作
  204. return (*this);
  205. }
  207. func func::operator+(func& fn) // 相加产生新函数
  208. {
  209. algo * a = new algojoin(alg, fn.alg, cadd);
  210. func f(a);
  211. return f;
  212. }
  214. func func::operator+(DOUBLE a) // 与常数相加产生新函数
  215. {
  216. func f(*this);
  217. f += a;
  218. return f;
  219. }
  221. func func::operator+(DOUBLE (*f)(DOUBLE)) // 加一个函数指针产生新函数
  222. {
  223. func ff(*this);
  224. ff += f;
  225. return ff;
  226. }
  228. func& func::neg() // 自身取负
  229. {
  230. alg=alg->neg();
  231. return (*this);
  232. }
  234. func func::operator-() // 产生负函数
  235. {
  236. func f(*this);
  237. f.neg();
  238. return f;
  239. }
  241. func& func::operator-=(func& fn) // 自身减一个函数
  242. {
  243. algo * a = new algojoin(alg, fn.alg, csub);
  244. alg->refnum--; // 因为联合算法对两个算法都加了引用数，因此再减回来
  245. alg = a; // 将新指针赋给alg
  246. return (*this);
  247. }
  249. func& func::operator-=(DOUBLE (*f)(DOUBLE)) // 自身减一个函数指针
  250. {
  251. func fn(f); // 将函数指针包装为函数类
  252. operator-=(fn); // 实施减操作
  253. return (*this);
  254. }
  256. func func::operator-(func& fn) // 相减产生新函数
  257. {
  258. algo * a = new algojoin(alg, fn.alg, csub);
  259. func f(a);
  260. return f;
  261. }
  263. func func::operator-(DOUBLE a) // 与常数相减产生新函数
  264. {
  265. func f(*this);
  266. f -= a;
  267. return f;
  268. }
  270. func operator-(DOUBLE a, func& f) // 常数减函数
  271. {
  272. return (-f)+a;
  273. }
  275. func func::operator-(DOUBLE (*f)(DOUBLE)) // 减一个函数指针产生新函数
  276. {
  277. func ff(*this);
  278. ff -= f;
  279. return ff;
  280. }
  282. func operator-(DOUBLE (*f)(DOUBLE),func& fn) // 函数指针减函数
  283. {
  284. func ff(f);
  285. ff -= fn;
  286. return ff;
  287. }
  289. func& func::operator*=(func& fn) // 自身乘一个函数
  290. {
  291. algo * a = new algojoin(alg, fn.alg, cmul);
  292. alg->refnum--; // 因为联合算法对两个算法都加了引用数，因此再减回来
  293. alg = a; // 将新指针赋给alg
  294. return (*this);
  295. }
  297. func& func::operator*=(DOUBLE (*f)(DOUBLE)) // 自身乘一个函数指针
  298. {
  299. func fn(f); // 将函数指针包装为函数类
  300. operator*=(fn); // 实施乘操作
  301. return (*this);
  302. }
  304. func func::operator*(func& fn) // 相乘产生新函数
  305. {
  306. algo * a = new algojoin(alg, fn.alg, cmul);
  307. func f(a);
  308. return f;
  309. }
  311. func func::operator*(DOUBLE a) // 与常数相乘产生新函数
  312. {
  313. func f(*this);
  314. f *= a;
  315. return f;
  316. }
  318. func func::operator*(DOUBLE (*f)(DOUBLE)) // 乘一个函数指针产生新函数
  319. {
  320. func ff(*this);
  321. ff *= f;
  322. return ff;
  323. }
  325. func& func::operator/=(func& fn) // 自身除以一个函数
  326. {
  327. algo * a = new algojoin(alg, fn.alg, cdiv);
  328. alg->refnum--; // 因为联合算法对两个算法都加了引用数，因此再减回来
  329. alg = a; // 将新指针赋给alg
  330. return (*this);
  331. }
  333. func& func::operator/=(DOUBLE (*f)(DOUBLE)) // 自身除以一个函数指针
  334. {
  335. func fn(f); // 将函数指针包装为函数类
  336. operator/=(fn); // 实施除法操作
  337. return (*this);
  338. }
  340. func func::operator/(func& fn) // 相除产生新函数
  341. {
  342. algo * a = new algojoin(alg, fn.alg, cdiv);
  343. func f(a);
  344. return f;
  345. }
  347. func func::operator/(DOUBLE a) // 与常数相除产生新函数
  348. {
  349. func f(*this);
  350. f /= a;
  351. return f;
  352. }
  354. func operator/(DOUBLE a, func& f) // 常数除以函数
  355. {
  356. func ff(a);
  357. return ff/f;
  358. }
  360. func func::operator/(DOUBLE (*f)(DOUBLE)) // 除以一个函数指针产生新函数
  361. {
  362. func ff(*this);
  363. ff /= f;
  364. return ff;
  365. }
  367. func operator/(DOUBLE (*f)(DOUBLE),func& fn) // 函数指针除以函数
  368. {
  369. func ff(f);
  370. ff /= fn;
  371. return ff;
  372. }
  374. void func::setxfactor(DOUBLE a) // 设置x因子为a
  375. {
  376. alg = alg->setxfactor(a);
  377. }
  379. void func::xroom(DOUBLE a)   // x方向扩大a倍
  380. {
  381. alg = alg->xroom(a);
  382. }
  384. func& func::power(func& f) // 函数的f次乘幂，函数自身改变
  385. {
  386. algo * a = new algojoin(alg, f.alg, cpow);
  387. alg->refnum--; // 因为联合算法对两个算法都加了引用数，因此再减回来
  388. alg = a; // 将新指针赋给alg
  389. return (*this);
  390. }
  392. func func::operator^(func& fn) // f次乘幂，产生新函数
  393. {
  394. algo * a = new algojoin(alg, fn.alg, cpow);
  395. func f(a);
  396. return f;
  397. }
  399. func& func::power(DOUBLE a) // 函数的a次幂，函数自身改变
  400. {
  401. func f(a);
  402. return power(f);
  403. }
  405. func func::operator^(DOUBLE a)  // 函数的a次幂，产生新函数，原函数不变
  406. {
  407. func f(a);
  408. func ff(*this);
  409. return ff.power(f);
  410. }
  412. func func::operator()(func & fn) // 复合函数，产生新的函数
  413. {
  414. algo * a = new algojoin(alg, fn.alg, ccom);
  415. func f(a);
  416. return f;
  417. }
  419. DOUBLE algopoly::calculate(DOUBLE x) // 实施函数算法
  420. {
  421. size_t i;
  422. DOUBLE u;
  423. size_t n=data.rownum-1;
  424. u=data(n,0);
  425. for (i=n; i>0; i--)
  426. u=u*x+data(i-1,0);
  427. return u;
  428. }
  430. algo * algopoly::clone() // 克隆自己
  431. {
  432. return new algopoly(*this);
  433. }
  435. DOUBLE algogass::calculate(DOUBLE x) // 实施函数算法
  436. {
  437. return gass(0,1,x);
  438. }
  440. algo * algogass::clone() // 克隆自己
  441. {
  442. return new algogass(*this);
  443. }
  445. func::func(DOUBLE a, DOUBLE d) // 产生正态分布函数a为均值，d为标准差
  446. {
  447. alg = new algogass(a,d);
  448. }
  450. func::func(matrix& m, funckind kind) // 构造数值相关函数，
  451. // 如kind = polyfunc, 则m为nX1矩阵，是n-1阶多项式系数，
  452. // 其中m(0,0)为常数项，m(n-1,0)为n-1次项。
  453. {
  454. if(kind == polyfunc)
  455. alg = new algopoly(m); // 产生多项式算法
  456. else if(kind == enter2func)
  457. alg = new algoenter2(m); // 产生一元全区间不等距插值
  458. }
  460. DOUBLE algoenter2::calculate(DOUBLE x) // 实施函数算法
  461. {
  462. size_t n = data.rownum;
  463. size_t i,j,k,m;
  464. double z,s;
  465. z=0.0;
  466. if (n<1) return(z);
  467. if (n==1) { z=data(0,1); return z;}
  468. if (n==2) {
  469. z = data(0,1)*(x-data(1,0))-data(1,1)*(x-data(0,0))/
  470. (data(0,0)-data(1,0));
  471.   return(z);
  472. }
  473. i=0;
  474. while ((i<n) && (data(i,0)<x)) i++; // ((x[i]<t)&&(i<n)) i=i+1;
  475. if (i<4) k=0;
  476. else k=i-4;
  477. m=i+3;
  478. if (m>n-1) m=n-1;
  479. for (i=k;i<=m;i++)
  480. { s=1.0;
  481. for (j=k;j<=m;j++)
  482. if (j!=i) s *= (x-data(j,0))/(data(i,0)-data(j,0)); //s=s*(t-x[j])/(x[i]-x[j]);
  483. z=z+s*data(i,1); // y[i];
  484. }
  485. return(z);
  486. }
  488. algo * algoenter2::clone() // 克隆自己
  489. {
  490. return new algoenter2(*this);
  491. }
  493. DOUBLE algoenter::calculate(DOUBLE x) // 实施函数算法
  494. {
  495. // double eelgr(x0,h,n,y,t)
  496. size_t n=data.rownum;
  497. //  double x0,h,t,y[];
  498. size_t i,j,k,m;
  499. DOUBLE z,s,xi,xj,p,q;
  500. z=0.0;
  501. if (n<1) return z;
  502. if (n==1) { z=data(0); return(z);}
  503. if (n==2)
  504. { z=(data(1)*(x-x0)-data(0)*(x-x0-h))/h;
  505. return z;
  506. }
  507. if (x>x0)
  508. { p=(x-x0)/h; q = floor(p); i=q;
  509. if (p>q) i++;
  510. }
  511. else i=0;
  512. k=i-4;
  513. if (i<4) k=0;
  514. else k=i-4;
  515. m=i+3;
  516. if (m>n-1) m=n-1;
  517. for (i=k;i<=m;i++)
  518. { s=1.0; xi=x0+i*h;
  519. for (j=k; j<=m; j++)
  520. if (j!=i)
  521. { xj=x0+j*h;
  522. s*=(x-xj)/(xi-xj);
  523. }
  524. z=z+s*data(i);
  525. }
  526. return z;
  527. }
  529. algo * algoenter::clone() // 克隆自己
  530. {
  531. return new algoenter(*this);
  532. }
  534. func::func(matrix& m, DOUBLE x0, DOUBLE h) // 构造等距插值函数
  535. // 其中m是nX1阶矩阵，代表n个y值，x0是起始点，h是步长（采样间隔）
  536. {
  537. alg = new algoenter(m,x0,h);
  538. }
  540. void func::setxshift(DOUBLE a) // 设置函数沿x轴平移a
  541. {
  542. alg = alg->setxshift(a);
  543. }
  545. void func::shiftxas(DOUBLE a) // 函数沿x轴右移a
  546. {
  547. alg = alg->xshiftas(a);
  548. }
  550. DOUBLE algo::integ(DOUBLE a, DOUBLE b, DOUBLE eps) // 在(a,b)区间积分
  551. // 采用勒让德高斯求积法
  552. {
  553.  size_t m,i,j;
  554.  DOUBLE s,p,ep,h,aa,bb,w,x,g;
  555.  static DOUBLE t[5]={-0.9061798459,-0.5384693101,0.0,
  556.  0.5384693101,0.9061798459};
  557.  static DOUBLE c[5]={0.2369268851,0.4786286705,0.5688888889,
  558. 0.4786286705,0.2369268851};
  559.  m=1;
  560.  h=b-a; s=fabs(0.001*h);
  561.  p=1.0e+35; ep=eps+1.0;
  562.  while ((ep>=eps)&&(fabs(h)>s))
  563. { g=0.0;
  564.   for (i=1;i<=m;i++)
  565.  { aa=a+(i-1.0)*h; bb=a+i*h;
  566. w=0.0;
  567. for (j=0;j<=4;j++)
  568.   { x=((bb-aa)*t[j]+(bb+aa))/2.0;
  569.  w=w+cal(x)*c[j];  //flrgsf(x)*c[j];
  570.   }
  571. g=g+w;
  572.  }
  573.   g *= h/2.0;
  574.   ep=fabs(g-p)/(1.0+fabs(g));
  575.   p=g; m=m+1; h=(b-a)/m;
  576. }
  577.  return g;
  578. }
  580. DOUBLE func::integ(DOUBLE a, DOUBLE b, DOUBLE eps)
  581. // 从a到b计算函数的定积分
  582. {
  583. return alg->integ(a,b,eps);
  584. }
  586. DOUBLE func::singleroot(DOUBLE x, DOUBLE eps)
  587. // 计算函数在x附近的一个单根
  588. {
  589. return getroot(*alg,x,eps);
  590. }
  592. DOUBLE algoinverse::calculate(DOUBLE x) // 实施反函数算法
  593. {
  594. algo * a = al->clone(); // 克隆一个一样的函数算法变量
  595. a->add(-x); // 形成函数f(t)-x
  596. DOUBLE t;
  597. t = getroot(*a); // 求f(t)-x=0的根
  598. delete a;
  599. return t;
  600. }
  602. algo * algoinverse::clone() // 克隆自己
  603. {
  604. return new algoinverse(*this);
  605. }
  607. func func::inverse() // 产生反函数
  608. {
  609. algo * a = new algoinverse(alg);
  610. func f;
  611. f.alg = a;
  612. return f;
  613. }