iir1d(3F)

NAME
     SIIR1D, DIIR1D, CIIR1D, ZIIR1D - 1D recursive convolution in the time
     domain.

FORTRAN SPECIFICATION
     subroutine SIIR1D( in_put, incinp, i0_inp, n_inp,
                        iirfil, inciir, i0_iir, n_iir,
                        output, incout, i0_out, n_out,
                        alpha, beta )
     integer            incinp, i0_inp, n_inp,
                        inciir, i0_iir, n_iir
                        incout, i0_out, n_out
     real               in_put(*), iirfil(*), output(*), alpha, beta

     subroutine DIIR1D( in_put, incinp, i0_inp, n_inp,
                        iirfil, inciir, i0_iir, n_iir,
                        output, incout, i0_out, n_out,
                        alpha, beta )
     integer            incinp, i0_inp, n_inp,
                        inciir, i0_iir, n_iir
                        incout, i0_out, n_out
     double precision   in_put(*), iirfil(*), output(*), alpha, beta

     subroutine CIIR1D( in_put, incinp, i0_inp, n_inp,
                        iirfil, inciir, i0_iir, n_iir,
                        output, incout, i0_out, n_out,
                        alpha, beta )
     integer            incinp, i0_inp, n_inp,
                        inciir, i0_iir, n_iir
                        incout, i0_out, n_out
     complex            in_put(*), iirfil(*), output(*), alpha, beta

     subroutine ZIIR1D( in_put, incinp, i0_inp, n_inp,
                        iirfil, inciir, i0_iir, n_iir,
                        output, incout, i0_out, n_out,
                        alpha, beta )
     integer            incinp, i0_inp, n_inp,
                        inciir, i0_iir, n_iir
                        incout, i0_out, n_out
     double complex     in_put(*), iirfil(*), output(*), alpha, beta


C SPECIFICATION
     #include <conv.h>

     void siir1d(    float *f, int incf, int if0, int nf,
                     float *g, int incg, int ig0, int ng,
                     float *h, int inch, int ih0, int nh,
                     float alpha, float beta)

     void diir1d(    double *f, int incf, int if0, int nf,
                     double *g, int incg, int ig0, int ng,
                     double *h, int inch, int ih0, int nh,
                     double alpha, double beta)

     void ciir1d(    complex *f, int incf, int if0, int nf,
                     complex *g, int incg, int ig0, int ng,
                     complex *h, int inch, int ih0, int nh,
                     complex *alpha, complex *beta)

     void ziir1d(    zomplex *f, int incf, int if0, int nf,
                     zomplex *g, int incg, int ig0, int ng,
                     zomplex *h, int inch, int ih0, int nh,
                     zomplex *alpha, zomplex *beta)



DESCRIPTION
     SIIR1D, DIIR1D CIIR1D and ZIIR1D compute a 1D convolution in the time
     domain :

       O(j) = (1/F(0)) * { I(j) - Sum[ O(i) * F(j-i) ] }, for i=1,...,(j-1)


USAGE
     These modules compute the result of the convolution in the "output" range
     padding with zeroes when needed.

     With some precautions it is possible that
               the Output sequence   OVERWRITE   the Input one.
     Then (if i0_out == i0_inp), it is necessary that   i0_iir =< 0 Said in
     DSP jargon: "iirfil" must be ANTI-CAUSAL

     In theory, an input sequence of "n_inp" samples starting at time
     "i0_inp", filtered by a sequence of "n_fir" samples starting at time
     "i0_fir", will result in a new signal of infinite length starting at time
     (i0_inp + i0_fir).  Here we just compute here the values that fall in
     that range and zero the rest.

     For example when filtering a sequence of N samples, with a filter of m
     samples. If one wants only to compute the first N resulting samples, the
     following call can be used:
         call diir1d( f, 0, 1, N,  g, 0, 1, m,  h, 0, 1, N)




PARAMETERS
     in_put  Pointer to IIRST sample of sequence "in_put"


     incinp  Increment between two successive values of "in_put"

     i0_inp  Index of the iirst element of "in_put"


     n_inp   Number of samples of "in_put"


     iirfil  Pointer to IIRST sample of sequence "iirfil"


     inciir  Increment between two successive values of "iirfil"


     i0_iir  Index of the iirst element of "iirfil"


     i0_iir  Number of samples of "iirfil"


     output  Pointer to IIRST sample of sequence "output"


     incout  Increment between two successive values of "output"


     i0_out  Index of the iirst element of "output"


     n_out   Number of samples of "output"


     alpha   Scaling factor for the convolution


     beta    Scaling factor for the Output on Entry


IMPORTANT NOTE:
           The array pointers must all point to the iirst element of the
           array "i0_inp", "i0_iir" and "i0_out". If "in_put" for example
           is defined as
                dimension in_put(-25:45)
           Then "diir1d" must be called with the following parameters
                call diir1d( in_put(-25),1,-25,45, ... )


AUTHORS
          Jean-Pierre Panziera, 1/12/93.