📄 特征提取.htm

📁 有关语音特征提取的C＋＋程序
💻 HTM
📖 第 1 页 / 共 2 页
字号:
12 下一页
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML><HEAD>
<META http-equiv=Content-Type content="text/html; charset=gb2312"></HEAD>
<BODY><PRE>///////////////////////////////////////////////////////////////////////////////
// This is a part of the Feature program.
// Version: 1.0
// Date: February 22, 2003
///////////////////////////////////////////////////////////////////////////////

#ifndef _FE_POLYNOMIAL_H_
#define _FE_POLYNOMIAL_H_

#include &lt;cstdio&gt;
#include &lt;cstdarg&gt;
#include &lt;cmath&gt;
#include &lt;cstring&gt;
#include &lt;cstdlib&gt;
#include &lt;typeinfo&gt;
#include &lt;vector&gt;
using namespace std;
#pragma warning(disable:4786)

#include "FE_complex.h"

template &lt;typename T&gt; class CPolynomial;

// friend template functions
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;T&gt;&amp; A, const double b);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_plus(const double b, const CPolynomial&lt;T&gt;&amp; A);

template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;T&gt;&amp; A, const double b);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_minus(const double b, const CPolynomial&lt;T&gt;&amp; A);

template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;T&gt;&amp; A, const double b);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_times(const double b, const CPolynomial&lt;T&gt;&amp; A);

template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;T&gt;&amp; A, const double b);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_divide(const double b, const CPolynomial&lt;T&gt;&amp; A);

template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_modulo(const CPolynomial&lt;T&gt;&amp; A, const double b);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_modulo(const CPolynomial&lt;T&gt;&amp; A, const double b);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_modulo(const double b, const CPolynomial&lt;T&gt;&amp; A);

/*
// GNU compiler gcc-2.95.2 cannot handle operator overloading with user-defined class type.
#if 0
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
template &lt;typename T&gt; CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
#endif
*/


template&lt;typename T&gt; 
class CPolynomial
{
typedef Complex&lt;T&gt; CComplex;
public:
	CPolynomial();
	CPolynomial(const int v0) { v.resize(1); v[0]=(T)v0; }
	CPolynomial(const double v0) { v.resize(1); v[0]=(T)v0; }
	CPolynomial(int m, const T* a);
	CPolynomial(const char* a);
	CPolynomial(const CPolynomial&lt;T&gt;&amp; a) : v(a.v) {}
	virtual ~CPolynomial();
	void Print() const;
	T Eval(T x, T* pd = NULL, int nd = 0) const;
	void Roots(CComplex* roots) const;
	void zroots(CComplex* a, int m, CComplex* roots, int polish) const;
	void laguer(CComplex* a, int m, CComplex* x, int *its) const;

public:
	vector&lt;T&gt; v;

	CPolynomial&lt;T&gt; operator+();
	CPolynomial&lt;T&gt; operator-();
	CPolynomial&lt;T&gt;&amp; operator=(const CPolynomial&lt;T&gt;&amp; a);
	CPolynomial&lt;T&gt;&amp; operator+=(const CPolynomial&lt;T&gt;&amp; a);
	CPolynomial&lt;T&gt;&amp; operator-=(const CPolynomial&lt;T&gt;&amp; a);
	CPolynomial&lt;T&gt;&amp; operator*=(const CPolynomial&lt;T&gt;&amp; a);
	CPolynomial&lt;T&gt;&amp; operator/=(const CPolynomial&lt;T&gt;&amp; a);

//	// Overload Operations
	//	//lvxg 添加
	//	CPolynomial operator + (CPolynomial&amp; cB);	
	//	CPolynomial operator - (CPolynomial&amp; cB);	
	//	CPolynomial&amp; operator += (CPolynomial&amp; cB);	
	//	CPolynomial&amp; operator -= (CPolynomial&amp; cB);
	//	CPolynomial&amp; operator = (CPolynomial&amp; cB);
	
//	CPolynomial&lt;T&gt; operator +(const CPolynomial&lt;T&gt; &amp; a);
//	CPolynomial&lt;T&gt; operator -(const CPolynomial&lt;T&gt; &amp; a);




	// GCC-2.95-2 did not allow friend operator overloading definition outside class declaration.
        friend CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B) {
                return poly_plus(A,B);
        }
        friend CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;T&gt;&amp; A, const double b) {
                return poly_plus(A,b);
        }
        friend CPolynomial&lt;T&gt; operator+(const double b, const CPolynomial&lt;T&gt;&amp; A) {
                return poly_plus(b,A);
        }
        friend CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B) {
                return poly_minus(A,B);
        }
        friend CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;T&gt;&amp; A, const double b) {
                return poly_minus(A,b);
        }
        friend CPolynomial&lt;T&gt; operator-(const double b, const CPolynomial&lt;T&gt;&amp; A) {
                return poly_minus(b,A);
        }
        friend CPolynomial&lt;T&gt; operator*(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B) {
                return poly_times(A,B);
        }
        friend CPolynomial&lt;T&gt; operator*(const CPolynomial&lt;T&gt;&amp; A, const double b) {
                return poly_times(A,b);
        }
        friend CPolynomial&lt;T&gt; operator*(const double b, const CPolynomial&lt;T&gt;&amp; A) {
                return poly_times(b,A);
        }
        friend CPolynomial&lt;T&gt; operator/(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B) {
                return poly_divide(A,B);
        }
        friend CPolynomial&lt;T&gt; operator/(const CPolynomial&lt;T&gt;&amp; A, const double b) {
                return poly_divide(A,b);
        }
        friend CPolynomial&lt;T&gt; operator/(const double b, const CPolynomial&lt;T&gt;&amp; A) {
                return poly_divide(b,A);
        }
        friend CPolynomial&lt;T&gt; operator%(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B) {
                return poly_modulo(A,B);
        }
        friend CPolynomial&lt;T&gt; operator%(const CPolynomial&lt;T&gt;&amp; A, const double b) {
                return poly_modulo(A,b);
        }
        friend CPolynomial&lt;T&gt; operator%(const double b, const CPolynomial&lt;T&gt;&amp; A) {
                return poly_modulo(b,A);
        }
/*

#if 0
        friend CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B) {
                return poly_plus(A,B);
        }
        friend CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B) {
                return poly_minus(A,B);
        }
        friend CPolynomial&lt;T&gt; operator*(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B) {
                return poly_times(A,B);
        }
        friend CPolynomial&lt;T&gt; operator/(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B) {
                return poly_divide(A,B);
        }
#endif
*/

#ifdef __GNUC__
        friend CPolynomial&lt;T&gt; poly_plus&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_plus&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_plus&lt;T&gt;(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_minus&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_minus&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_minus&lt;T&gt;(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_times&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_times&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_times&lt;T&gt;(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_divide&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_divide&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_divide&lt;T&gt;(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_modulo&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_modulo&lt;T&gt;(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_modulo&lt;T&gt;(const double b, const CPolynomial&lt;T&gt;&amp; A);
/*
#if 0
	friend CPolynomial&lt;T&gt; poly_plus&lt;T&gt;(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
	friend CPolynomial&lt;T&gt; poly_minus&lt;T&gt;(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
	friend CPolynomial&lt;T&gt; poly_times&lt;T&gt;(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
	friend CPolynomial&lt;T&gt; poly_divide&lt;T&gt;(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
#endif
#else
	friend CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_plus(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_minus(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_times(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_divide(const double b, const CPolynomial&lt;T&gt;&amp; A);
        friend CPolynomial&lt;T&gt; poly_modulo(const CPolynomial&lt;T&gt;&amp; A, const CPolynomial&lt;T&gt;&amp; B);
        friend CPolynomial&lt;T&gt; poly_modulo(const CPolynomial&lt;T&gt;&amp; A, const double b);
        friend CPolynomial&lt;T&gt; poly_modulo(const double b, const CPolynomial&lt;T&gt;&amp; A);
#if 0
	friend CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
	friend CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
	friend CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
	friend CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; A, const CPolynomial&lt;Complex&lt;T&gt; &gt;&amp; B);
#endif
#endif

#if 0
	friend CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;T&gt;&amp; a, const double&amp; b);
	friend CPolynomial&lt;T&gt; operator+(const double&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;T&gt;&amp; a);
	friend CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;T&gt;&amp; a, const double&amp; b);
	friend CPolynomial&lt;T&gt; operator-(const double&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;T&gt;&amp; a);
	friend CPolynomial&lt;T&gt; operator*(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator*(const CPolynomial&lt;T&gt;&amp; a, const double&amp; b);
	friend CPolynomial&lt;T&gt; operator*(const double&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator/(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator/(const CPolynomial&lt;T&gt;&amp; a, const double&amp; b);
	friend CPolynomial&lt;T&gt; operator/(const double&amp; a, const CPolynomial&lt;T&gt;&amp; b);
	friend CPolynomial&lt;T&gt; operator%(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b);	
	friend CPolynomial&lt;T&gt; operator%(const CPolynomial&lt;T&gt;&amp; a, const double&amp; b);
	friend CPolynomial&lt;T&gt; operator%(const double&amp; a, const CPolynomial&lt;T&gt;&amp; b);*/

#endif

};

template&lt;typename T&gt;
inline void PolynomialDivision(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b, CPolynomial&lt;T&gt;&amp; q, CPolynomial&lt;T&gt;&amp; r)
{
	int an = a.v.size() - 1;
	int bn = a.v.size() - 1;
	int qn = ((an &gt;= bn) ? an-bn : 0);
	int rn = ((bn &gt;= 1) ? ((an &lt;bn-1) ? an : bn-1) : 0);
	q.v.resize(qn+1);
	r.v.resize(rn+1);

	int k,j;
	for(j=0;j&lt;=an;j++){
		r.v[j] = a.v[j];
		q.v[j] = 0;
	}
	for(k=an-bn;k&gt;=0;k--){
		q.v[k] = r.v[bn+k]/b.v[bn];
		for(j=bn+k-1;j&gt;=k;j--) r.v[j] -= q.v[k]*b.v[j-k];
	}
	for(j=bn;j&lt;=an;j++) r.v[j] = 0;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; c = a;
	c += b;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_plus(const CPolynomial&lt;T&gt;&amp; a, const double b)
{
	CPolynomial&lt;T&gt; c = a;
	c += CPolynomial&lt;T&gt;((T)b);
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_plus(const double a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; c((T)a);
	c += b;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; operator+(const CPolynomial&lt;T&gt;&amp; a)
{
	CPolynomial&lt;T&gt; c = a;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; c = a;
	c -= b;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_minus(const CPolynomial&lt;T&gt;&amp; a, const double b)
{
	CPolynomial&lt;T&gt; c = a;
	c -= CPolynomial&lt;T&gt;((T)b);
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_minus(const double a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; c((T)a);
	c -= b;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; operator-(const CPolynomial&lt;T&gt;&amp; a)
{
	CPolynomial&lt;T&gt; c = 0;
	c -= a;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; c = a;
	c *= b;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_times(const CPolynomial&lt;T&gt;&amp; a, const double b)
{
	CPolynomial&lt;T&gt; c = a;
	c *= CPolynomial&lt;T&gt;((T)b);
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_times(const double a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; c((T)a);
	c *= b;
	return c;
}

template&lt;typename T&gt;
inline CPolynomial&lt;T&gt; poly_divide(const CPolynomial&lt;T&gt;&amp; a, const CPolynomial&lt;T&gt;&amp; b)
{
	CPolynomial&lt;T&gt; q,r;
	PolynomialDivision(a,b,q,r);
	return q;
12 下一页
💿 文件大小 5 K
👤 上传用户 feigo156
📂 所属分类 VC书籍
🏷️ 相关标签

#语音 #特征提取 #程序
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -