FIR IIR 数字滤波器 C++实现

 FIR实现，已验证

class CFilter_FIR  
{
public:
	CFilter_FIR();
	virtual ~CFilter_FIR();
private:
	double *m_pB;

	double *m_pdata_buf;

	int m_nB_order;

	int m_nFirIndex;
public:
	void reset();
	
	/*/*brief:注意：B数组为nB_order个
	*/
	*/
	void setPara(double B[], int nB_order);

	double filter(double data);
	void filter(double data[], int len);
	void filter(double data_in[], double data_out[], int len);

};

 cpp文件

CFilter_FIR::CFilter_FIR()
{
	m_pB = NULL;
	m_pdata_buf = NULL;
	m_nB_order = 0;

	m_nFirIndex = 0;
}

CFilter_FIR::~CFilter_FIR()
{
	if (m_pdata_buf)
	{
		delete m_pdata_buf;
		m_pdata_buf = NULL;
	}
	if (m_pB)
	{
		delete m_pB;
		m_pB = NULL;
	}
}
/** \brief 将滤波器的内部状态清零
 * \return
 */
void CFilter_FIR::reset()
{
    for(int i = 0; i < m_nB_order; i++)
    {
		m_pdata_buf[i] = 0.0;
    }
	m_nFirIndex = 0;
}

/** \brief 

 */  
void CFilter_FIR::setPara(double B[], int nB_order)
{
	m_nB_order = nB_order;

	if (m_pB)
	{
		delete m_pB;
	}
	if (m_pdata_buf)
	{
		delete m_pdata_buf;
	}

    m_pB = new double[nB_order ];
    m_pdata_buf = new double[nB_order ];

    for(int i = 0; i < nB_order; i++)
    {
        m_pB[i] = B[i];
        m_pdata_buf[i] = 0.0;
    }	
}


/** \brief 滤波函数
 * 
 * \param data 传入输入数据 
 * \return 滤波后的结果 
*/  
double CFilter_FIR::filter(double data)
{
	int k;
	double fOut = 0.0;
    
	int i = 0;
	m_pdata_buf[m_nFirIndex%m_nB_order] = data;
	fOut = 0.0f;
	
	for (i = 0; i < m_nB_order; ++i)
	{
		fOut += m_pdata_buf[(m_nFirIndex +i+1)%m_nB_order]*m_pB[i];
	}
	
	m_nFirIndex++;
	return fOut;
}


/** \brief 滤波函数
 * 
 * \param data[] 传入输入数据，返回时给出滤波后的结果 
 * \param len data[] 数组的长度 
 * \return 
 */   
void CFilter_FIR::filter(double data[], int len)
{
   int k;
   double fOut = 0.0;
    for(k = 0; k < len; k++)
    {
		int i = 0;
		m_pdata_buf[m_nFirIndex%m_nB_order] = data[k];
		fOut = 0.0f;
		
		for (i = 0; i < m_nB_order; ++i)
		{
			fOut += m_pdata_buf[(m_nFirIndex +i+1)%m_nB_order]*m_pB[i];
		}
		m_nFirIndex++;

		data[k] = fOut;
    
	}
}
/** \brief 滤波函数
* 
* \param data_in[] 输入数据 
* \param data_out[] 保存滤波后的数据 
* \param len 数组的长度 
* \return 
*/  
void CFilter_FIR::filter(double data_in[], double data_out[], int len)
{
    int k;
    for(k = 0; k < len; k++)
    {
		int i = 0;
		m_pdata_buf[m_nFirIndex%m_nB_order] = data_in[k];
		data_out[k] = 0.0f;
		
		for (i = 0; i < m_nB_order; ++i)
		{
			data_out[k] += m_pdata_buf[(m_nFirIndex +i+1)%m_nB_order]*m_pB[i];
		}
		m_nFirIndex++;
    }
}

 IIR实现，验证过的

class CFilter_IIR_I  
{
public:
	CFilter_IIR_I();
	virtual ~CFilter_IIR_I();
	
private:
	double *m_pNum;
	double *m_pDen;
	double *m_px;
	double *m_py;
	int m_num_order;
	int m_den_order;
public:
	void reset();
	
	/*brief:注意：num数组为num_order个，den数组为den_order个
	*/
	void setPara(double num[], int num_order, double den[], int den_order);

	void resp(double data_in[], int m, double data_out[], int n);
	double filter(double data);
	void filter(double data[], int len);
	void filter(double data_in[], double data_out[], int len);
	
};

cpp文件

CFilter_IIR_I::CFilter_IIR_I()
{
    m_pNum = NULL;
    m_pDen = NULL;
    m_px = NULL;
    m_py = NULL;
    m_num_order = -1;
    m_den_order = -1;
}

CFilter_IIR_I::~CFilter_IIR_I()
{

}
/** \brief 将滤波器的内部状态清零，滤波器的系数保留 
 * \return
 */
void CFilter_IIR_I::reset()
{
    for(int i = 0; i < m_num_order; i++)
    {
        m_pNum[i] = 0.0;
    }
    for(i = 0; i < m_den_order; i++)
    {
        m_pDen[i] = 0.0;
    }
}

/** \brief 
 * 
 * \param num 分子多项式的系数，升序排列,num[0] 为常数项 
 * \param m 分子多项式的阶数 
 * \param den 分母多项式的系数，升序排列,den[0] 为常数项 
 * \param m 分母多项式的阶数 
 * \return 
 */   
void CFilter_IIR_I::setPara(double num[], int num_order, double den[], int den_order)
{
    delete[] m_pNum;
    delete[] m_pDen;
    delete[] m_px;
    delete[] m_py;
    m_pNum = new double[num_order ];
    m_pDen = new double[den_order ];
    m_num_order = num_order;
    m_den_order = den_order;
    m_px = new double[num_order ];
    m_py = new double[den_order ];
    for(int i = 0; i < m_num_order; i++)
    {
        m_pNum[i] = num[i];
        m_px[i] = 0.0;
    }
    for(i = 0; i < m_den_order; i++)
    {
        m_pDen[i] = den[i];
        m_py[i] = 0.0;
    }
}

/** \brief 滤波函数，采用直接I型结构 
 * 
 * \param data 传入输入数据 
 * \return 滤波后的结果 
 */   
double CFilter_IIR_I::filter(double data)
{
    m_py[0] = 0.0; // ????????
    m_px[0] = data;
    for(int i = 0; i < m_num_order; i++)
    {
        m_py[0] = m_py[0] + m_pNum[i] * m_px[i];
    }
    for(i = 1; i < m_den_order; i++)
    {
        m_py[0] = m_py[0] - m_pDen[i] * m_py[i];
    }
    for(i = m_num_order-1; i >= 1; i--)
    {
        m_px[i] = m_px[i-1];
    }
    for(i = m_den_order-1; i >= 1; i--)
    {
        m_py[i] = m_py[i-1];
    }
    return m_py[0];
}


/** \brief 滤波函数，采用直接I型结构 
 * 
 * \param data[] 传入输入数据，返回时给出滤波后的结果 
 * \param len data[] 数组的长度 
 * \return 
 */    
void CFilter_IIR_I::filter(double data[], int len)
{
    int i, k;
    for(k = 0; k < len; k++)
    {
        m_px[0] = data[k];
        data[k] = 0.0;
        for(i = 0; i < m_num_order; i++)
        {
            data[k] = data[k] + m_pNum[i] * m_px[i];
        }
        for(i = 1; i < m_den_order; i++)
        {
            data[k] = data[k] - m_pDen[i] * m_py[i];
        }
        // we get the y value now
        m_py[0] = data[k];
        for(i = m_num_order-1; i >= 1; i--)
        {
            m_px[i] = m_px[i-1];
        }
        for(i = m_den_order-1; i >= 1; i--)
        {
            m_py[i] = m_py[i-1];
        }
    }
}
/** \brief 滤波函数，采用直接I型结构 
 * 
 * \param data_in[] 输入数据 
 * \param data_out[] 保存滤波后的数据 
 * \param len 数组的长度 
 * \return 
 */  
void CFilter_IIR_I::filter(double data_in[], double data_out[], int len)
{
    int i, k;
    for(k = 0; k < len; k++)
    {
        m_px[0] = data_in[k];
        m_py[0] = 0.0;
        for(i = 0; i < m_num_order; i++)
        {
            m_py[0] += m_pNum[i] * m_px[i];
        }
        for(i = 1; i < m_den_order; i++)
        {
            m_py[0] -= m_pDen[i] * m_py[i];
        }
        for(i = m_num_order-1; i >= 1; i--)
        {
            m_px[i] = m_px[i-1];
        }
        for(i = m_den_order-1; i >= 1; i--)
        {
            m_py[i] = m_py[i-1];
        }
        data_out[k] = m_py[0];
    }
}
/** \brief 计算 IIR 滤波器的时域响应，不影响滤波器的内部状态 
 * \param data_in 为滤波器的输入，0 时刻之前的输入默认为 0，data_in[M] 及之后的输入默认为data_in[M-1] 
 * \param data_out 滤波器的输出 
 * \param M 输入数据的长度 
 * \param N 输出数据的长度 
 * \return 
 */ 
void CFilter_IIR_I::resp(double data_in[], int M, double data_out[], int N)  
{  
    int i, k, il;  
    for(k = 0; k < N; k++)  
    {  
        data_out[k] = 0.0;  
        for(i = 0; i < m_num_order; i++)  
        {  
            if( k - i >= 0)  
            {  
                il = ((k - i) < M) ? (k - i) : (M - 1);  
                data_out[k] = data_out[k] + m_pNum[i] * data_in[il];  
            }  
        }  
        for(i = 1; i < m_den_order; i++)  
        {  
            if( k - i >= 0)  
            {  
                data_out[k] = data_out[k] - m_pDen[i] * data_out[k - i];  
            }  
        }  
    }  
}  

IIR参考http://blog.csdn.net/liyuanbhu/article/details/38849897#comments