firm1d(3F)

NAME
     SFIRM1D, DFIRM1D, CFIRM1D, ZFIRM1D - N 1D convolutions in the time
     domain.

FORTRAN SPECIFICATION
     subroutine SFIRM1D( f, incf, ldf, ifx0, n_fx, ny,
                         g, incg,      igx0, n_gx,
                         h, inch, ldh, ihx0, n_hx,
                         alpha, beta )
     integer             incf, ldf, ifx0, n_fx, ny,
                         incg, igx0, n_gx,
                         inch, ldh, ihx0, n_hx
     real                f(ldf,ny), g(*), h(ldh,ny), alpha, beta

     subroutine DFIRM1D( f, incf, ldf, ifx0, n_fx, ny,
                         g, incg,      igx0, n_gx,
                         h, inch, ldh, ihx0, n_hx,
                         alpha, beta )
     integer             incf, ldf, ifx0, n_fx, ny,
                         incg, igx0, n_gx,
                         inch, ldh, ihx0, n_hx
     double precision    f(ldf,ny), g(*), h(ldh,ny), alpha, beta

     subroutine CFIRM1D( f, incf, ldf, ifx0, n_fx, ny,
                         g, incg,      igx0, n_gx,
                         h, inch, ldh, ihx0, n_hx,
                         alpha, beta )
     integer             incf, ldf, ifx0, n_fx, ny,
                         incg, igx0, n_gx,
                         inch, ldh, ihx0, n_hx
     complex             f(ldf,ny), g(*), h(ldh,ny), alpha, beta

     subroutine ZFIRM1D( f, incf, ldf, ifx0, n_fx, ny,
                         g, incg,      igx0, n_gx,
                         h, inch, ldh, ihx0, n_hx,
                         alpha, beta )
     integer             incf, ldf, ifx0, n_fx, ny,
                         incg, igx0, n_gx,
                         inch, ldh, ihx0, n_hx
     double complex      f(ldf,ny), g(*), h(ldh,ny), alpha, beta



C SPECIFICATION
     #include <conv.h>

     void sfirm1d( float *f, int incf, int lsf, int ifx0, int n_fx,
                  int n_seq,
                  float *g, int incg, int igx0, int n_gx,
                  float *h, int inch, int ldh, int ihx0, int n_hx,
                  float alpha, float beta)
     void dfirm1d( double *f, int incf, int ldf, int ifx0, int n_fx,
                  int n_seq,
                  double *g, int incg, int igx0, int n_gx,
                  double *h, int inch, int ldh, int ihx0, int n_hx,
                  double alpha, double beta)

     void cfirm1d( complex *f, int incf, int ldf, int ifx0, int n_fx,
                  int n_seq,
                  complex *g, int incg, int igx0, int n_gx,
                  complex *h, int inch, int ldh, int ihx0, int n_hx,
                  complex *alpha, complex *beta)

     void zfirm1d( zomplex *f, int incf, int ldf, int ifx0, int n_fx,
                  int n_seq,
                  zomplex *g, int incg, int igx0, int n_gx,
                  zomplex *h, int inch, int ldh, int ihx0, int n_hx,
                  zomplex *alpha,  zomplex *beta)



DESCRIPTION
     SFIRM1D, DFIRM1D, CFIRM1D and DFIRM1D compute N 1D convolutions in the
     time domain :

      h(i,j) = beta * h(i,j) + alpha * Sum[ f(k,j) * g(i-k) ] with j=1,...,N



USAGE:
     1. Suppose you want to:
           filter a 2D "image" f(0:449,0:699) along the first dimension ,
        by  a 1D filter g(-15:15),
           put the result in h(0:449,0:699),
        you can use:

           call dfirm1d( 700,f(0,0),1,449-0+1,0,449,g(-15),1,-15,15,1.0,
          $                      h(0,0),1,449-0+1,0,449,0.0)

     2. Suppose you want to:
           filter a 2D "image" f(0:449,0:699) along the Second dimension ,
        by  the Fisrt line of g(0:149,-15:15),
           put the result in h(-25:449,0:699),
        you can use:

                 call dfirm1d( 450,f(0,0),449-0+1,1,0,449,
          $                      g(0,-15),149-25+1,-15,15,1.0,
          $                      h(0,0),449-0+1,1,0,449,0.0)

PARAMETERS
     f       Vector containing sequence "f"

     incf    Increment between two successive values   of "f"

     ldf     Increment between two successive 1D sequnce of "f"

     ifx0    Index of the first element of each 1D sequence of "f"

     n_fx    Number of elements of each sequence of "f"

     ny      Number of 1D sequences to filter


     g       Vector containing the 1D sequence "g"

     incg    Increment between two successive values of "g"

     igx0    Index of the first element of each 1D sequence of "g"

     n_gx    Number of elements of Each sequence of "g"


     h       Vector containing the 2D sequence "h"

     inch    Increment between two successive values of "h"

     ldh     Increment between two successive 1D sequnce of "h"

     ihx0    Index of the first element of each 1D sequence of "h"

     n_hx    Number of elements of Each sequence of "h"


     alpha   Scaling factor for the original values of the "h" sequence

     beta    Scaling factor for the convolution



IMPORTANT NOTE:
           The array pointers must all point to the first element of the
           array "(ifx0,ify0)", "(igx0,igy0)" and "(ihx0,ihy0)". If "f"
           for example is defined as
                dimension f(-25:45,10:21)
           Then "dfirm1d" must be called with the following parameters
                call dfirm1d( f(-25,10),(45-(-25)+1),-25,45,10,21 ... )

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