rtf                 package:cwhmath                 R Documentation

_R_a_t_i_o_n_a_l _T_r_a_n_s_f_e_r _F_u_n_c_t_i_o_n _o_b_j_e_c_t_s _f_o_r _R

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

     ??

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

     rtf(A = 1, B = 1, delay = 0, unit.sg = T, stability.check = T)
     rtf.filter(x, rtfobj, init)
     rtf.impulse(rtfobj, lag.max, plot.it=T,
                             nzero=2, type="h",
                             xlab="Lag", ylab="Impulse Response",...)
     rtf.step(rtfobj, lag.max, plot.it=T,
                          nzero=2, type="h",
                          xlab="Lag", ylab="Step Response", ylim,...)
     print.rtf(x,..., digits)
     plot.rtf(x,..., lag.max)

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

       A: See details

       B: See details

   delay: delay

 unit.sg: See details

stability.check: See details

       x: Filter (print.rtf), or (plot.rtf) rational transfer function
          object as created by rtf()

  rtfobj: rational transfer function object as created by rtf()

    init: If initialization is needed 'init' is supplied to the
          recursive filter (the first)

 lag.max: 

 plot.it: 

   nzero: 

    type: 

    xlab: 

    ylab: 

    ylim: 

  digits: for print

     ...: passed to rtf.impulse and rtf.step

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

     rtf:     Creates and checks a rational transfer-function object

     $y_t = H(q) x_t$, where $H(q) = q^-delay B(q^{-1}) / A(q^{-1})$

     If unit.sq is TRUE (default) the coefs. of $B(q^{-1})$ is
     multiplied with a factor making the stationary gain one.

     $A(q^{-1}) = 1   - a_1 q^{-1} - ... - a_{na} q^{-na}$ $B(q^{-1}) =
     b_0 + b_1 q^{-1} + ... + b_{nb} q^{-nb}$

     Note that '-' is used in A() and '+' in B(), these are specified
     as:

     $A = c(1,   a_1, .... , a_{na})$ $b = c(b_0, b_1, .... , b_{nb})$

     If stability.check is TRUE (default) the function will stop if any
     poles of A() is outside the unit circle.

     rtf.filter: Filter x using a rational transfer function object
     (rtfobj) as created by rtf(). If initialization is needed 'init'
     is supplied to the recursive filter (the first).

     Note that:

     * 'init' is multiplied with the stationary gain of the recursive
     filter before it is applied, i.e. replaced by init/A(1).

     * First the series is filtered trough $1/A(q^{-1})$, and the
     initialization is in terms of the output of this filter. 
     Furthermore, 'init' is used to calculate the first value of the
     filtered series, i.e. 'init' corresponds to times 0, -1, -2, ...

     * The causal convolution filter cannot return values for time <=
     length(B) - 1, since it do not use initialization.

     * Since the recursive filter is run first (an no missing i allowed
     in x) the bug in filter() when the series starts with NA will not
     become active.

     rtf.impulse: Impulse response of rtfobj (one like the one created
     by rtf()), i.e. the response on a unit impule corresponding to
     index 1 of the output.

     rtf.step: Step response of rtfobj (one like the one created by
     rtf()) i.e. the response on a unit step corresponding to index 1
     of the output.

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

     rtf: 

    call: Image of the call

  stable: Logical indicating if the transfer-function is stable

      sg: Stationary gain (only if stable is TRUE)

  n.init: Number of initial values needed

       A: A

       B: B

   delay: delay

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

     Henrik Aalborg Nielsen, IMM, DTU, han@imm.dtu.dk

_E_x_a_m_p_l_e_s:

