bilin_transf.cpp
上传用户:jtjnyq9001
上传日期:2014-11-21
资源大小:3974k
文件大小:3k
源码类别:

3G开发

开发平台:

Visual C++

  1. //
  2. //  File = bilin_transf.cpp
  3. //                     
  4.  #include <stdlib.h> 
  5.  #include <iostream>
  6.  #include <fstream> 
  7.  #include "misdefs.h"
  8.  #include "typedefs.h" 
  9.  #include <complex>
  10.  #include "bilin_transf.h"
  11.  extern ofstream *DebugFile;
  12.  
  13. //====================================================
  14. //
  15. //----------------------------------------------------
  16. void BilinearTransf( DenormalizedPrototype* filt_proto,
  17.                      double big_t,
  18.                      double **a_ret,
  19.                      double **b_ret)
  20. {
  21.   int max_poles;
  22.   int j, m, n;
  23.   int max_coeff;
  24.   double little_h;
  25.   complex<double> *mu;
  26.   complex<double> alpha;
  27.   complex<double> beta;
  28.   complex<double> gamma;
  29.   complex<double> delta;
  30.   complex<double> eta;
  31.   complex<double> work;
  32.   complex<double> c2;
  33.   complex<double> *pole;
  34.   complex<double> *zero;
  35.   double *a, *b;
  36.   int num_poles, num_zeros;
  37.   double h0;
  38.   double adjust;
  39.   pole = filt_proto->GetPoles();
  40.   num_poles = filt_proto->GetNumPoles();
  41.   zero = filt_proto->GetZeros();
  42.   num_zeros = filt_proto->GetNumZeros();
  43.   h0 = filt_proto->GetHZero();
  44.   if(num_poles > num_zeros){
  45.     max_poles = num_poles;
  46.     }
  47.   else{
  48.     max_poles = num_zeros;
  49.     }
  50.   //-------------------------------------------
  51.   a = new double[max_poles+1];
  52.   *a_ret = a;
  53.   b = new double[max_poles+1];
  54.   *b_ret = b;
  55.   
  56.   mu = new std::complex<double>[max_poles+1];
  57.   
  58.   for(j=0; j<=max_poles; j++){
  59.     mu[j] = 0.0;
  60.     a[j] = 0.0;
  61.     b[j] = 0.0;
  62.     }
  63.   //------------------------------------------
  64.   little_h = 1.0;
  65.   work = 1.0;
  66.   c2 = 2.0;
  67.   adjust = 1.0;
  68.   for(n=0; n<num_poles; n++){
  69.     work = work * (c2 - (big_t * pole[n]));
  70.     little_h = little_h * big_t;
  71.     adjust *= 4.0;
  72.     }
  73.   adjust *= num_poles;
  74.   little_h = h0 * little_h / std::real(work);
  75.   //-------------------------------------------------
  76.   mu[0] = 1.0;
  77.   for( n=1; n<=max_poles; n++){
  78.     mu[n] = 0.0;
  79.     }
  80.   for( n=1; n<=num_poles; n++){
  81.     gamma = complex<double>( 2.0/big_t, 0.0) - pole[n-1];
  82.     delta = complex<double>( -2.0/big_t, 0.0) - pole[n-1];
  83.     eta = delta/gamma;
  84.     for( j=n; j>=1; j--){
  85.       mu[j] = gamma * mu[j] + (delta * mu[j-1]);
  86.       #ifdef DEBUG
  87.         *DebugFile << "mu[" << j << "] = " << mu[j] << endl;
  88.       #endif
  89.       }
  90.     mu[0] = gamma * mu[0];
  91.     #ifdef DEBUG
  92.       *DebugFile << "mu[0] = " << mu[0] << endl;
  93.     #endif
  94.     }
  95.   for( j=1; j<=num_poles; j++){
  96.     a[j] = -little_h * mu[j].real() / h0;
  97.     }
  98.   //--------------------------------------------
  99.   mu[0] = 1.0;
  100.   for( n=1; n<=max_poles; n++){
  101.     mu[n] = 0.0;
  102.     }
  103.   max_coeff = 0;
  104.   //--------------------------------------------
  105.   for(m=1; m<=(num_poles-num_zeros); m++){
  106.     max_coeff++;
  107.     for( j=max_coeff; j>=1; j--){
  108.       mu[j] = mu[j] + mu[j-1];
  109.       }
  110.     }
  111.   for( m=1; m<=num_zeros; m++){
  112.     max_coeff++;
  113.     alpha = complex<double>( 2.0/big_t, 0.0) - zero[m-1];
  114.     beta = complex<double>( -2.0/big_t, 0.0) - zero[m-1];
  115.     for( j=max_coeff; j>=1; j--){
  116.       mu[j] = alpha * mu[j] + (beta * mu[j-1]);
  117.       }
  118.     mu[0] = alpha * mu[0];
  119.     }
  120.   for(j=0; j<=max_coeff; j++){
  121.     b[j] = little_h * mu[j].real();
  122.     }
  123.   return;