_FIR1D(3F)_FIR1D(3F)NAME
SFIR1D, DFIR1D, CFIR1D, ZFIR1D - 1D Convolution in the time domain.
FORTRAN SPECIFICATION
subroutine SFIR1D( in_put, incinp, i0_inp, n_inp,
firfil, incfir, i0_fir, n_fir,
output, incout, i0_out, n_out,
alpha, beta )
integer incinp, i0_inp, n_inp,
incfir, i0_fir, n_fir
incout, i0_out, n_out
real in_put(*), firfil(*), output(*), alpha, beta
subroutine DFIR1D( in_put, incinp, i0_inp, n_inp,
firfil, incfir, i0_fir, n_fir,
output, incout, i0_out, n_out,
alpha, beta )
integer incinp, i0_inp, n_inp,
incfir, i0_fir, n_fir
incout, i0_out, n_out
double precision in_put(*), firfil(*), output(*), alpha, beta
subroutine CFIR1D( in_put, incinp, i0_inp, n_inp,
firfil, incfir, i0_fir, n_fir,
output, incout, i0_out, n_out,
alpha, beta )
integer incinp, i0_inp, n_inp,
incfir, i0_fir, n_fir
incout, i0_out, n_out
complex in_put(*), firfil(*), output(*), alpha, beta
subroutine ZFIR1D( in_put, incinp, i0_inp, n_inp,
firfil, incfir, i0_fir, n_fir,
output, incout, i0_out, n_out,
alpha, beta )
integer incinp, i0_inp, n_inp,
incfir, i0_fir, n_fir
incout, i0_out, n_out
double complex in_put(*), firfil(*), output(*), alpha, beta
C SPECIFICATION
#include <conv.h>
void sfir1d( 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 dfir1d( double *f, int incf, int if0, int nf,
double *g, int incg, int ig0, int ng,
double *h, int inch, int ih0, int nh,
Page 1
_FIR1D(3F)_FIR1D(3F)
double alpha, double beta)
void cfir1d( 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 zfir1d( 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)
DESCRIPTIONSFIR1D and DFIR1D compute a 1D convolution in the time domain :
O(j) = Sum[ I(i) * F(j-i) ]
USAGE
These modules compute the result of the convolution in the "output" range
padding with zeroes when needed. 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 (n_inp
+ n_fir - 1) non zero samples starting at time (i0_inp + i0_fir). We just
compute here the values that fall in that range and zero the rest. This
may be interesting, for example when filtering a sequence of N samples,
with a symmetric filter of 2m+1 samples. If one wants only to compute the
central N resulting samples, the following call can be used:
call _fir1d( f, 0, 1, N, g, -m, 1, 2*m+1, h, 0, 1, N)
PARAMETERS
in_put Pointer to FIRST sample of sequence "in_put"
incinp Increment between two successive values of "in_put"
i0_inp Index of the first element of "in_put"
n_inp Number of samples of "in_put"
firfil Pointer to FIRST sample of sequence "firfil"
Page 2
_FIR1D(3F)_FIR1D(3F)
incfir Increment between two successive values of "firfil"
i0_fir Index of the first element of "firfil"
i0_fir Number of samples of "firfil"
output Pointer to FIRST sample of sequence "output"
incout Increment between two successive values of "output"
i0_out Index of the first 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 first element of the
array "i0_inp", "i0_fir" and "i0_out". If "in_put" for example
is defined as
dimension in_put(-25:45)
Then "dfir1d" must be called with the following parameters
call dfir1d( in_put(-25),1,-25,45, ... )
AUTHORS
Jean-Pierre Panziera, 1/12/93.
Page 3