GNU Radio Manual and C++ API Reference 3.7.14.0
The Free & Open Software Radio Ecosystem
fir_filter.h
Go to the documentation of this file.
1/* -*- c++ -*- */
2/*
3 * Copyright 2004,2010,2012 Free Software Foundation, Inc.
4 *
5 * This file is part of GNU Radio
6 *
7 * GNU Radio is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3, or (at your option)
10 * any later version.
11 *
12 * GNU Radio is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with GNU Radio; see the file COPYING. If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street,
20 * Boston, MA 02110-1301, USA.
21 */
22
23#ifndef INCLUDED_FILTER_FIR_FILTER_H
24#define INCLUDED_FILTER_FIR_FILTER_H
25
26#include <gnuradio/filter/api.h>
27#include <gnuradio/gr_complex.h>
28#include <vector>
29
30namespace gr {
31namespace filter {
32namespace kernel {
33
35{
36public:
37 fir_filter_fff(int decimation, const std::vector<float>& taps);
39
40 void set_taps(const std::vector<float>& taps);
41 void update_tap(float t, unsigned int index);
42 std::vector<float> taps() const;
43 unsigned int ntaps() const;
44
45 float filter(const float input[]);
46 void filterN(float output[], const float input[], unsigned long n);
47 void filterNdec(float output[],
48 const float input[],
49 unsigned long n,
50 unsigned int decimate);
51
52protected:
53 std::vector<float> d_taps;
54 unsigned int d_ntaps;
56 float* d_output;
59};
60
61/**************************************************************/
62
64{
65public:
66 fir_filter_ccf(int decimation, const std::vector<float>& taps);
68
69 void set_taps(const std::vector<float>& taps);
70 void update_tap(float t, unsigned int index);
71 std::vector<float> taps() const;
72 unsigned int ntaps() const;
73
75 void filterN(gr_complex output[], const gr_complex input[], unsigned long n);
76 void filterNdec(gr_complex output[],
77 const gr_complex input[],
78 unsigned long n,
79 unsigned int decimate);
80
81protected:
82 std::vector<float> d_taps;
83 unsigned int d_ntaps;
88};
89
90/**************************************************************/
91
93{
94public:
95 fir_filter_fcc(int decimation, const std::vector<gr_complex>& taps);
97
98 void set_taps(const std::vector<gr_complex>& taps);
99 void update_tap(gr_complex t, unsigned int index);
100 std::vector<gr_complex> taps() const;
101 unsigned int ntaps() const;
102
103 gr_complex filter(const float input[]);
104 void filterN(gr_complex output[], const float input[], unsigned long n);
105 void filterNdec(gr_complex output[],
106 const float input[],
107 unsigned long n,
108 unsigned int decimate);
109
110protected:
111 std::vector<gr_complex> d_taps;
112 unsigned int d_ntaps;
117};
118
119/**************************************************************/
120
122{
123public:
124 fir_filter_ccc(int decimation, const std::vector<gr_complex>& taps);
126
127 void set_taps(const std::vector<gr_complex>& taps);
128 void update_tap(gr_complex t, unsigned int index);
129 std::vector<gr_complex> taps() const;
130 unsigned int ntaps() const;
131
133 void filterN(gr_complex output[], const gr_complex input[], unsigned long n);
134 void filterNdec(gr_complex output[],
135 const gr_complex input[],
136 unsigned long n,
137 unsigned int decimate);
138
139protected:
140 std::vector<gr_complex> d_taps;
141 unsigned int d_ntaps;
146};
147
148/**************************************************************/
149
151{
152public:
153 fir_filter_scc(int decimation, const std::vector<gr_complex>& taps);
155
156 void set_taps(const std::vector<gr_complex>& taps);
157 void update_tap(gr_complex t, unsigned int index);
158 std::vector<gr_complex> taps() const;
159 unsigned int ntaps() const;
160
161 gr_complex filter(const short input[]);
162 void filterN(gr_complex output[], const short input[], unsigned long n);
163 void filterNdec(gr_complex output[],
164 const short input[],
165 unsigned long n,
166 unsigned int decimate);
167
168protected:
169 std::vector<gr_complex> d_taps;
170 unsigned int d_ntaps;
175};
176
177/**************************************************************/
178
180{
181public:
182 fir_filter_fsf(int decimation, const std::vector<float>& taps);
184
185 void set_taps(const std::vector<float>& taps);
186 void update_tap(float t, unsigned int index);
187 std::vector<float> taps() const;
188 unsigned int ntaps() const;
189
190 short filter(const float input[]);
191 void filterN(short output[], const float input[], unsigned long n);
192 void filterNdec(short output[],
193 const float input[],
194 unsigned long n,
195 unsigned int decimate);
196
197protected:
198 std::vector<float> d_taps;
199 unsigned int d_ntaps;
201 short* d_output;
204};
205
206} /* namespace kernel */
207} /* namespace filter */
208} /* namespace gr */
209
210#endif /* INCLUDED_FILTER_FIR_FILTER_H */
Definition: fir_filter.h:122
unsigned int d_ntaps
Definition: fir_filter.h:141
void update_tap(gr_complex t, unsigned int index)
void filterN(gr_complex output[], const gr_complex input[], unsigned long n)
void set_taps(const std::vector< gr_complex > &taps)
void filterNdec(gr_complex output[], const gr_complex input[], unsigned long n, unsigned int decimate)
gr_complex filter(const gr_complex input[])
gr_complex * d_output
Definition: fir_filter.h:143
std::vector< gr_complex > d_taps
Definition: fir_filter.h:140
fir_filter_ccc(int decimation, const std::vector< gr_complex > &taps)
gr_complex ** d_aligned_taps
Definition: fir_filter.h:142
std::vector< gr_complex > taps() const
int d_align
Definition: fir_filter.h:144
int d_naligned
Definition: fir_filter.h:145
Definition: fir_filter.h:64
void filterN(gr_complex output[], const gr_complex input[], unsigned long n)
unsigned int d_ntaps
Definition: fir_filter.h:83
void set_taps(const std::vector< float > &taps)
gr_complex * d_output
Definition: fir_filter.h:85
fir_filter_ccf(int decimation, const std::vector< float > &taps)
int d_naligned
Definition: fir_filter.h:87
std::vector< float > taps() const
int d_align
Definition: fir_filter.h:86
void update_tap(float t, unsigned int index)
gr_complex filter(const gr_complex input[])
void filterNdec(gr_complex output[], const gr_complex input[], unsigned long n, unsigned int decimate)
std::vector< float > d_taps
Definition: fir_filter.h:82
float ** d_aligned_taps
Definition: fir_filter.h:84
Definition: fir_filter.h:93
std::vector< gr_complex > taps() const
void update_tap(gr_complex t, unsigned int index)
void filterN(gr_complex output[], const float input[], unsigned long n)
gr_complex filter(const float input[])
fir_filter_fcc(int decimation, const std::vector< gr_complex > &taps)
unsigned int d_ntaps
Definition: fir_filter.h:112
int d_align
Definition: fir_filter.h:115
void filterNdec(gr_complex output[], const float input[], unsigned long n, unsigned int decimate)
int d_naligned
Definition: fir_filter.h:116
void set_taps(const std::vector< gr_complex > &taps)
gr_complex ** d_aligned_taps
Definition: fir_filter.h:113
std::vector< gr_complex > d_taps
Definition: fir_filter.h:111
gr_complex * d_output
Definition: fir_filter.h:114
Definition: fir_filter.h:35
fir_filter_fff(int decimation, const std::vector< float > &taps)
int d_naligned
Definition: fir_filter.h:58
void set_taps(const std::vector< float > &taps)
float filter(const float input[])
int d_align
Definition: fir_filter.h:57
std::vector< float > taps() const
std::vector< float > d_taps
Definition: fir_filter.h:53
float ** d_aligned_taps
Definition: fir_filter.h:55
void update_tap(float t, unsigned int index)
float * d_output
Definition: fir_filter.h:56
void filterNdec(float output[], const float input[], unsigned long n, unsigned int decimate)
void filterN(float output[], const float input[], unsigned long n)
unsigned int d_ntaps
Definition: fir_filter.h:54
Definition: fir_filter.h:180
fir_filter_fsf(int decimation, const std::vector< float > &taps)
int d_align
Definition: fir_filter.h:202
void filterN(short output[], const float input[], unsigned long n)
void set_taps(const std::vector< float > &taps)
void filterNdec(short output[], const float input[], unsigned long n, unsigned int decimate)
short filter(const float input[])
float ** d_aligned_taps
Definition: fir_filter.h:200
int d_naligned
Definition: fir_filter.h:203
short * d_output
Definition: fir_filter.h:201
unsigned int d_ntaps
Definition: fir_filter.h:199
std::vector< float > taps() const
std::vector< float > d_taps
Definition: fir_filter.h:198
void update_tap(float t, unsigned int index)
Definition: fir_filter.h:151
int d_align
Definition: fir_filter.h:173
void filterNdec(gr_complex output[], const short input[], unsigned long n, unsigned int decimate)
void filterN(gr_complex output[], const short input[], unsigned long n)
void update_tap(gr_complex t, unsigned int index)
fir_filter_scc(int decimation, const std::vector< gr_complex > &taps)
gr_complex * d_output
Definition: fir_filter.h:172
gr_complex filter(const short input[])
unsigned int d_ntaps
Definition: fir_filter.h:170
gr_complex ** d_aligned_taps
Definition: fir_filter.h:171
std::vector< gr_complex > taps() const
std::vector< gr_complex > d_taps
Definition: fir_filter.h:169
void set_taps(const std::vector< gr_complex > &taps)
int d_naligned
Definition: fir_filter.h:174
#define FILTER_API
Definition: gr-filter/include/gnuradio/filter/api.h:30
std::complex< float > gr_complex
Definition: gr_complex.h:27
static const float taps[NSTEPS+1][NTAPS]
Definition: interpolator_taps.h:9
Include this header to use the message passing features.
Definition: basic_block.h:45