sftrans                package:signal                R Documentation

_T_r_a_n_s_f_o_r_m _f_i_l_t_e_r _b_a_n_d _e_d_g_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     Transform band edges of a generic lowpass filter to a filter with
     different band edges and to other filter types (high pass, band
     pass, or band stop).

_U_s_a_g_e:

     ## Default S3 method:
     sftrans(Sz, Sp, Sg, W, stop = FALSE, ...)

     ## S3 method for class 'Arma':
     sftrans(Sz, W, stop = FALSE, ...)

     ## S3 method for class 'Zpg':
     sftrans(Sz, W, stop = FALSE, ...)

_A_r_g_u_m_e_n_t_s:

      Sz: In the generic case, a model to be transformed. In the
          default case, a vector containing the zeros in a
          pole-zero-gain model. 

      Sp: a vector containing the poles in a pole-zero-gain model. 

      Sg: a vector containing the gain in a pole-zero-gain model. 

       W: critical frequencies of the target filter specified in
          radians. 'W' must be a scalar for low-pass and high-pass
          filters, and 'W' must be a two-element vector 'c(low, high)'
          specifying the lower and upper bands. 

    stop: 'FALSE' for a low-pass or band-pass filter, 'TRUE' for a
          high-pass or band-stop filter. 

     ...: additional arguments (ignored). 

_D_e_t_a_i_l_s:

     Given a low pass filter represented by poles and zeros in the
     splane, you can convert it to a low pass, high pass, band pass or 
     band stop by transforming each of the poles and zeros
     individually. The following summarizes the transformations:

     Low-Pass Transform         

                             S -> C S/Fc


       Zero at x      Pole at x
       zero: F_c x/C  F_c x/C
       gain: C/F_c    F_c/C

     High-Pass Transform         

                             S -> C F_c/S


       Zero at x      Pole at x
       zero: F_c C/x  F_c C/x
       pole: 0        0
       gain: -x       -1/x

     Band-Pass Transform         

                 S -> C frac{S^2+F_hF_l}{S(F_h-F_l)}


       Zero at x                   Pole at x
       zero: b  sqrt(b^2-F_hF_l)  b  sqrt(b^2-F_hF_l)
       pole: 0                     0
       gain: C/(F_h-F_l)           (F_h-F_l)/C
       b = x/C (F_h-F_l)/2         b=x/C (F_h-F_l)/2

     Band-Stop Transform         

                 S -> C frac{S(F_h-F_l)}{S^2+F_hF_l}


       Zero at x                   Pole at x
       zero: b  sqrt(b^2-F_hF_l)  b  sqrt(b^2-F_hF_l)
       pole: sqrt(-F_hF_l)        sqrt(-F_hF_l)
       gain: -x                    -1/x
       b = C/x (F_h-F_l)/2         b=C/x (F_h-F_l)/2

     Bilinear Transform         

                    S -> frac{2}{T} frac{z-1}{z+1}


       Zero at x            Pole at x
       zero: (2+xT)/(2-xT)  (2+xT)/(2-xT)
       pole: -1             -1
       gain: (2-xT)/T       (2-xT)/T

     where C is the cutoff frequency of the initial lowpass filter, F_c
     is the edge of the target low/high pass filter and [F_l,F_h] are
     the edges of the target band pass/stop filter.  With abundant
     tedious algebra, you can derive the above formulae yourself by
     substituting the transform for S into H(S)=S-x for a zero at x or
     H(S)=1/(S-x) for a pole at x, and converting the result into the
     form:


             H(S) = g mbox{prod}(S-Xi) / mbox{prod}(S-Xj)


     Please note that a pole and a zero at the same place exactly
     cancel. This is significant for High Pass, Band Pass and Band Stop
     filters which create numerous extra poles and zeros, most of which
     cancel. Those which do not cancel have a `fill-in' effect,
     extending the  shorter of the sets to have the same number of as
     the longer of the sets of poles and zeros (or at least split the
     difference in the case of the band pass filter).  There may be
     other opportunistic cancellations, but it does not check for them.

     Also note that any pole on the unit circle or beyond will result
     in an unstable filter.  Because of cancellation, this will only
     happen if the number of poles is smaller than the number of zeros
     and the filter is high pass or band pass.  The analytic design
     methods all yield more poles than zeros, so this will not be a
     problem.

_V_a_l_u_e:

     For the default case or for 'sftrans.Zpg', an object of class
     "Zpg", containing the list elements: 

   zero : complex vector of the zeros of the transformed model

   pole : complex vector of the poles of the transformed model

   gain : gain of the transformed model

       b: moving average (MA) polynomial coefficients 

       a: autoregressive (AR) polynomial coefficients 

_A_u_t_h_o_r(_s):

     Original Octave version by Paul Kienzle pkienzle@users.sf.net.
     Conversion to R by Tom Short.

_R_e_f_e_r_e_n_c_e_s:

     Proakis & Manolakis (1992). Digital Signal Processing. New York:
     Macmillan Publishing Company.

     Octave Forge <URL: http://octave.sf.net>

_S_e_e _A_l_s_o:

     'Zpg', 'bilinear', 'Arma'

