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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 语音合成与识别 > 查看源码
FE_complex.h
资源名称：speech_analysis.rar　[点击查看]
上传用户：italyroyal
上传日期：2013-05-06
资源大小：473k
文件大小：9k
源码类别：

语音合成与识别

开发平台：

Visual C++

FE_complex.h：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. // This is a part of the Feature program.
  3. // Version: 1.0
  4. // Date: February 22, 2003
  5. // Programmer: Oh-Wook Kwon
  6. // Copyright(c) 2003 Oh-Wook Kwon. All rights reserved. owkwon@ucsd.edu
  7. ///////////////////////////////////////////////////////////////////////////////
  9. #ifndef _FE_COMPLEX_H_
  10. #define _FE_COMPLEX_H_
  12. #include <cstdio>
  13. #include <cmath>
  15. #ifndef M_PI
  16. #define M_PI 3.14159265358979323846
  17. #endif
  19. template <typename T> class Complex;
  21. // friend template functions
  22. template <typename T> Complex<T> complex_plus(const Complex<T>& A, const Complex<T>& B);
  23. template <typename T> Complex<T> complex_plus(const Complex<T>& A, const double b);
  24. template <typename T> Complex<T> complex_plus(const double b, const Complex<T>& A);
  26. template <typename T> Complex<T> complex_minus(const Complex<T>& A, const Complex<T>& B);
  27. template <typename T> Complex<T> complex_minus(const Complex<T>& A, const double b);
  28. template <typename T> Complex<T> complex_minus(const double b, const Complex<T>& A);
  30. template <typename T> Complex<T> complex_times(const Complex<T>& A, const Complex<T>& B);
  31. template <typename T> Complex<T> complex_times(const Complex<T>& A, const double b);
  32. template <typename T> Complex<T> complex_times(const double b, const Complex<T>& A);
  34. template <typename T> Complex<T> complex_divide(const Complex<T>& A, const Complex<T>& B);
  35. template <typename T> Complex<T> complex_divide(const Complex<T>& A, const double b);
  36. template <typename T> Complex<T> complex_divide(const double b, const Complex<T>& A);
  39. template <typename T>
  40. class Complex
  41. {
  42. public:
  43. Complex(const T a=(T)0, const T b=(T)0) : r(a), i(b) {}
  44. Complex(const Complex<T>& z) : r(z.r), i(z.i) {}
  45. ~Complex();
  47. public:
  48. T r;
  49. T i;
  51. Complex<T>   operator+();
  52.         Complex<T>   operator-();
  53. Complex<T>& operator=(const Complex<T>& a);
  54. Complex<T>& operator+=(const Complex<T>& a);
  55. Complex<T>& operator-=(const Complex<T>& a);
  56. Complex<T>& operator*=(const Complex<T>& a);
  57. Complex<T>& operator/=(const Complex<T>& a);
  59. friend Complex<T> operator+(const Complex<T>& a, const Complex<T>& b) {
  60. return complex_plus(a,b);
  61. }
  62. friend Complex<T> operator+(const Complex<T>& a, const T& b) {
  63. return complex_plus(a,b);
  64. }
  65. friend Complex<T> operator+(const T& a, const Complex<T>& b) {
  66. return complex_plus(a,b);
  67. }
  68. friend Complex<T> operator-(const Complex<T>& a, const Complex<T>& b) {
  69. return complex_minus(a,b);
  70. }
  71. friend Complex<T> operator-(const Complex<T>& a, const T& b) {
  72. return complex_minus(a,b);
  73. }
  74. friend Complex<T> operator-(const T& a, const Complex<T>& b) {
  75. return complex_minus(a,b);
  76. }
  77. friend Complex<T> operator*(const Complex<T>& a, const Complex<T>& b) {
  78. return complex_times(a,b);
  79. }
  80. friend Complex<T> operator*(const Complex<T>& a, const T& b) {
  81. return complex_times(a,b);
  82. }
  83. friend Complex<T> operator*(const T& a, const Complex<T>& b) {
  84. return complex_times(a,b);
  85. }
  86. friend Complex<T> operator/(const Complex<T>& a, const Complex<T>& b) {
  87. return complex_divide(a,b);
  88. }
  89. friend Complex<T> operator/(const Complex<T>& a, const T& b) {
  90. return complex_divide(a,b);
  91. }
  92. friend Complex<T> operator/(const T& a, const Complex<T>& b) {
  93. return complex_divide(a,b);
  94. }
  96. #ifdef __GNUC__
  97.         friend Complex<T> complex_plus<T>(const Complex<T>& A, const Complex<T>& B);
  98.         friend Complex<T> complex_plus<T>(const Complex<T>& A, const double b);
  99.         friend Complex<T> complex_plus<T>(const double b, const Complex<T>& A);
  100.         friend Complex<T> complex_minus<T>(const Complex<T>& A, const Complex<T>& B);
  101.         friend Complex<T> complex_minus<T>(const Complex<T>& A, const double b);
  102.         friend Complex<T> complex_minus<T>(const double b, const Complex<T>& A);
  103.         friend Complex<T> complex_times<T>(const Complex<T>& A, const Complex<T>& B);
  104.         friend Complex<T> complex_times<T>(const Complex<T>& A, const double b);
  105.         friend Complex<T> complex_times<T>(const double b, const Complex<T>& A);
  106.         friend Complex<T> complex_divide<T>(const Complex<T>& A, const Complex<T>& B);
  107.         friend Complex<T> complex_divide<T>(const Complex<T>& A, const double b);
  108.         friend Complex<T> complex_divide<T>(const double b, const Complex<T>& A);
  109. #endif
  111. };
  113. template <typename T> 
  114. inline Complex<T> Complex<T>::operator+() {
  115.         return (*this);
  116. }
  118. template <typename T> 
  119. inline Complex<T> Complex<T>::operator-() {
  120.         Complex<T> C=(*this);
  121.         C*=(-1);
  122.         return C;
  123. }
  125. template <typename T>
  126. inline Complex<T> complex_plus(const Complex<T>& a, const Complex<T>& b)
  127. {
  128. Complex<T> c = a;
  129. c += b;
  130. return c;
  131. }
  133. template <typename T>
  134. inline Complex<T> complex_plus(const Complex<T>& a, const T& b)
  135. {
  136. Complex<T> c = a;
  137. c += Complex<T>((T)b,(T)0);
  138. return c;
  139. }
  141. template <typename T>
  142. inline Complex<T> complex_plus(const T& a, const Complex<T>& b)
  143. {
  144. Complex<T> c((T)a, (T)0);
  145. c += b;
  146. return c;
  147. }
  149. template <typename T>
  150. inline Complex<T> complex_plus(const Complex<T>& a)
  151. {
  152. Complex<T> c = a;
  153. return c;
  154. }
  156. template <typename T>
  157. inline Complex<T> complex_minus(const Complex<T>& a, const Complex<T>& b)
  158. {
  159. Complex<T> c = a;
  160. c -= b;
  161. return c;
  162. }
  164. template <typename T>
  165. inline Complex<T> complex_minus(const Complex<T>& a, const T& b)
  166. {
  167. Complex<T> c = a;
  168. c -= Complex<T>((T)b,(T)0);
  169. return c;
  170. }
  172. template <typename T>
  173. inline Complex<T> complex_minus(const T& a, const Complex<T>& b)
  174. {
  175. Complex<T> c((T)a, (T)0);
  176. c -= b;
  177. return c;
  178. }
  180. template <typename T>
  181. inline Complex<T> complex_minus(const Complex<T>& a)
  182. {
  183. Complex<T> c((T)0, (T)0);
  184. c -= a;
  185. return c;
  186. }
  188. template <typename T>
  189. inline Complex<T> complex_times(const Complex<T>& a, const Complex<T>& b)
  190. {
  191. Complex<T> c = a;
  192. c *= b;
  193. return c;
  194. }
  196. template <typename T>
  197. inline Complex<T> complex_times(const Complex<T>& a, const T& b)
  198. {
  199. Complex<T> c = a;
  200. c *= Complex<T>((T)b,(T)0);
  201. return c;
  202. }
  204. template <typename T>
  205. inline Complex<T> complex_times(const T& a, const Complex<T>& b)
  206. {
  207. Complex<T> c((T)a, (T)0);
  208. c *= b;
  209. return c;
  210. }
  212. template <typename T>
  213. inline Complex<T> complex_divide(const Complex<T>& a, const Complex<T>& b)
  214. {
  215. Complex<T> c = a;
  216. c /= b;
  217. return c;
  218. }
  220. template <typename T>
  221. inline Complex<T> complex_divide(const Complex<T>& a, const T& b)
  222. {
  223. Complex<T> c = a;
  224. c /= Complex<T>((T)b,(T)0);
  225. return c;
  226. }
  228. template <typename T>
  229. inline Complex<T> complex_divide(const T& a, const Complex<T>& b)
  230. {
  231. Complex<T> c((T)a, (T)0);
  232. c /= b;
  233. return c;
  234. }
  236. template <typename T>
  237. Complex<T>::~Complex()
  238. {
  239. }
  241. template <typename T>
  242. T real(const Complex<T>& z)
  243. {
  244. return z.r;
  245. }
  247. template <typename T>
  248. T imag(const Complex<T>& z)
  249. {
  250. return z.i;
  251. }
  253. template <typename T>
  254. T abs(const Complex<T>& z)
  255. {
  256. T x,y,ans,temp;
  257. x=(T)fabs(z.r);
  258. y=(T)fabs(z.i);
  259. if(x == (T)0)
  260. ans=y;
  261. else if(y == (T)0)
  262. ans=x;
  263. else if(x>y){
  264. temp=y/x;
  265. ans=(T)(x*sqrt((T)1.0+temp*temp));
  266. } else {
  267. temp = x/y;
  268. ans=(T)(y*sqrt((T)1.0+temp*temp));
  269. }
  270. return ans;
  271. }
  273. template <typename T>
  274. T arg(const Complex<T>& z)
  275. {
  276. if(z.r == (T)0 && z.i == (T)0) return (T)0;
  277. else if(z.i >= (T)0) return (T)acos(z.r/abs(z));
  278. else return (T)(2*M_PI-acos(z.r/abs(z)));
  279. }
  281. template <typename T>
  282. Complex<T> sqrt(const Complex<T>& z)
  283. {
  284. Complex<T> c;
  285. T x,y,w,r;
  286. if((z.r == (T)0) && (z.i == (T)0)){
  287. c.r = (T)0;
  288. c.i = (T)0;
  289. return c;
  290. } else {
  291. x=(T)fabs(z.r);
  292. y=(T)fabs(z.i);
  293. if(x>=y){
  294. r=y/x;
  295. w=(T)(sqrt(x)*sqrt(0.5*(1.0+sqrt(1.0+r*r))));
  296. } else {
  297. r=x/y;
  298. w=(T)(sqrt(y)*sqrt(0.5*(r+sqrt(1.0+r*r))));
  299. }
  300. if(z.r >= (T)0){
  301. c.r=w;
  302. c.i=z.i/(T)(2*w);
  303. } else {
  304. c.i=(z.i >= (T)0) ? w : -w;
  305. c.r=z.i/(T)(2.0*c.i);
  306. }
  307. return c;
  308. }
  309. }
  311. template <typename T>
  312. Complex<T> conjg(const Complex<T>& z)
  313. {
  314. Complex<T> c;
  315. c.r = z.r;
  316. c.i = -z.i;
  317. return c;
  318. }
  320. template <typename T>
  321. Complex<T>& Complex<T>::operator=(const Complex<T>& a)
  322. {
  323. r = a.r;
  324. i = a.i;
  325. return *this;
  326. }
  328. template <typename T>
  329. Complex<T>& Complex<T>::operator+=(const Complex<T>& a)
  330. {
  331. r += a.r;
  332. i += a.i;
  333. return *this;
  334. }
  336. template <typename T>
  337. Complex<T>& Complex<T>::operator-=(const Complex<T>& a)
  338. {
  339. r -= a.r;
  340. i -= a.i;
  341. return *this;
  342. }
  344. template <typename T>
  345. Complex<T>& Complex<T>::operator*=(const Complex<T>& a)
  346. {
  347. T t;
  348. r = (t=r)*a.r-i*a.i;
  349. i = i*a.r+t*a.i;
  350. return *this;
  351. }
  353. template <typename T>
  354. Complex<T>& Complex<T>::operator/=(const Complex<T>& a)
  355. {
  356. T ratio,den,t;
  357. if((T)fabs(a.r) >= (T)fabs(a.i)){
  358. ratio = a.i/a.r;
  359. den = a.r+ratio*a.i;
  360. r = ((t=r)+ratio*i)/den;
  361. i = (i-ratio*t)/den;
  362. }
  363. else{
  364. ratio = a.r/a.i;
  365. den = a.i+ratio*a.r;
  366. r = ((t=r)*ratio+i)/den;
  367. i = (i*ratio-t)/den;
  368. }
  370. return *this;
  371. }
  373. #endif