11#ifndef INCLUDED_FILTER_FIR_FILTER_WITH_BUFFER_H 
   12#define INCLUDED_FILTER_FIR_FILTER_WITH_BUFFER_H 
   16#include <volk/volk_alloc.hh> 
   30    mutable volk::vector<float> d_output; 
 
   33    std::vector<float> d_taps;
 
   35    volk::vector<float> d_buffer_ptr;
 
   38    std::vector<volk::vector<float>> d_aligned_taps;
 
   79    float filter(
const float input[], 
unsigned long dec);
 
   87    void filterN(
float output[], 
const float input[], 
unsigned long n);
 
   99                    unsigned long decimate);
 
  106    unsigned int ntaps()
 const { 
return d_ntaps; }
 
  116    std::vector<float> 
taps() 
const;
 
 
  130    mutable volk::vector<gr_complex> d_output; 
 
  133    std::vector<gr_complex> d_taps;
 
  134    unsigned int d_ntaps;
 
  135    volk::vector<gr_complex> d_buffer_ptr;
 
  138    std::vector<volk::vector<gr_complex>> d_aligned_taps;
 
  199                    unsigned long decimate);
 
  206    unsigned int ntaps()
 const { 
return d_ntaps; }
 
  216    std::vector<gr_complex> 
taps() 
const;
 
 
  230    mutable volk::vector<gr_complex> d_output; 
 
  233    std::vector<float> d_taps;
 
  234    unsigned int d_ntaps;
 
  235    volk::vector<gr_complex> d_buffer_ptr;
 
  238    std::vector<volk::vector<float>> d_aligned_taps;
 
  299                    unsigned long decimate);
 
  306    unsigned int ntaps()
 const { 
return d_ntaps; }
 
  316    std::vector<float> 
taps() 
const;
 
 
fir_filter_with_buffer_ccc(const std::vector< gr_complex > &taps)
construct new FIR with given taps.
fir_filter_with_buffer_ccc & operator=(fir_filter_with_buffer_ccc &&)=default
gr_complex filter(const gr_complex input[], unsigned long dec)
compute a single output value; designed for decimating filters.
fir_filter_with_buffer_ccc(fir_filter_with_buffer_ccc &&)=default
std::vector< gr_complex > taps() const
fir_filter_with_buffer_ccc & operator=(const fir_filter_with_buffer_ccc &)=delete
void filterN(gr_complex output[], const gr_complex input[], unsigned long n)
compute an array of N output values.
void filterNdec(gr_complex output[], const gr_complex input[], unsigned long n, unsigned long decimate)
compute an array of N output values, decimating the input
unsigned int ntaps() const
Definition fir_filter_with_buffer.h:206
gr_complex filter(gr_complex input)
compute a single output value.
void set_taps(const std::vector< gr_complex > &taps)
install new_taps as the current taps.
fir_filter_with_buffer_ccc(const fir_filter_with_buffer_ccc &)=delete
gr_complex filter(const gr_complex input[], unsigned long dec)
compute a single output value; designed for decimating filters.
void filterNdec(gr_complex output[], const gr_complex input[], unsigned long n, unsigned long decimate)
compute an array of N output values, decimating the input
fir_filter_with_buffer_ccf & operator=(fir_filter_with_buffer_ccf &&)=default
fir_filter_with_buffer_ccf(const fir_filter_with_buffer_ccf &)=delete
fir_filter_with_buffer_ccf & operator=(const fir_filter_with_buffer_ccf &)=delete
void set_taps(const std::vector< float > &taps)
install new_taps as the current taps.
fir_filter_with_buffer_ccf(const std::vector< float > &taps)
construct new FIR with given taps.
unsigned int ntaps() const
Definition fir_filter_with_buffer.h:306
std::vector< float > taps() const
void filterN(gr_complex output[], const gr_complex input[], unsigned long n)
compute an array of N output values.
gr_complex filter(gr_complex input)
compute a single output value.
fir_filter_with_buffer_ccf(fir_filter_with_buffer_ccf &&)=default
void filterN(float output[], const float input[], unsigned long n)
compute an array of N output values.
unsigned int ntaps() const
Definition fir_filter_with_buffer.h:106
void filterNdec(float output[], const float input[], unsigned long n, unsigned long decimate)
compute an array of N output values, decimating the input
fir_filter_with_buffer_fff(const std::vector< float > &taps)
construct new FIR with given taps.
void set_taps(const std::vector< float > &taps)
install new_taps as the current taps.
fir_filter_with_buffer_fff & operator=(const fir_filter_with_buffer_fff &)=delete
fir_filter_with_buffer_fff(fir_filter_with_buffer_fff &&)=default
float filter(float input)
compute a single output value.
fir_filter_with_buffer_fff & operator=(fir_filter_with_buffer_fff &&)=default
fir_filter_with_buffer_fff(const fir_filter_with_buffer_fff &)=delete
std::vector< float > taps() const
float filter(const float input[], unsigned long dec)
compute a single output value; designed for decimating filters.
#define FILTER_API
Definition gr-filter/include/gnuradio/filter/api.h:18
std::complex< float > gr_complex
Definition gr_complex.h:15
Definition fft_filter.h:23
Definition dc_blocker_cc.h:18
GNU Radio logging wrapper.
Definition basic_block.h:29