paddlec 0.0.1

data/ext/paddlec/complex_buffer.h

@@ -0,0 +1,28 @@
+/* Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of PaddleC
+ * 
+ * PaddleC is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * PaddleC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PaddleC. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PADDLEC_COMPLEX_BUFFER_H
+#define PADDLEC_COMPLEX_BUFFER_H
+
+#include <ruby.h>
+#include "libpaddlec.h"
+
+void Init_paddlec_complex_buffer();
+pdlc_complex_buffer_t* paddlec_complex_buffer_get_struct(VALUE obj);
+
+#endif /* PADDLEC_COMPLEX_BUFFER_H */

data/ext/paddlec/delay.c

@@ -0,0 +1,214 @@
+/* Copyright (C) 2020 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of PaddleC
+ * 
+ * PaddleC is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * PaddleC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PaddleC. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <ruby.h>
+#include "libpaddlec.h"
+#include "paddlec.h"
+#include "float_buffer.h"
+#include "complex_buffer.h"
+
+/* Document-class: PaddleC::Delay
+ *
+ * A delay line. It can be used to balance delays brought by filters.
+ *
+ * To prevent incoherent data, 
+ * a given {PaddleC::Delay} object must be used exclusively with {PaddleC::FloatBuffer} and Float,
+ * or {PaddleC::ComplexBuffer} and Complex.
+ */
+
+
+VALUE c_Delay;
+
+
+static void paddlec_delay_free(void *p)
+{
+	pdlc_delay_t *del = (pdlc_delay_t*)p;
+	pdlc_delay_free(del);
+}
+
+
+static size_t paddlec_delay_size(const void* data)
+{
+	const pdlc_delay_t *del = (pdlc_delay_t*)data;
+	return pdlc_delay_size(del);
+}
+
+
+static const rb_data_type_t paddlec_delay_type = {
+	.wrap_struct_name = "paddlec_delay_struct",
+	.function = {
+		.dmark = NULL,
+		.dfree = paddlec_delay_free,
+		.dsize = paddlec_delay_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+
+static VALUE paddlec_delay_alloc(VALUE klass)
+{
+	VALUE obj;
+	pdlc_delay_t *del;
+
+	del = pdlc_delay_new(0);
+	obj = TypedData_Wrap_Struct(klass, &paddlec_delay_type, del);
+
+	return obj;
+}
+
+
+pdlc_delay_t* paddlec_delay_get_struct(VALUE obj)
+{
+	pdlc_delay_t *del;
+	TypedData_Get_Struct(obj, pdlc_delay_t, &paddlec_delay_type, del);
+	return del;
+}
+
+
+/* Return a new {PaddleC::Delay}.
+ * @param len [Integer] the number of samples the input will be delayed, must be strictly positive
+ * @return [PaddleC::Delay]
+ */
+static VALUE paddlec_delay_initialize(VALUE self, VALUE len)
+{
+	int dl;
+	pdlc_delay_t *del;
+
+	if (rb_class_of(len) != rb_cInteger)
+		rb_raise(rb_eTypeError, "expecting an integer, not a %"PRIsVALUE, rb_class_name(rb_class_of(len)));
+	dl = NUM2INT(len);
+	if (dl <= 0)
+		rb_raise(rb_eRangeError, "delay length must be strictly positive");
+
+	del = paddlec_delay_get_struct(self);
+	pdlc_delay_initialize(del, dl);
+
+	return self;
+}
+
+
+/* Reset the state of the delay line.
+ * @return [self]
+ */
+static VALUE paddlec_delay_reset(VALUE self)
+{
+	pdlc_delay_t *del = paddlec_delay_get_struct(self);
+	pdlc_delay_reset(del);
+	return self;
+}
+
+
+/* Return the length of the delay line.
+ * @return [Integer]
+ */
+static VALUE paddlec_delay_length(VALUE self)
+{
+	pdlc_delay_t *del = paddlec_delay_get_struct(self);
+	return UINT2NUM(del->delay);
+}
+
+
+/* Push new samples, pull delayed samples.
+ * If +outbuf+ is provided, it will receive the delayed data.
+ * @overload delay(float)
+ *  @param float [Float]
+ *  @return [Float]
+ * @overload delay(complex)
+ *  @param complex [Complex]
+ *  @return [Complex]
+ * @overload delay(fbuf, outbuf = nil)
+ *  @param fbuf [PaddleC::FloatBuffer]
+ *  @param outbuf [PaddleC::FloatBuffer, nil]
+ *  @return [PaddleC::FloatBuffer]
+ * @overload delay(cbuf, outbuf = nil)
+ *  @param cbuf [PaddleC::ComplexBuffer]
+ *  @param outbuf [PaddleC::ComplexBuffer, nil]
+ *  @return [PaddleC::ComplexBuffer]
+ */
+static VALUE paddlec_delay_delay(int argc, VALUE *argv, VALUE self)
+{
+	VALUE in, out;
+	pdlc_delay_t *del;
+	float flt;
+	pdlc_complex_t cmp;
+	const pdlc_buffer_t *ifbuf;
+	pdlc_buffer_t *ofbuf;
+	const pdlc_complex_buffer_t *icbuf;
+	pdlc_complex_buffer_t *ocbuf;
+
+	rb_scan_args(argc, argv, "11", &in, &out);
+
+	del = paddlec_delay_get_struct(self);
+
+	if (rb_class_of(in) == rb_cComplex) {
+		if (out != Qnil)
+			rb_raise(rb_eArgError, "outbuf argument is not used when a scalar is delayed");
+		cmp.real = (float)NUM2DBL(rb_funcallv(in, id_real, 0, NULL));
+		cmp.imag = (float)NUM2DBL(rb_funcallv(in, id_imag, 0, NULL));
+		cmp = pdlc_delay_delay_complex(del, cmp);
+		out = rb_complex_new(DBL2NUM((double)cmp.real), DBL2NUM((double)cmp.imag));
+	}
+	else if (rb_obj_is_kind_of(in, rb_cNumeric)) {
+		if (out != Qnil)
+			rb_raise(rb_eArgError, "outbuf argument is not used when a scalar is delayed");
+		flt = (float)NUM2DBL(in);
+		flt = pdlc_delay_delay_float(del, flt);
+		out = DBL2NUM((double)flt);
+	}
+	else if (rb_class_of(in) == c_FloatBuffer) {
+		if (out != Qnil) {
+			if (rb_class_of(out) != c_FloatBuffer)
+				rb_raise(rb_eTypeError, "outbuf must be the same type of buffer than the input");
+		}
+		else
+			out = rb_class_new_instance(0, NULL, c_FloatBuffer);
+		ifbuf = paddlec_float_buffer_get_struct(in);
+		ofbuf = paddlec_float_buffer_get_struct(out);
+		pdlc_delay_delay_float_buffer(del, ifbuf, ofbuf);
+	}
+	else if (rb_class_of(in) == c_ComplexBuffer) {
+		if (out != Qnil) {
+			if (rb_class_of(out) != c_ComplexBuffer)
+				rb_raise(rb_eTypeError, "outbuf must be the same type of buffer than the input");
+		}
+		else
+			out = rb_class_new_instance(0, NULL, c_ComplexBuffer);
+		icbuf = paddlec_complex_buffer_get_struct(in);
+		ocbuf = paddlec_complex_buffer_get_struct(out);
+		pdlc_delay_delay_complex_buffer(del, icbuf, ocbuf);
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a float, a complex, a %"PRIsVALUE" or a %"PRIsVALUE", not a %"PRIsVALUE,
+				rb_class_name(c_FloatBuffer), rb_class_name(c_ComplexBuffer), rb_class_name(rb_class_of(in)));
+
+	return out;
+}
+
+
+void Init_paddlec_delay()
+{
+	c_Delay = rb_define_class_under(m_PaddleC, "Delay", rb_cObject);
+	rb_define_alloc_func(c_Delay, paddlec_delay_alloc);
+	rb_define_method(c_Delay, "initialize",        paddlec_delay_initialize,         1);
+	rb_define_method(c_Delay, "lenght",            paddlec_delay_length,             0);
+	rb_define_method(c_Delay, "reset",             paddlec_delay_reset,              0);
+	rb_define_method(c_Delay, "delay",             paddlec_delay_delay,             -1);
+}
+
+

data/ext/paddlec/delay.h

@@ -0,0 +1,29 @@
+/* Copyright (C) 2020 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of PaddleC
+ * 
+ * PaddleC is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * PaddleC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PaddleC. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PADDLEC_DELAY_H
+#define PADDLEC_DELAY_H
+
+#include <ruby.h>
+#include "libpaddlec.h"
+
+void Init_paddlec_delay();
+pdlc_buffer_t* paddlec_delay_get_struct(VALUE obj);
+
+#endif /* PADDLEC_DELAY_H */
+

data/ext/paddlec/extconf.rb

@@ -0,0 +1,106 @@
+require 'mkmf'
+
+if have_library('pulse') and have_library('pulse-simple') then
+	$defs << '-DHAVE_PULSEAUDIO_L'
+else
+	warn "Cannot find pulseaudio library, you should do 'sudo apt install libpulse-dev' and install this gem again'"
+end
+
+if have_library('fftw3f') then
+	$defs << '-DHAVE_FFTW3F_L'
+else
+	warn "Cannot find fftw3f library, you should do 'sudo apt install libfftw3-dev libfftw3-single3' and install this gem again'"
+end
+
+if RUBY_PLATFORM =~ /linux/ then
+	cpuinfo = File.read '/proc/cpuinfo'
+	avx   = not(not(cpuinfo =~ /\savx/i))
+	sse   = not(not(cpuinfo =~ /\ssse/i))
+	neon  = not(not(cpuinfo =~ /\sneon/i))
+	vfpv4 = not(not(cpuinfo =~ /\svfpv4/i))
+else
+	avx   = false
+	sse   = false
+	neon  = false
+	vfpv4 = false
+end
+
+vflgs = ''
+if avx then
+	vflgs += ' -mavx'
+elsif sse then
+	vflgs += ' -msse'
+elsif neon then
+	vflgs += ' -mfpu=neon'
+	vflgs += '-vfpv4' if vfpv4
+elsif vfpv4 then
+	vflgs += ' -mfpu=vfpv4'
+end
+
+File.open(File.expand_path(File.join('..', '..', 'libpaddlec', 'Makefile'), __FILE__), 'w') do |m|
+	m.puts <<EOF
+
+CC = gcc
+CFLAGS += -W -Wall
+CFLAGS += -fPIC
+CFLAGS += -O3 -march=native -ffast-math#{vflgs}
+
+#SRC = $(wildcard *.c)
+SRC += libpaddlec.c
+SRC += fir_filter.c
+SRC += delay.c
+SRC += arithmetic.c
+SRC += math.c
+SRC += complex.c
+SRC += comparison.c
+SRC += rounding.c
+SRC += no_fast_math.c
+OBJS = $(SRC:.c=.o)
+
+all: libpaddlec.a libpaddlec.so
+
+libpaddlec.a: $(OBJS)
+	ar rcs $@ $^
+
+libpaddlec.so: $(OBJS)
+	$(CC) $(CFLAGS) -shared -o $@ $^ -lm
+
+fir_filter.o: fir_filter.c fir_filter_avx.c fir_filter_sse.c fir_filter_neon.c Makefile
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+no_fast_math.o: no_fast_math.c Makefile
+	$(CC) $(CFLAGS) -fno-fast-math -c -o $@ $<
+
+%.o: %.c Makefile
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	@rm -vf *.o
+	@rm -vf libpaddlec.a
+	@rm -vf libpaddlec.so
+
+.PHONY: clean
+
+EOF
+end
+
+libpaddlec_dir =  File.expand_path(File.join('..', '..', 'libpaddlec'), __FILE__)
+$CFLAGS += " -I #{libpaddlec_dir}"
+#$CFLAGS += ' -O3 -mtune=native -ffast-math'
+#$CFLAGS += " -O0 -g "
+
+libpaddlec_static = false
+if libpaddlec_static then
+	$LDFLAGS += " -L #{libpaddlec_dir}"
+	#$LOCAL_LIBS << ' -Wl,--whole-archive -lpaddlec -Wl,--no-whole-archive '
+	$LOCAL_LIBS << '-lpaddlec'
+	abort "Cannot make libpaddlec.a" unless system "cd #{libpaddlec_dir} && make clean && make libpaddlec.a"
+else
+	$LOCAL_LIBS += " -Wl,-rpath,#{libpaddlec_dir} -L#{libpaddlec_dir} -lpaddlec"
+	abort "Cannot make libpaddlec.so" unless system "cd #{libpaddlec_dir} && make clean && make libpaddlec.so"
+end
+
+create_header 'paddlec_defs.h'
+create_makefile 'paddlec/paddlec'
+
+

data/ext/paddlec/fir_filter.c

@@ -0,0 +1,892 @@
+/* Copyright (C) 2019 Théotime Bollengier <theotime.bollengier@gmail.com>
+ *
+ * This file is part of PaddleC
+ * 
+ * PaddleC is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * PaddleC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PaddleC. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <ruby.h>
+#include "libpaddlec.h"
+#include "paddlec.h"
+#include "fir_filter.h"
+#include "float_buffer.h"
+#include "complex_buffer.h"
+
+
+VALUE c_FirFilter;
+VALUE c_FirTransformer;
+VALUE c_FirDecimator;
+VALUE c_FirInterpolator;
+
+
+static void paddlec_fir_filter_free(void *p)
+{
+	pdlc_fir_filter_t *fir = (pdlc_fir_filter_t*)p;
+	pdlc_fir_filter_free(fir);
+}
+
+
+static size_t paddlec_fir_filter_size(const void* data)
+{
+	pdlc_fir_filter_t *fir = (pdlc_fir_filter_t*)data;
+	return pdlc_fir_filter_size(fir);
+}
+
+
+static const rb_data_type_t paddlec_fir_filter_type = {
+	.wrap_struct_name = "paddlec_fir_filter_struct",
+	.function = {
+		.dmark = NULL,
+		.dfree = paddlec_fir_filter_free,
+		.dsize = paddlec_fir_filter_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+
+static VALUE paddlec_fir_filter_alloc(VALUE klass)
+{
+	VALUE obj;
+	pdlc_fir_filter_t *fir;
+
+	fir = pdlc_fir_filter_new(-1);
+	obj = TypedData_Wrap_Struct(klass, &paddlec_fir_filter_type, fir);
+
+	return obj;
+}
+
+
+static inline pdlc_fir_filter_t* paddlec_fir_filter_get_struct(VALUE obj)
+{
+	pdlc_fir_filter_t *fir;
+	TypedData_Get_Struct(obj, pdlc_fir_filter_t, &paddlec_fir_filter_type, fir);
+	return fir;
+}
+
+
+/* @return [PaddleC::FirFilter]
+ * @overload initialize(n)
+ *  @param n [Integer] the filter order
+ *  @return [Paddlec::FirFilter]
+ * @overload initialize(b)
+ *  @param b [Array<Float>, PaddleC::FloatBuffer] the coefficients, as an array or a {FloatBuffer}
+ *  @return [Paddlec::FirFilter]
+ */
+static VALUE paddlec_fir_filter_initialize(VALUE self, VALUE b_or_n)
+{
+	pdlc_fir_filter_t *fir;
+	const pdlc_buffer_t *fbuf;
+	int order, i;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(b_or_n) == c_FloatBuffer) {
+		fbuf = paddlec_float_buffer_get_struct(b_or_n);
+		order = fbuf->length;
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_initialize(fir, order - 1);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, fbuf->data[i]);
+	}
+	else if (rb_class_of(b_or_n) == rb_cArray) {
+		order = rb_array_len(b_or_n);
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_initialize(fir, order - 1);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, (float)NUM2DBL(rb_ary_entry(b_or_n, i)));
+	}
+	else {
+		order = NUM2INT(b_or_n);
+		if (order < 0)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_initialize(fir, order);
+	}
+
+	return self;
+}
+
+
+/* Reset the filter state.
+ * @return [self]
+ */
+static VALUE paddlec_fir_filter_reset(VALUE self)
+{
+	pdlc_fir_filter_t *fir;
+
+	fir = paddlec_fir_filter_get_struct(self);
+	pdlc_fir_filter_reset(fir);
+
+	return self;
+}
+
+
+/* @return [Integer] the filter order
+ */
+static VALUE paddlec_fir_filter_order(VALUE self)
+{
+	const pdlc_fir_filter_t *fir;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	return INT2NUM((int)fir->nb_coefs - 1);
+}
+
+
+/* @return [Integer] number of coefficients (order + 1)
+ */
+static VALUE paddlec_fir_filter_nb_coefficients(VALUE self)
+{
+	const pdlc_fir_filter_t *fir;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	return INT2NUM((int)fir->nb_coefs);
+}
+
+
+/* Return a copy of the filter's numerator coefficients.
+ * @return [PaddleC::FloatBuffer] the filter coefficients
+ */
+static VALUE paddlec_fir_filter_coefficients(VALUE self)
+{
+	const pdlc_fir_filter_t *fir;
+	pdlc_buffer_t *fbuf;
+	VALUE res;
+	unsigned int i;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	res = UINT2NUM(fir->nb_coefs);
+	res = rb_class_new_instance(1, &res, c_FloatBuffer);
+	fbuf = paddlec_float_buffer_get_struct(res);
+
+	for (i = 0; i < fir->nb_coefs; i++)
+		pdlc_fir_filter_get_coef_at(fir, (int)i, fbuf->data + i);
+
+	return res;
+}
+
+
+/* Return a copy of the filter's denominator coefficients, allways [1].
+ * @return [PaddleC::FloatBuffer] the filter denominator coefficients
+ */
+static VALUE paddlec_fir_filter_denominator(VALUE self)
+{
+	pdlc_buffer_t *fbuf;
+	VALUE res;
+
+	res = UINT2NUM(1);
+	res = rb_class_new_instance(1, &res, c_FloatBuffer);
+	fbuf = paddlec_float_buffer_get_struct(res);
+
+	fbuf->data[0] = 1.0;
+
+	return res;
+}
+
+
+/* @param index [Integer] the coefficient index
+ * @return [Float] the coefficient at +index+
+ */
+static VALUE paddlec_fir_filter_get_coefficient_at(VALUE self, VALUE index)
+{
+	const pdlc_fir_filter_t *fir;
+	int ind;
+	float val;
+	VALUE res;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	ind = NUM2INT(index);
+	if (pdlc_fir_filter_get_coef_at(fir, ind, &val) == 0)
+		res = DBL2NUM((double)val);
+	else
+		res = DBL2NUM(0.0);
+
+	return res;
+}
+
+
+/* @param index [Integer] the coefficient index
+ * @param coef  [Float] the coefficient value
+ * @return [Float, nil] the coefficient if the index is valid, or +nil+ otherwise
+ */
+static VALUE paddlec_fir_filter_set_coefficient_at(VALUE self, VALUE index, VALUE coef)
+{
+	pdlc_fir_filter_t *fir;
+	int ind;
+	float val;
+	VALUE res = Qnil;
+
+	fir = paddlec_fir_filter_get_struct(self);
+	val = (float)NUM2DBL(coef);
+
+	ind = NUM2INT(index);
+	if (pdlc_fir_filter_set_coef_at(fir, ind, val) == 0)
+		res = DBL2NUM(val);
+
+	return res;
+}
+
+
+/* This method returns 1.0 if +index+ is 0, 0.0 otherwise. It is there to be compatible with {IirFilter}
+ * @param index [Integer] the denominator coefficient index
+ * @return [Float] the denominator coefficient at index
+ */
+static VALUE paddlec_fir_filter_get_denominator_at(VALUE self, VALUE index)
+{
+	int ind;
+	VALUE res;
+
+	ind = NUM2INT(index);
+	if (ind == 0)
+		res = DBL2NUM(1.0);
+	else
+		res = DBL2NUM(0.0);
+
+	return res;
+}
+
+
+/* This method does nothing, it is there to be compatible with {IirFilter}
+ * @param index [Integer] the coefficient index
+ * @param coef  [Float] the denominator coefficient value
+ * @return [Float, nil] the denominator coefficient if the index is valid, or nil otherwise
+ */
+static VALUE paddlec_fir_filter_set_denominator_at(VALUE self, VALUE index, VALUE coef)
+{
+	(void)self;
+	(void)index;
+	(void)coef;
+
+	return Qnil;
+}
+
+
+/* Filter a single sample, complex or real, or a {FloatBuffer} or {ComplexBuffer}.
+ * The returned element is of the same type as the input element.
+ *
+ * If complex samples are fed to the filter, float samples must not be fed before a {FirFilter#reset}.
+ *
+ * The keyword argument +buffer:+ can be used to provide the filter with an already allocated buffer for the output.
+ *
+ * The keyword argument +delayed:+ can be used to provide the filter with an already allocated buffer filled 
+ * with the input signal delayed by +order / 2+.
+ * If +delayed:+ is not +nil+, then the output is an array containing the filtered signal and the delayed signal.
+ *
+ * @overload filter(r_sample) 
+ *  @param r_sample [Float] a real input sample
+ *  @return [Float] a real processed sample
+ *
+ * @overload filter(c_sample) 
+ *  @param c_sample [Complex] a complex input sample
+ *  @return [Complex] a complex processed sample
+ *
+ * @overload filter(r_sample, delayed: true) 
+ *  @param r_sample [Float] a real input sample
+ *  @param delayed [Boolean, nil] whether to output the delayed sample or not
+ *  @return [Array<Float>] a two element array containing the processed sample and the delayed sample
+ *
+ * @overload filter(c_sample, delayed: true) 
+ *  @param c_sample [Complex] a complex input sample
+ *  @param delayed [Boolean, nil] whether to output the delayed sample or not
+ *  @return [Array<Complex>] a two element array containing the processed sample and the delayed sample
+ *
+ * @overload filter(float_buffer, buffer: obuf) 
+ *  @param float_buffer [PaddleC::FloatBuffer] a buffer of real input samples
+ *  @param buffer [PaddleC::FloatBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @return [PaddleC::FloatBuffer] a buffer of real processed samples
+ *
+ * @overload filter(complex_buffer, buffer: obuf) 
+ *  @param complex_buffer [PaddleC::ComplexBuffer] a buffer of complex input samples
+ *  @param buffer [PaddleC::ComplexBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @return [PaddleC::ComplexBuffer] a buffer of complex processed samples
+ *
+ * @overload filter(float_buffer, buffer: obuf, delayed: true) 
+ *  @param float_buffer [PaddleC::FloatBuffer] a buffer of real input samples
+ *  @param buffer [PaddleC::FloatBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @param delayed [PaddleC::FloatBuffer, Boolean, nil] a boolean or an already allocated buffer
+ *  @return [Array<PaddleC::FloatBuffer>] a two element array containing the processed samples and the delayed samples
+ *
+ * @overload filter(complex_buffer, buffer: obuf, delayed: true) 
+ *  @param complex_buffer [PaddleC::ComplexBuffer] a buffer of complex input samples
+ *  @param buffer [PaddleC::ComplexBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @param delayed [PaddleC::ComplexBuffer, Boolean, nil] a boolean or an already allocated buffer
+ *  @return [Array<PaddleC::ComplexBuffer>] a two element array containing the processed samples and the delayed samples
+ */
+static VALUE paddlec_fir_filter_filter(int argc, VALUE *argv, VALUE self)
+{
+	pdlc_fir_filter_t *fir;
+	VALUE rbSample, rbOptHash;
+	VALUE buffer_and_delayed[2] = {Qundef, Qundef};
+	const ID kwkeys[2] = {id_buffer, id_delayed};
+	VALUE obuf = Qnil, delayed = Qnil;
+	VALUE res = Qnil;
+	float delayed_float;
+	pdlc_complex_t delayed_complex;
+	float output_float;
+	pdlc_complex_t output_complex;
+	const pdlc_buffer_t *ifbuf;
+	const pdlc_complex_buffer_t *icbuf;
+	pdlc_buffer_t *ofbuf, *dfbuf;
+	pdlc_complex_buffer_t *ocbuf, *dcbuf;
+
+	rb_scan_args(argc, argv, "1:", &rbSample, &rbOptHash);
+
+	if (!NIL_P(rbOptHash))
+		rb_get_kwargs(rbOptHash, kwkeys, 0, 2, buffer_and_delayed);
+	if (buffer_and_delayed[0] != Qundef)
+		obuf = buffer_and_delayed[0];
+	if (buffer_and_delayed[1] != Qundef)
+		delayed = buffer_and_delayed[1];
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(rbSample) == c_FloatBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_FloatBuffer)
+			rb_raise(rb_eArgError, "only a FloatBuffer is valid for buffer when a FloatBuffer is provided to the filter");
+		if (delayed != Qtrue && delayed != Qnil && delayed != Qfalse && rb_class_of(obuf) != c_FloatBuffer)
+			rb_raise(rb_eArgError, "only true, false, nil and a FloatBuffer are valid values for delayed when a FloatBuffer is provided to the filter");
+		ifbuf = paddlec_float_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_FloatBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_FloatBuffer);
+		ofbuf = paddlec_float_buffer_get_struct(obuf);
+
+		if (delayed == Qnil || delayed == Qfalse) {
+			pdlc_fir_filter_filter_float_buffer(fir, ifbuf, ofbuf, NULL);
+			res = obuf;
+		}
+		else {
+			if (rb_class_of(delayed) != c_FloatBuffer)
+				delayed = rb_class_new_instance(0, NULL, c_FloatBuffer);
+			dfbuf = paddlec_float_buffer_get_struct(delayed);
+			pdlc_fir_filter_filter_float_buffer(fir, ifbuf, ofbuf, dfbuf);
+			res = rb_ary_new_capa(2);
+			rb_ary_store(res, 0, obuf);
+			rb_ary_store(res, 1, delayed);
+		}
+	}
+	else if (rb_class_of(rbSample) == c_ComplexBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_ComplexBuffer)
+			rb_raise(rb_eArgError, "only a ComplexBuffer is valid for buffer when a ComplexBuffer is provided to the filter");
+		if (delayed != Qtrue && delayed != Qnil && delayed != Qfalse && rb_class_of(obuf) != c_ComplexBuffer)
+			rb_raise(rb_eArgError, "only true, false, nil and a ComplexBuffer are valid values for delayed when a ComplexBuffer is provided to the filter");
+		icbuf = paddlec_complex_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_ComplexBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_ComplexBuffer);
+		ocbuf = paddlec_complex_buffer_get_struct(obuf);
+
+		if (delayed == Qnil || delayed == Qfalse) {
+			pdlc_fir_filter_filter_complex_buffer(fir, icbuf, ocbuf, NULL);
+			res = obuf;
+		}
+		else {
+			if (rb_class_of(delayed) != c_ComplexBuffer)
+				delayed = rb_class_new_instance(0, NULL, c_ComplexBuffer);
+			dcbuf = paddlec_complex_buffer_get_struct(delayed);
+			pdlc_fir_filter_filter_complex_buffer(fir, icbuf, ocbuf, dcbuf);
+			res = rb_ary_new_capa(2);
+			rb_ary_store(res, 0, obuf);
+			rb_ary_store(res, 1, delayed);
+		}
+	}
+	else {
+		if (!NIL_P(obuf))
+			rb_raise(rb_eArgError, "output buffer must not be provided when a single sample is given to the filter");
+		if (delayed != Qtrue && delayed != Qnil && delayed != Qfalse)
+			rb_raise(rb_eArgError, "only true, false and nil are valid values for delayed when a single sample is provided to the filter");
+		if (rb_class_of(rbSample) == rb_cComplex) {
+			output_complex.real = (float)NUM2DBL(rb_funcallv(rbSample, id_real, 0, NULL));
+			output_complex.imag = (float)NUM2DBL(rb_funcallv(rbSample, id_real, 0, NULL));
+			if (delayed == Qtrue) {
+				output_complex = pdlc_fir_filter_filter_complex(fir, output_complex, &delayed_complex);
+				res = rb_ary_new_capa(2);
+				rb_ary_store(res, 0, rb_complex_raw(DBL2NUM((double)output_complex.real), DBL2NUM((double)output_complex.imag)));
+				rb_ary_store(res, 1, rb_complex_raw(DBL2NUM((double)delayed_complex.real), DBL2NUM((double)delayed_complex.imag)));
+			}
+			else {
+				output_complex = pdlc_fir_filter_filter_complex(fir, output_complex, NULL);
+				res = rb_complex_raw(DBL2NUM((double)output_complex.real), DBL2NUM((double)output_complex.imag));
+			}
+		}
+		else {
+			if (delayed == Qtrue) {
+				output_float = pdlc_fir_filter_filter_float(fir, (float)NUM2DBL(rbSample), &delayed_float);
+				res = rb_ary_new_capa(2);
+				rb_ary_store(res, 0, DBL2NUM((double)output_float));
+				rb_ary_store(res, 1, DBL2NUM((double)delayed_float));
+			}
+			else {
+				output_float = pdlc_fir_filter_filter_float(fir, (float)NUM2DBL(rbSample), NULL);
+				res = DBL2NUM((double)output_float);
+			}
+		}
+	}
+
+	return res;
+}
+
+
+/* @return [PaddleC::FirInterpolator]
+ * @overload initialize(n, interpolation_factor)
+ *  @param n [Integer] the filter order
+ *  @param interpolation_factor [Integer] the interpolation factor (>= 1)
+ *  @return [PaddleC::FirInterpolator]
+ * @overload initialize(b, interpolation_factor)
+ *  @param interpolation_factor [Integer] the interpolation factor (>= 1)
+ *  @param b [Array<Float>, PaddleC::FloatBuffer] the coefficients, as an array or a {FloatBuffer}
+ *  @return [PaddleC::FirInterpolator]
+ */
+static VALUE paddlec_fir_filter_interpolator_initialize(VALUE self, VALUE b_or_n, VALUE factor)
+{
+	pdlc_fir_filter_t *fir;
+	const pdlc_buffer_t *fbuf;
+	int order, i, ifactor;
+
+	ifactor = NUM2INT(factor);
+	if (ifactor < 1)
+		rb_raise(rb_eRangeError, "Interpolation factor cannot be less than one");
+	if (ifactor > 32)
+		rb_raise(rb_eRangeError, "Interpolation factor greater than 32 is too much");
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(b_or_n) == c_FloatBuffer) {
+		fbuf = paddlec_float_buffer_get_struct(b_or_n);
+		order = fbuf->length;
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_interpolator_initialize(fir, order - 1, ifactor);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, fbuf->data[i]);
+	}
+	else if (rb_class_of(b_or_n) == rb_cArray) {
+		order = rb_array_len(b_or_n);
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_interpolator_initialize(fir, order - 1, ifactor);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, (float)NUM2DBL(rb_ary_entry(b_or_n, i)));
+	}
+	else {
+		order = NUM2INT(b_or_n);
+		if (order < 0)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_interpolator_initialize(fir, order, ifactor);
+	}
+
+	return self;
+}
+
+
+/* @return [Integer] the interpolation factor
+ */
+static VALUE paddlec_fir_filter_interpolator_interpolation_factor(VALUE self)
+{
+	const pdlc_fir_filter_t *fir;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	return INT2NUM(pdlc_fir_filter_get_factor(fir));
+}
+
+
+/* Interpolate a {FloatBuffer} or {ComplexBuffer}.
+ * The returned element is of the same type as the input element.
+ *
+ * If complex samples are fed to the interpolator, float samples must not be fed before a {FirFilter#reset}.
+ *
+ * The keyword argument +buffer:+ can be used to provide the interpolator with an already allocated buffer for the output.
+ *
+ * @overload interpolate(float_buffer, buffer: obuf) 
+ *  @param float_buffer [PaddleC::FloatBuffer] a buffer of real input samples
+ *  @param buffer [PaddleC::FloatBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @return [PaddleC::FloatBuffer] a buffer of real processed samples of size +float_buffer.length * #interpolation_factor+
+ *
+ * @overload interpolate(complex_buffer, buffer: obuf) 
+ *  @param complex_buffer [PaddleC::ComplexBuffer] a buffer of complex input samples
+ *  @param buffer [PaddleC::ComplexBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @return [PaddleC::ComplexBuffer] a buffer of complex processed samples of size +complex_buffer.length * #interpolation_factor+
+ */
+static VALUE paddlec_fir_filter_interpolator_interpolate(int argc, VALUE *argv, VALUE self)
+{
+	pdlc_fir_filter_t *fir;
+	VALUE rbSample, rbOptHash;
+	VALUE buffer_hash[2] = {Qundef};
+	const ID kwkeys[2] = {id_buffer};
+	VALUE obuf = Qnil;
+	VALUE res = Qnil;
+	const pdlc_buffer_t *ifbuf;
+	const pdlc_complex_buffer_t *icbuf;
+	pdlc_buffer_t *ofbuf;
+	pdlc_complex_buffer_t *ocbuf;
+
+	rb_scan_args(argc, argv, "1:", &rbSample, &rbOptHash);
+
+	if (!NIL_P(rbOptHash))
+		rb_get_kwargs(rbOptHash, kwkeys, 0, 1, buffer_hash);
+	if (buffer_hash[0] != Qundef)
+		obuf = buffer_hash[0];
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(rbSample) == c_FloatBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_FloatBuffer)
+			rb_raise(rb_eArgError, "only a %"PRIsVALUE" is valid for buffer when a %"PRIsVALUE" is provided to the Interpolator", rb_class_name(c_FloatBuffer), rb_class_name(c_FloatBuffer));
+		ifbuf = paddlec_float_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_FloatBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_FloatBuffer);
+		ofbuf = paddlec_float_buffer_get_struct(obuf);
+
+		pdlc_fir_filter_interpolate_float_buffer(fir, ifbuf, ofbuf);
+		res = obuf;
+	}
+	else if (rb_class_of(rbSample) == c_ComplexBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_ComplexBuffer)
+			rb_raise(rb_eArgError, "only a %"PRIsVALUE" is valid for buffer when a %"PRIsVALUE" is provided to the Interpolator", rb_class_name(c_ComplexBuffer), rb_class_name(c_ComplexBuffer));
+		icbuf = paddlec_complex_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_ComplexBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_ComplexBuffer);
+		ocbuf = paddlec_complex_buffer_get_struct(obuf);
+
+		pdlc_fir_filter_interpolate_complex_buffer(fir, icbuf, ocbuf);
+		res = obuf;
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a %"PRIsVALUE" or a %"PRIsVALUE, rb_class_name(c_FloatBuffer), rb_class_name(c_ComplexBuffer));
+
+	return res;
+}
+
+
+/* @return [PaddleC::FirDecimator]
+ * @overload initialize(n, decimation_factor)
+ *  @param n [Integer] the filter order
+ *  @param decimation_factor [Integer] the decimation factor (>= 1)
+ *  @return [PaddleC::FirDecimator]
+ * @overload initialize(b, decimation_factor)
+ *  @param b [Array<Float>, PaddleC::FloatBuffer] the coefficients, as an array or a {FloatBuffer}
+ *  @param decimation_factor [Integer] the decimation factor (>= 1)
+ *  @return [PaddleC::FirDecimator]
+ */
+static VALUE paddlec_fir_filter_decimator_initialize(VALUE self, VALUE b_or_n, VALUE factor)
+{
+	pdlc_fir_filter_t *fir;
+	const pdlc_buffer_t *fbuf;
+	int order, i, ifactor;
+
+	ifactor = NUM2INT(factor);
+	if (ifactor < 1)
+		rb_raise(rb_eRangeError, "Decimation factor cannot be less than one");
+	if (ifactor > 32)
+		rb_raise(rb_eRangeError, "Decimation factor greater than 32 is too much");
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(b_or_n) == c_FloatBuffer) {
+		fbuf = paddlec_float_buffer_get_struct(b_or_n);
+		order = fbuf->length;
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_decimator_initialize(fir, order - 1, ifactor);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, fbuf->data[i]);
+	}
+	else if (rb_class_of(b_or_n) == rb_cArray) {
+		order = rb_array_len(b_or_n);
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_decimator_initialize(fir, order - 1, ifactor);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, (float)NUM2DBL(rb_ary_entry(b_or_n, i)));
+	}
+	else {
+		order = NUM2INT(b_or_n);
+		if (order < 0)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_decimator_initialize(fir, order, ifactor);
+	}
+
+	return self;
+}
+
+
+/* @return [Integer] the decimation factor
+ */
+static VALUE paddlec_fir_filter_decimator_decimation_factor(VALUE self)
+{
+	const pdlc_fir_filter_t *fir;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	return INT2NUM(pdlc_fir_filter_get_factor(fir));
+}
+
+
+/* Decimate a {FloatBuffer} or {ComplexBuffer}.
+ * The returned element is of the same type as the input element.
+ *
+ * If complex samples are fed to the decimator, float samples must not be fed before a {FirFilter#reset}.
+ *
+ * The keyword argument +buffer:+ can be used to provide the decimator with an already allocated buffer for the output.
+ *
+ * @overload decimate(float_buffer, buffer: obuf) 
+ *  @param float_buffer [PaddleC::FloatBuffer] a buffer of real input samples
+ *  @param buffer [PaddleC::FloatBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @return [PaddleC::FloatBuffer] a buffer of real processed samples of size ≈ +float_buffer.length / #decimation_factor+
+ *
+ * @overload decimate(complex_buffer, buffer: obuf) 
+ *  @param complex_buffer [PaddleC::ComplexBuffer] a buffer of complex input samples
+ *  @param buffer [PaddleC::ComplexBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ *  @return [PaddleC::ComplexBuffer] a buffer of complex processed samples of size ≈ +complex_buffer.length / #decimation_factor+
+ */
+static VALUE paddlec_fir_filter_decimator_decimate(int argc, VALUE *argv, VALUE self)
+{
+	pdlc_fir_filter_t *fir;
+	VALUE rbSample, rbOptHash;
+	VALUE buffer_hash[2] = {Qundef};
+	const ID kwkeys[2] = {id_buffer};
+	VALUE obuf = Qnil;
+	VALUE res = Qnil;
+	const pdlc_buffer_t *ifbuf;
+	const pdlc_complex_buffer_t *icbuf;
+	pdlc_buffer_t *ofbuf;
+	pdlc_complex_buffer_t *ocbuf;
+
+	rb_scan_args(argc, argv, "1:", &rbSample, &rbOptHash);
+
+	if (!NIL_P(rbOptHash))
+		rb_get_kwargs(rbOptHash, kwkeys, 0, 1, buffer_hash);
+	if (buffer_hash[0] != Qundef)
+		obuf = buffer_hash[0];
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(rbSample) == c_FloatBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_FloatBuffer)
+			rb_raise(rb_eArgError, "only a %"PRIsVALUE" is valid for buffer when a %"PRIsVALUE" is provided to the decimator", rb_class_name(c_FloatBuffer), rb_class_name(c_FloatBuffer));
+		ifbuf = paddlec_float_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_FloatBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_FloatBuffer);
+		ofbuf = paddlec_float_buffer_get_struct(obuf);
+
+		pdlc_fir_filter_decimate_float_buffer(fir, ifbuf, ofbuf);
+		res = obuf;
+	}
+	else if (rb_class_of(rbSample) == c_ComplexBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_ComplexBuffer)
+			rb_raise(rb_eArgError, "only a %"PRIsVALUE" is valid for buffer when a %"PRIsVALUE" is provided to the decimator", rb_class_name(c_ComplexBuffer), rb_class_name(c_ComplexBuffer));
+		icbuf = paddlec_complex_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_ComplexBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_ComplexBuffer);
+		ocbuf = paddlec_complex_buffer_get_struct(obuf);
+
+		pdlc_fir_filter_decimate_complex_buffer(fir, icbuf, ocbuf);
+		res = obuf;
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a %"PRIsVALUE" or a %"PRIsVALUE, rb_class_name(c_FloatBuffer), rb_class_name(c_ComplexBuffer));
+
+	return res;
+}
+
+
+/* @return [PaddleC::FirTransformer]
+ * @overload initialize(n)
+ *  @param n [Integer] the filter order
+ *  @return [Paddlec::FirTransformer]
+ * @overload initialize(b)
+ *  @param b [Array<Float>, PaddleC::FloatBuffer] the coefficients, as an array or a {FloatBuffer}
+ *  @return [Paddlec::FirTransformer]
+ */
+static VALUE paddlec_fir_filter_transformer_initialize(VALUE self, VALUE b_or_n)
+{
+	pdlc_fir_filter_t *fir;
+	const pdlc_buffer_t *fbuf;
+	int order, i;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(b_or_n) == c_FloatBuffer) {
+		fbuf = paddlec_float_buffer_get_struct(b_or_n);
+		order = fbuf->length;
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_initialize(fir, order - 1);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, fbuf->data[i]);
+	}
+	else if (rb_class_of(b_or_n) == rb_cArray) {
+		order = rb_array_len(b_or_n);
+		if (order < 1)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_initialize(fir, order - 1);
+		for (i = 0; i < order; i++)
+			pdlc_fir_filter_set_coef_at(fir, i, (float)NUM2DBL(rb_ary_entry(b_or_n, i)));
+	}
+	else {
+		order = NUM2INT(b_or_n);
+		if (order < 0)
+			rb_raise(rb_eArgError, "Negative order");
+		pdlc_fir_filter_initialize(fir, order);
+	}
+
+	return self;
+}
+
+
+/* Transform a {FloatBuffer} into a {ComplexBuffer}.
+ * The real part of the output is the input signal delayed, 
+ * and the imaginary part of the output is the input signal filtered.
+ *
+ * @overload transform(float_buffer, buffer: obuf) 
+ * @param float_buffer [PaddleC::FloatBuffer] a buffer of real input samples
+ * @param buffer [PaddleC::ComplexBuffer, nil] if provided, the buffer is resized if needed and filled with output samples, then returned
+ * @return [PaddleC::ComplexBuffer] a complex buffer whose real part is the original signal delayed, and the imaginary part the signal filtered
+ */
+static VALUE paddlec_fir_filter_transformer_transform(int argc, VALUE *argv, VALUE self)
+{
+	pdlc_fir_filter_t *fir;
+	VALUE rbSample, rbOptHash;
+	VALUE buffer_hash = Qundef;
+	const ID kwkeys = id_buffer;
+	VALUE obuf = Qnil;
+	VALUE res = Qnil;
+	const pdlc_buffer_t *ifbuf;
+	pdlc_complex_buffer_t *ocbuf;
+
+	rb_scan_args(argc, argv, "1:", &rbSample, &rbOptHash);
+
+	if (!NIL_P(rbOptHash))
+		rb_get_kwargs(rbOptHash, &kwkeys, 0, 1, &buffer_hash);
+	if (buffer_hash != Qundef)
+		obuf = buffer_hash;
+
+	fir = paddlec_fir_filter_get_struct(self);
+
+	if (rb_class_of(rbSample) == c_FloatBuffer) {
+		if (!NIL_P(obuf) && rb_class_of(obuf) != c_ComplexBuffer)
+			rb_raise(rb_eArgError, "only a %"PRIsVALUE" is valid for buffer", rb_class_name(c_ComplexBuffer));
+		ifbuf = paddlec_float_buffer_get_struct(rbSample);
+
+		if (rb_class_of(obuf) != c_ComplexBuffer)
+			obuf = rb_class_new_instance(0, NULL, c_ComplexBuffer);
+		ocbuf = paddlec_complex_buffer_get_struct(obuf);
+
+		pdlc_fir_filter_transform(fir, ifbuf, ocbuf);
+		res = obuf;
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a %"PRIsVALUE, rb_class_name(c_FloatBuffer));
+
+	return res;
+}
+
+
+
+/* Document-class: PaddleC::FirTransformer
+ *
+ * PaddleC::FirTransformer is a FIR filter with the +#transform+ method. It is mostly implemented for Hilbert transformers.
+ *
+ * It can process {PaddleC::FloatBuffer} into {PaddleC::ComplexBuffer}.
+ */
+
+
+static void Init_paddlec_fir_transformer()
+{
+	c_FirTransformer = rb_define_class_under(m_PaddleC, "FirTransformer", c_FirFilter);
+	rb_define_method(c_FirTransformer, "initialize", paddlec_fir_filter_transformer_initialize,  1);
+	rb_define_method(c_FirTransformer, "transform",  paddlec_fir_filter_transformer_transform,  -1);
+}
+
+
+/* Document-class: PaddleC::FirDecimator
+ *
+ * A finite impulse response (FIR) decimator (filter + downsample), relying on {PaddleC::FirFilter}.
+ *
+ * It can process {PaddleC::FloatBuffer} and {PaddleC::ComplexBuffer}.
+ */
+
+
+static void Init_paddlec_fir_decimator()
+{
+	c_FirDecimator = rb_define_class_under(m_PaddleC, "FirDecimator", c_FirFilter);
+	rb_define_method(c_FirDecimator, "initialize",        paddlec_fir_filter_decimator_initialize,        2);
+	rb_define_method(c_FirDecimator, "decimation_factor", paddlec_fir_filter_decimator_decimation_factor, 0);
+	rb_define_method(c_FirDecimator, "decimate",          paddlec_fir_filter_decimator_decimate,         -1);
+}
+
+
+/* Document-class: PaddleC::FirInterpolator
+ *
+ * A finite impulse response (FIR) interpolator (upsample + filter), relying on {PaddleC::FirFilter}.
+ *
+ * It can process {PaddleC::FloatBuffer} and {PaddleC::ComplexBuffer}.
+ */
+
+
+static void Init_paddlec_fir_interpolator()
+{
+	c_FirInterpolator = rb_define_class_under(m_PaddleC, "FirInterpolator", c_FirFilter);
+	rb_define_method(c_FirInterpolator, "initialize",           paddlec_fir_filter_interpolator_initialize,           2);
+	rb_define_method(c_FirInterpolator, "interpolation_factor", paddlec_fir_filter_interpolator_interpolation_factor, 0);
+	rb_define_method(c_FirInterpolator, "interpolate",          paddlec_fir_filter_interpolator_interpolate,         -1);
+}
+
+
+/* Document-class: PaddleC::FirFilter
+ *
+ * A finite impulse response (FIR) filter.
+ *
+ * It can process +Float+, +Complex+, {PaddleC::FloatBuffer} and {PaddleC::ComplexBuffer}.
+ *
+ * Internal coefficients and state are hold using native arrays of single floats.
+ *
+ * Deppending on the host architecture, computation may be accelerated using +AVX+, +SSE+ or +NEON+ SIMD instructions.
+ */
+
+
+void Init_paddlec_fir_filter()
+{
+	c_FirFilter = rb_define_class_under(m_PaddleC, "FirFilter", rb_cObject);
+
+	rb_define_alloc_func(c_FirFilter, paddlec_fir_filter_alloc);
+	rb_define_method(c_FirFilter, "initialize",         paddlec_fir_filter_initialize,         1);
+	rb_define_method(c_FirFilter, "filter",             paddlec_fir_filter_filter,            -1);
+	rb_define_method(c_FirFilter, "order",              paddlec_fir_filter_order,              0);
+	rb_define_method(c_FirFilter, "nb_coefficients",    paddlec_fir_filter_nb_coefficients,    0);
+	rb_define_method(c_FirFilter, "reset",              paddlec_fir_filter_reset,              0);
+	rb_define_method(c_FirFilter, "coefficients",       paddlec_fir_filter_coefficients,       0);
+	rb_define_alias(c_FirFilter,  "numerator", "coefficients");
+	rb_define_method(c_FirFilter, "denominator",        paddlec_fir_filter_denominator,        0);
+	rb_define_method(c_FirFilter, "get_numerator_at",   paddlec_fir_filter_get_coefficient_at, 1);
+	rb_define_method(c_FirFilter, "set_numerator_at",   paddlec_fir_filter_set_coefficient_at, 2);
+	rb_define_method(c_FirFilter, "get_denominator_at", paddlec_fir_filter_get_denominator_at, 1);
+	rb_define_method(c_FirFilter, "set_denominator_at", paddlec_fir_filter_set_denominator_at, 2);
+
+	Init_paddlec_fir_transformer();
+	Init_paddlec_fir_decimator();
+	Init_paddlec_fir_interpolator();
+}
+
+