From 575e234b005d45dbcdf2afb274df56aac995ef2a Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Thu, 13 Dec 2007 04:10:52 +0000 Subject: imported jsarlo's DSP windowing objects from http://crca.ucsd.edu/~jsarlo/pd/windowing.tar.gz which has a date of 2002-04-06 svn path=/trunk/externals/windowing/; revision=9090 --- README | 18 +++ bartlett~.c | 85 ++++++++++++ blackman~.c | 85 ++++++++++++ connes~.c | 85 ++++++++++++ cosine~.c | 85 ++++++++++++ gaussian~.c | 101 ++++++++++++++ hamming~.c | 85 ++++++++++++ hanning~.c | 85 ++++++++++++ i0.c | 409 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ kaiser~.c | 99 +++++++++++++ lanczos~.c | 85 ++++++++++++ mconf.h | 200 ++++++++++++++++++++++++++ welch~.c | 85 ++++++++++++ windowFunctions.c | 136 ++++++++++++++++++ windowFunctions.h | 30 ++++ windowing.pd | 100 +++++++++++++ 16 files changed, 1773 insertions(+) create mode 100644 README create mode 100644 bartlett~.c create mode 100644 blackman~.c create mode 100644 connes~.c create mode 100644 cosine~.c create mode 100644 gaussian~.c create mode 100644 hamming~.c create mode 100644 hanning~.c create mode 100644 i0.c create mode 100644 kaiser~.c create mode 100644 lanczos~.c create mode 100644 mconf.h create mode 100644 welch~.c create mode 100644 windowFunctions.c create mode 100644 windowFunctions.h create mode 100644 windowing.pd diff --git a/README b/README new file mode 100644 index 0000000..835705c --- /dev/null +++ b/README @@ -0,0 +1,18 @@ +Porvides: + hammimng~, hanning~, blackman~, cosine~, connes~, bartlett~, + welch~, lanczos~, gaussian~, and kaiser~ + +Usage: + Windows inlet signal on each DSP block and sends to outlet + + gaussian~ takes one optional argument (standard deviation) + May be set by float in left inlet + + kaiser~ takes one option argument (alpha) + May be set by float in left inlet + + See windowing.pd + +To build: + Linux: make windowing_linux + Windows: nmake windowing_nt diff --git a/bartlett~.c b/bartlett~.c new file mode 100644 index 0000000..61d1127 --- /dev/null +++ b/bartlett~.c @@ -0,0 +1,85 @@ +/* bartlett~ - bartlett windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *bartlett_class; + +typedef struct _bartlett { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_bartlett; + +static t_int* bartlett_perform(t_int *w) { + t_bartlett *x = (t_bartlett *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillBartlett(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void bartlett_dsp(t_bartlett *x, t_signal **sp) { + dsp_add(bartlett_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* bartlett_new(void) { + t_bartlett *x = (t_bartlett *)pd_new(bartlett_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillBartlett(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void bartlett_free(t_bartlett *x) { + free(x->x_table); +} + +void bartlett_tilde_setup(void) { + bartlett_class = class_new(gensym("bartlett~"), + (t_newmethod)bartlett_new, + (t_method)bartlett_free, + sizeof(t_bartlett), + 0, + A_DEFFLOAT, + 0); + class_addmethod(bartlett_class, nullfn, gensym("signal"), 0); + class_addmethod(bartlett_class, (t_method)bartlett_dsp, gensym("dsp"), 0); +} diff --git a/blackman~.c b/blackman~.c new file mode 100644 index 0000000..1e48fcd --- /dev/null +++ b/blackman~.c @@ -0,0 +1,85 @@ +/* blackman~ - blackman windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *blackman_class; + +typedef struct _blackman { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_blackman; + +static t_int* blackman_perform(t_int *w) { + t_blackman *x = (t_blackman *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillBlackman(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void blackman_dsp(t_blackman *x, t_signal **sp) { + dsp_add(blackman_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* blackman_new(void) { + t_blackman *x = (t_blackman *)pd_new(blackman_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillBlackman(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void blackman_free(t_blackman *x) { + free(x->x_table); +} + +void blackman_tilde_setup(void) { + blackman_class = class_new(gensym("blackman~"), + (t_newmethod)blackman_new, + (t_method)blackman_free, + sizeof(t_blackman), + 0, + A_DEFFLOAT, + 0); + class_addmethod(blackman_class, nullfn, gensym("signal"), 0); + class_addmethod(blackman_class, (t_method)blackman_dsp, gensym("dsp"), 0); +} diff --git a/connes~.c b/connes~.c new file mode 100644 index 0000000..5df68b0 --- /dev/null +++ b/connes~.c @@ -0,0 +1,85 @@ +/* connes~ - connes windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *connes_class; + +typedef struct _connes { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_connes; + +static t_int* connes_perform(t_int *w) { + t_connes *x = (t_connes *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillConnes(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void connes_dsp(t_connes *x, t_signal **sp) { + dsp_add(connes_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* connes_new(void) { + t_connes *x = (t_connes *)pd_new(connes_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillConnes(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void connes_free(t_connes *x) { + free(x->x_table); +} + +void connes_tilde_setup(void) { + connes_class = class_new(gensym("connes~"), + (t_newmethod)connes_new, + (t_method)connes_free, + sizeof(t_connes), + 0, + A_DEFFLOAT, + 0); + class_addmethod(connes_class, nullfn, gensym("signal"), 0); + class_addmethod(connes_class, (t_method)connes_dsp, gensym("dsp"), 0); +} diff --git a/cosine~.c b/cosine~.c new file mode 100644 index 0000000..76cdadf --- /dev/null +++ b/cosine~.c @@ -0,0 +1,85 @@ +/* cosine~ - cosine windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *cosine_class; + +typedef struct _cosine { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_cosine; + +static t_int* cosine_perform(t_int *w) { + t_cosine *x = (t_cosine *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillCosine(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void cosine_dsp(t_cosine *x, t_signal **sp) { + dsp_add(cosine_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* cosine_new(void) { + t_cosine *x = (t_cosine *)pd_new(cosine_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillCosine(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void cosine_free(t_cosine *x) { + free(x->x_table); +} + +void cosine_tilde_setup(void) { + cosine_class = class_new(gensym("cosine~"), + (t_newmethod)cosine_new, + (t_method)cosine_free, + sizeof(t_cosine), + 0, + A_DEFFLOAT, + 0); + class_addmethod(cosine_class, nullfn, gensym("signal"), 0); + class_addmethod(cosine_class, (t_method)cosine_dsp, gensym("dsp"), 0); +} diff --git a/gaussian~.c b/gaussian~.c new file mode 100644 index 0000000..4716c8e --- /dev/null +++ b/gaussian~.c @@ -0,0 +1,101 @@ +/* gaussian~ - gaussian windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFDELTA 0.5 +#define DEFBLOCKSIZE 64 + +static t_class *gaussian_class; + +typedef struct _gaussian { + t_object x_obj; + int x_blocksize; + float *x_table; + float x_delta; +} t_gaussian; + +static t_int* gaussian_perform(t_int *w) { + t_gaussian *x = (t_gaussian *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillGaussian(x->x_table, x->x_blocksize, x->x_delta); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void gaussian_dsp(t_gaussian *x, t_signal **sp) { + dsp_add(gaussian_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void gaussian_float(t_gaussian *x, t_float delta) { + if (delta != 0) { + x->x_delta = delta; + fillGaussian(x->x_table, x->x_blocksize, x->x_delta); + } +} + +static void* gaussian_new(float delta) { + t_gaussian *x = (t_gaussian *)pd_new(gaussian_class); + x->x_blocksize = DEFBLOCKSIZE; + if (delta == 0) { + x->x_delta = DEFDELTA; + } + else { + x->x_delta = delta; + } + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillGaussian(x->x_table, x->x_blocksize, x->x_delta); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void gaussian_free(t_gaussian *x) { + free(x->x_table); +} + +void gaussian_tilde_setup(void) { + gaussian_class = class_new(gensym("gaussian~"), + (t_newmethod)gaussian_new, + (t_method)gaussian_free, + sizeof(t_gaussian), + 0, + A_DEFFLOAT, + 0); + class_addmethod(gaussian_class, nullfn, gensym("signal"), 0); + class_addmethod(gaussian_class, (t_method)gaussian_dsp, gensym("dsp"), 0); + class_addfloat(gaussian_class, (t_method)gaussian_float); +} diff --git a/hamming~.c b/hamming~.c new file mode 100644 index 0000000..c5c10e2 --- /dev/null +++ b/hamming~.c @@ -0,0 +1,85 @@ +/* hamming~ - hamming windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *hamming_class; + +typedef struct _hamming { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_hamming; + +static t_int* hamming_perform(t_int *w) { + t_hamming *x = (t_hamming *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillHamming(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void hamming_dsp(t_hamming *x, t_signal **sp) { + dsp_add(hamming_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* hamming_new(void) { + t_hamming *x = (t_hamming *)pd_new(hamming_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillHamming(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void hamming_free(t_hamming *x) { + free(x->x_table); +} + +void hamming_tilde_setup(void) { + hamming_class = class_new(gensym("hamming~"), + (t_newmethod)hamming_new, + (t_method)hamming_free, + sizeof(t_hamming), + 0, + A_DEFFLOAT, + 0); + class_addmethod(hamming_class, nullfn, gensym("signal"), 0); + class_addmethod(hamming_class, (t_method)hamming_dsp, gensym("dsp"), 0); +} diff --git a/hanning~.c b/hanning~.c new file mode 100644 index 0000000..bf11a64 --- /dev/null +++ b/hanning~.c @@ -0,0 +1,85 @@ +/* hanning~ - hanning windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *hanning_class; + +typedef struct _hanning { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_hanning; + +static t_int* hanning_perform(t_int *w) { + t_hanning *x = (t_hanning *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillHanning(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void hanning_dsp(t_hanning *x, t_signal **sp) { + dsp_add(hanning_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* hanning_new(void) { + t_hanning *x = (t_hanning *)pd_new(hanning_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillHanning(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void hanning_free(t_hanning *x) { + free(x->x_table); +} + +void hanning_tilde_setup(void) { + hanning_class = class_new(gensym("hanning~"), + (t_newmethod)hanning_new, + (t_method)hanning_free, + sizeof(t_hanning), + 0, + A_DEFFLOAT, + 0); + class_addmethod(hanning_class, nullfn, gensym("signal"), 0); + class_addmethod(hanning_class, (t_method)hanning_dsp, gensym("dsp"), 0); +} diff --git a/i0.c b/i0.c new file mode 100644 index 0000000..b6a00f4 --- /dev/null +++ b/i0.c @@ -0,0 +1,409 @@ +/* i0.c + * + * Modified Bessel function of order zero + * + * + * + * SYNOPSIS: + * + * double x, y, i0(); + * + * y = i0( x ); + * + * + * + * DESCRIPTION: + * + * Returns modified Bessel function of order zero of the + * argument. + * + * The function is defined as i0(x) = j0( ix ). + * + * The range is partitioned into the two intervals [0,8] and + * (8, infinity). Chebyshev polynomial expansions are employed + * in each interval. + * + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * DEC 0,30 6000 8.2e-17 1.9e-17 + * IEEE 0,30 30000 5.8e-16 1.4e-16 + * + */ + /* i0e.c + * + * Modified Bessel function of order zero, + * exponentially scaled + * + * + * + * SYNOPSIS: + * + * double x, y, i0e(); + * + * y = i0e( x ); + * + * + * + * DESCRIPTION: + * + * Returns exponentially scaled modified Bessel function + * of order zero of the argument. + * + * The function is defined as i0e(x) = exp(-|x|) j0( ix ). + * + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE 0,30 30000 5.4e-16 1.2e-16 + * See i0(). + * + */ + +/* i0.c */ + + +/* +Cephes Math Library Release 2.8: June, 2000 +Copyright 1984, 1987, 2000 by Stephen L. Moshier +*/ + +#include +#include "mconf.h" + +/* Chebyshev coefficients for exp(-x) I0(x) + * in the interval [0,8]. + * + * lim(x->0){ exp(-x) I0(x) } = 1. + */ + +#ifdef UNK +static double A[] = +{ +-4.41534164647933937950E-18, + 3.33079451882223809783E-17, +-2.43127984654795469359E-16, + 1.71539128555513303061E-15, +-1.16853328779934516808E-14, + 7.67618549860493561688E-14, +-4.85644678311192946090E-13, + 2.95505266312963983461E-12, +-1.72682629144155570723E-11, + 9.67580903537323691224E-11, +-5.18979560163526290666E-10, + 2.65982372468238665035E-9, +-1.30002500998624804212E-8, + 6.04699502254191894932E-8, +-2.67079385394061173391E-7, + 1.11738753912010371815E-6, +-4.41673835845875056359E-6, + 1.64484480707288970893E-5, +-5.75419501008210370398E-5, + 1.88502885095841655729E-4, +-5.76375574538582365885E-4, + 1.63947561694133579842E-3, +-4.32430999505057594430E-3, + 1.05464603945949983183E-2, +-2.37374148058994688156E-2, + 4.93052842396707084878E-2, +-9.49010970480476444210E-2, + 1.71620901522208775349E-1, +-3.04682672343198398683E-1, + 6.76795274409476084995E-1 +}; +#endif + +#ifdef DEC +static unsigned short A[] = { +0121642,0162671,0004646,0103567, +0022431,0115424,0135755,0026104, +0123214,0023533,0110365,0156635, +0023767,0033304,0117662,0172716, +0124522,0100426,0012277,0157531, +0025254,0155062,0054461,0030465, +0126010,0131143,0013560,0153604, +0026517,0170577,0006336,0114437, +0127227,0162253,0152243,0052734, +0027724,0142766,0061641,0160200, +0130416,0123760,0116564,0125262, +0031066,0144035,0021246,0054641, +0131537,0053664,0060131,0102530, +0032201,0155664,0165153,0020652, +0132617,0061434,0074423,0176145, +0033225,0174444,0136147,0122542, +0133624,0031576,0056453,0020470, +0034211,0175305,0172321,0041314, +0134561,0054462,0147040,0165315, +0035105,0124333,0120203,0162532, +0135427,0013750,0174257,0055221, +0035726,0161654,0050220,0100162, +0136215,0131361,0000325,0041110, +0036454,0145417,0117357,0017352, +0136702,0072367,0104415,0133574, +0037111,0172126,0072505,0014544, +0137302,0055601,0120550,0033523, +0037457,0136543,0136544,0043002, +0137633,0177536,0001276,0066150, +0040055,0041164,0100655,0010521 +}; +#endif + +#ifdef IBMPC +static unsigned short A[] = { +0xd0ef,0x2134,0x5cb7,0xbc54, +0xa589,0x977d,0x3362,0x3c83, +0xbbb4,0x721e,0x84eb,0xbcb1, +0x5eba,0x93f6,0xe6d8,0x3cde, +0xfbeb,0xc297,0x5022,0xbd0a, +0x2627,0x4b26,0x9b46,0x3d35, +0x1af0,0x62ee,0x164c,0xbd61, +0xd324,0xe19b,0xfe2f,0x3d89, +0x6abc,0x7a94,0xfc95,0xbdb2, +0x3c10,0xcc74,0x98be,0x3dda, +0x9556,0x13ae,0xd4fe,0xbe01, +0xcb34,0xa454,0xd903,0x3e26, +0x30ab,0x8c0b,0xeaf6,0xbe4b, +0x6435,0x9d4d,0x3b76,0x3e70, +0x7f8d,0x8f22,0xec63,0xbe91, +0xf4ac,0x978c,0xbf24,0x3eb2, +0x6427,0xcba5,0x866f,0xbed2, +0x2859,0xbe9a,0x3f58,0x3ef1, +0x1d5a,0x59c4,0x2b26,0xbf0e, +0x7cab,0x7410,0xb51b,0x3f28, +0xeb52,0x1f15,0xe2fd,0xbf42, +0x100e,0x8a12,0xdc75,0x3f5a, +0xa849,0x201a,0xb65e,0xbf71, +0xe3dd,0xf3dd,0x9961,0x3f85, +0xb6f0,0xf121,0x4e9e,0xbf98, +0xa32d,0xcea8,0x3e8a,0x3fa9, +0x06ea,0x342d,0x4b70,0xbfb8, +0x88c0,0x77ac,0xf7ac,0x3fc5, +0xcd8d,0xc057,0x7feb,0xbfd3, +0xa22a,0x9035,0xa84e,0x3fe5, +}; +#endif + +#ifdef MIEEE +static unsigned short A[] = { +0xbc54,0x5cb7,0x2134,0xd0ef, +0x3c83,0x3362,0x977d,0xa589, +0xbcb1,0x84eb,0x721e,0xbbb4, +0x3cde,0xe6d8,0x93f6,0x5eba, +0xbd0a,0x5022,0xc297,0xfbeb, +0x3d35,0x9b46,0x4b26,0x2627, +0xbd61,0x164c,0x62ee,0x1af0, +0x3d89,0xfe2f,0xe19b,0xd324, +0xbdb2,0xfc95,0x7a94,0x6abc, +0x3dda,0x98be,0xcc74,0x3c10, +0xbe01,0xd4fe,0x13ae,0x9556, +0x3e26,0xd903,0xa454,0xcb34, +0xbe4b,0xeaf6,0x8c0b,0x30ab, +0x3e70,0x3b76,0x9d4d,0x6435, +0xbe91,0xec63,0x8f22,0x7f8d, +0x3eb2,0xbf24,0x978c,0xf4ac, +0xbed2,0x866f,0xcba5,0x6427, +0x3ef1,0x3f58,0xbe9a,0x2859, +0xbf0e,0x2b26,0x59c4,0x1d5a, +0x3f28,0xb51b,0x7410,0x7cab, +0xbf42,0xe2fd,0x1f15,0xeb52, +0x3f5a,0xdc75,0x8a12,0x100e, +0xbf71,0xb65e,0x201a,0xa849, +0x3f85,0x9961,0xf3dd,0xe3dd, +0xbf98,0x4e9e,0xf121,0xb6f0, +0x3fa9,0x3e8a,0xcea8,0xa32d, +0xbfb8,0x4b70,0x342d,0x06ea, +0x3fc5,0xf7ac,0x77ac,0x88c0, +0xbfd3,0x7feb,0xc057,0xcd8d, +0x3fe5,0xa84e,0x9035,0xa22a +}; +#endif + + +/* Chebyshev coefficients for exp(-x) sqrt(x) I0(x) + * in the inverted interval [8,infinity]. + * + * lim(x->inf){ exp(-x) sqrt(x) I0(x) } = 1/sqrt(2pi). + */ + +#ifdef UNK +static double B[] = +{ +-7.23318048787475395456E-18, +-4.83050448594418207126E-18, + 4.46562142029675999901E-17, + 3.46122286769746109310E-17, +-2.82762398051658348494E-16, +-3.42548561967721913462E-16, + 1.77256013305652638360E-15, + 3.81168066935262242075E-15, +-9.55484669882830764870E-15, +-4.15056934728722208663E-14, + 1.54008621752140982691E-14, + 3.85277838274214270114E-13, + 7.18012445138366623367E-13, +-1.79417853150680611778E-12, +-1.32158118404477131188E-11, +-3.14991652796324136454E-11, + 1.18891471078464383424E-11, + 4.94060238822496958910E-10, + 3.39623202570838634515E-9, + 2.26666899049817806459E-8, + 2.04891858946906374183E-7, + 2.89137052083475648297E-6, + 6.88975834691682398426E-5, + 3.36911647825569408990E-3, + 8.04490411014108831608E-1 +}; +#endif + +#ifdef DEC +static unsigned short B[] = { +0122005,0066672,0123124,0054311, +0121662,0033323,0030214,0104602, +0022515,0170300,0113314,0020413, +0022437,0117350,0035402,0007146, +0123243,0000135,0057220,0177435, +0123305,0073476,0144106,0170702, +0023777,0071755,0017527,0154373, +0024211,0052214,0102247,0033270, +0124454,0017763,0171453,0012322, +0125072,0166316,0075505,0154616, +0024612,0133770,0065376,0025045, +0025730,0162143,0056036,0001632, +0026112,0015077,0150464,0063542, +0126374,0101030,0014274,0065457, +0127150,0077271,0125763,0157617, +0127412,0104350,0040713,0120445, +0027121,0023765,0057500,0001165, +0030407,0147146,0003643,0075644, +0031151,0061445,0044422,0156065, +0031702,0132224,0003266,0125551, +0032534,0000076,0147153,0005555, +0033502,0004536,0004016,0026055, +0034620,0076433,0142314,0171215, +0036134,0146145,0013454,0101104, +0040115,0171425,0062500,0047133 +}; +#endif + +#ifdef IBMPC +static unsigned short B[] = { +0x8b19,0x54ca,0xadb7,0xbc60, +0x9130,0x6611,0x46da,0xbc56, +0x8421,0x12d9,0xbe18,0x3c89, +0x41cd,0x0760,0xf3dd,0x3c83, +0x1fe4,0xabd2,0x600b,0xbcb4, +0xde38,0xd908,0xaee7,0xbcb8, +0xfb1f,0xa3ea,0xee7d,0x3cdf, +0xe6d7,0x9094,0x2a91,0x3cf1, +0x629a,0x7e65,0x83fe,0xbd05, +0xbb32,0xcf68,0x5d99,0xbd27, +0xc545,0x0d5f,0x56ff,0x3d11, +0xc073,0x6b83,0x1c8c,0x3d5b, +0x8cec,0xfa26,0x4347,0x3d69, +0x8d66,0x0317,0x9043,0xbd7f, +0x7bf2,0x357e,0x0fd7,0xbdad, +0x7425,0x0839,0x511d,0xbdc1, +0x004f,0xabe8,0x24fe,0x3daa, +0x6f75,0xc0f4,0xf9cc,0x3e00, +0x5b87,0xa922,0x2c64,0x3e2d, +0xd56d,0x80d6,0x5692,0x3e58, +0x616e,0xd9cd,0x8007,0x3e8b, +0xc586,0xc101,0x412b,0x3ec8, +0x9e52,0x7899,0x0fa3,0x3f12, +0x9049,0xa2e5,0x998c,0x3f6b, +0x09cb,0xaca8,0xbe62,0x3fe9 +}; +#endif + +#ifdef MIEEE +static unsigned short B[] = { +0xbc60,0xadb7,0x54ca,0x8b19, +0xbc56,0x46da,0x6611,0x9130, +0x3c89,0xbe18,0x12d9,0x8421, +0x3c83,0xf3dd,0x0760,0x41cd, +0xbcb4,0x600b,0xabd2,0x1fe4, +0xbcb8,0xaee7,0xd908,0xde38, +0x3cdf,0xee7d,0xa3ea,0xfb1f, +0x3cf1,0x2a91,0x9094,0xe6d7, +0xbd05,0x83fe,0x7e65,0x629a, +0xbd27,0x5d99,0xcf68,0xbb32, +0x3d11,0x56ff,0x0d5f,0xc545, +0x3d5b,0x1c8c,0x6b83,0xc073, +0x3d69,0x4347,0xfa26,0x8cec, +0xbd7f,0x9043,0x0317,0x8d66, +0xbdad,0x0fd7,0x357e,0x7bf2, +0xbdc1,0x511d,0x0839,0x7425, +0x3daa,0x24fe,0xabe8,0x004f, +0x3e00,0xf9cc,0xc0f4,0x6f75, +0x3e2d,0x2c64,0xa922,0x5b87, +0x3e58,0x5692,0x80d6,0xd56d, +0x3e8b,0x8007,0xd9cd,0x616e, +0x3ec8,0x412b,0xc101,0xc586, +0x3f12,0x0fa3,0x7899,0x9e52, +0x3f6b,0x998c,0xa2e5,0x9049, +0x3fe9,0xbe62,0xaca8,0x09cb +}; +#endif + +double chbevl(double x, double array[], int n) +{ +double b0, b1, b2, *p; +int i; + +p = array; +b0 = *p++; +b1 = 0.0; +i = n - 1; + +do + { + b2 = b1; + b1 = b0; + b0 = x * b1 - b2 + *p++; + } +while( --i ); + +return( 0.5*(b0-b2) ); +} + +double i0(double x) +{ +double y; + +if( x < 0 ) + x = -x; +if( x <= 8.0 ) + { + y = (x/2.0) - 2.0; + return( exp(x) * chbevl( y, A, 30 ) ); + } + +return( exp(x) * chbevl( 32.0/x - 2.0, B, 25 ) / sqrt(x) ); + +} + + + + +double i0e(double x) +{ +double y; + +if( x < 0 ) + x = -x; +if( x <= 8.0 ) + { + y = (x/2.0) - 2.0; + return( chbevl( y, A, 30 ) ); + } + +return( chbevl( 32.0/x - 2.0, B, 25 ) / sqrt(x) ); + +} diff --git a/kaiser~.c b/kaiser~.c new file mode 100644 index 0000000..8267ba1 --- /dev/null +++ b/kaiser~.c @@ -0,0 +1,99 @@ +/* kaiser~ - kaiser windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFALPHA 10 +#define DEFBLOCKSIZE 64 + +static t_class *kaiser_class; + +typedef struct _kaiser { + t_object x_obj; + int x_blocksize; + float *x_table; + float x_alpha; +} t_kaiser; + +static t_int* kaiser_perform(t_int *w) { + t_kaiser *x = (t_kaiser *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillKaiser(x->x_table, x->x_blocksize, x->x_alpha); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void kaiser_dsp(t_kaiser *x, t_signal **sp) { + dsp_add(kaiser_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void kaiser_float(t_kaiser *x, t_float alpha) { + x->x_alpha = alpha; + fillKaiser(x->x_table, x->x_blocksize, x->x_alpha); +} + +static void* kaiser_new(float alpha) { + t_kaiser *x = (t_kaiser *)pd_new(kaiser_class); + x->x_blocksize = DEFBLOCKSIZE; + if (alpha == 0) { + x->x_alpha = DEFALPHA; + } + else { + x->x_alpha = alpha; + } + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillKaiser(x->x_table, x->x_blocksize, x->x_alpha); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void kaiser_free(t_kaiser *x) { + free(x->x_table); +} + +void kaiser_tilde_setup(void) { + kaiser_class = class_new(gensym("kaiser~"), + (t_newmethod)kaiser_new, + (t_method)kaiser_free, + sizeof(t_kaiser), + 0, + A_DEFFLOAT, + 0); + class_addmethod(kaiser_class, nullfn, gensym("signal"), 0); + class_addmethod(kaiser_class, (t_method)kaiser_dsp, gensym("dsp"), 0); + class_addfloat(kaiser_class, (t_method)kaiser_float); +} diff --git a/lanczos~.c b/lanczos~.c new file mode 100644 index 0000000..422b020 --- /dev/null +++ b/lanczos~.c @@ -0,0 +1,85 @@ +/* lanczos~ - lanczos windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *lanczos_class; + +typedef struct _lanczos { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_lanczos; + +static t_int* lanczos_perform(t_int *w) { + t_lanczos *x = (t_lanczos *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillLanczos(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void lanczos_dsp(t_lanczos *x, t_signal **sp) { + dsp_add(lanczos_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* lanczos_new(void) { + t_lanczos *x = (t_lanczos *)pd_new(lanczos_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillLanczos(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void lanczos_free(t_lanczos *x) { + free(x->x_table); +} + +void lanczos_tilde_setup(void) { + lanczos_class = class_new(gensym("lanczos~"), + (t_newmethod)lanczos_new, + (t_method)lanczos_free, + sizeof(t_lanczos), + 0, + A_DEFFLOAT, + 0); + class_addmethod(lanczos_class, nullfn, gensym("signal"), 0); + class_addmethod(lanczos_class, (t_method)lanczos_dsp, gensym("dsp"), 0); +} diff --git a/mconf.h b/mconf.h new file mode 100644 index 0000000..063158e --- /dev/null +++ b/mconf.h @@ -0,0 +1,200 @@ +/* mconf.h + * + * Common include file for math routines + * + * + * + * SYNOPSIS: + * + * #include "mconf.h" + * + * + * + * DESCRIPTION: + * + * This file contains definitions for error codes that are + * passed to the common error handling routine mtherr() + * (which see). + * + * The file also includes a conditional assembly definition + * for the type of computer arithmetic (IEEE, DEC, Motorola + * IEEE, or UNKnown). + * + * For Digital Equipment PDP-11 and VAX computers, certain + * IBM systems, and others that use numbers with a 56-bit + * significand, the symbol DEC should be defined. In this + * mode, most floating point constants are given as arrays + * of octal integers to eliminate decimal to binary conversion + * errors that might be introduced by the compiler. + * + * For little-endian computers, such as IBM PC, that follow the + * IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE + * Std 754-1985), the symbol IBMPC should be defined. These + * numbers have 53-bit significands. In this mode, constants + * are provided as arrays of hexadecimal 16 bit integers. + * + * Big-endian IEEE format is denoted MIEEE. On some RISC + * systems such as Sun SPARC, double precision constants + * must be stored on 8-byte address boundaries. Since integer + * arrays may be aligned differently, the MIEEE configuration + * may fail on such machines. + * + * To accommodate other types of computer arithmetic, all + * constants are also provided in a normal decimal radix + * which one can hope are correctly converted to a suitable + * format by the available C language compiler. To invoke + * this mode, define the symbol UNK. + * + * An important difference among these modes is a predefined + * set of machine arithmetic constants for each. The numbers + * MACHEP (the machine roundoff error), MAXNUM (largest number + * represented), and several other parameters are preset by + * the configuration symbol. Check the file const.c to + * ensure that these values are correct for your computer. + * + * Configurations NANS, INFINITIES, MINUSZERO, and DENORMAL + * may fail on many systems. Verify that they are supposed + * to work on your computer. + */ +/* +Cephes Math Library Release 2.3: June, 1995 +Copyright 1984, 1987, 1989, 1995 by Stephen L. Moshier +*/ + + +/* Define if the `long double' type works. */ +#define HAVE_LONG_DOUBLE 1 + +/* Define as the return type of signal handlers (int or void). */ +#define RETSIGTYPE void + +/* Define if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define if your processor stores words with the most significant + byte first (like Motorola and SPARC, unlike Intel and VAX). */ +/* #undef WORDS_BIGENDIAN */ + +/* Define if floating point words are bigendian. */ +/* #undef FLOAT_WORDS_BIGENDIAN */ + +/* The number of bytes in a int. */ +#define SIZEOF_INT 4 + +/* Define if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Name of package */ +#define PACKAGE "cephes" + +/* Version number of package */ +#define VERSION "2.7" + +/* Constant definitions for math error conditions + */ +#ifndef NT +#define DOMAIN 1 /* argument domain error */ +#define SING 2 /* argument singularity */ +#define OVERFLOW 3 /* overflow range error */ +#define UNDERFLOW 4 /* underflow range error */ +#define TLOSS 5 /* total loss of precision */ +#define PLOSS 6 /* partial loss of precision */ +#endif + +#define EDOM 33 +#define ERANGE 34 +/* Complex numeral. */ +typedef struct + { + double r; + double i; + } cmplx; + +#ifdef HAVE_LONG_DOUBLE +/* Long double complex numeral. */ +typedef struct + { + long double r; + long double i; + } cmplxl; +#endif + + +/* Type of computer arithmetic */ + +/* PDP-11, Pro350, VAX: + */ +/* #define DEC 1 */ + +/* Intel IEEE, low order words come first: + */ +/* #define IBMPC 1 */ + +/* Motorola IEEE, high order words come first + * (Sun 680x0 workstation): + */ +/* #define MIEEE 1 */ + +/* UNKnown arithmetic, invokes coefficients given in + * normal decimal format. Beware of range boundary + * problems (MACHEP, MAXLOG, etc. in const.c) and + * roundoff problems in pow.c: + * (Sun SPARCstation) + */ +#define UNK 1 + +/* If you define UNK, then be sure to set BIGENDIAN properly. */ +#ifdef FLOAT_WORDS_BIGENDIAN +#define BIGENDIAN 1 +#else +#define BIGENDIAN 0 +#endif +/* Define this `volatile' if your compiler thinks + * that floating point arithmetic obeys the associative + * and distributive laws. It will defeat some optimizations + * (but probably not enough of them). + * + * #define VOLATILE volatile + */ +#define VOLATILE + +/* For 12-byte long doubles on an i386, pad a 16-bit short 0 + * to the end of real constants initialized by integer arrays. + * + * #define XPD 0, + * + * Otherwise, the type is 10 bytes long and XPD should be + * defined blank (e.g., Microsoft C). + * + * #define XPD + */ +#define XPD 0, + +/* Define to support tiny denormal numbers, else undefine. */ +#define DENORMAL 1 + +/* Define to ask for infinity support, else undefine. */ +#define INFINITIES 1 + +/* Define to ask for support of numbers that are Not-a-Number, + else undefine. This may automatically define INFINITIES in some files. */ +#define NANS 1 + +/* Define to distinguish between -0.0 and +0.0. */ +#define MINUSZERO 1 + +/* Define 1 for ANSI C atan2() function + See atan.c and clog.c. */ +#define ANSIC 1 + +/* Get ANSI function prototypes, if you want them. */ +#if 1 +/* #ifdef __STDC__ */ +#define ANSIPROT 1 +int mtherr ( char *, int ); +#else +int mtherr(); +#endif + +/* Variable for error reporting. See mtherr.c. */ +extern int merror; diff --git a/welch~.c b/welch~.c new file mode 100644 index 0000000..ffae066 --- /dev/null +++ b/welch~.c @@ -0,0 +1,85 @@ +/* welch~ - welch windowing function for Pure Data +** +** Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include "m_pd.h" +#include "windowFunctions.h" +#include +#ifdef NT +#pragma warning( disable : 4244 ) +#pragma warning( disable : 4305 ) +#endif +#define DEFBLOCKSIZE 64 + +static t_class *welch_class; + +typedef struct _welch { + t_object x_obj; + int x_blocksize; + float *x_table; +} t_welch; + +static t_int* welch_perform(t_int *w) { + t_welch *x = (t_welch *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int i; + if (x->x_blocksize != n) { + if (x->x_blocksize < n) { + x->x_table = realloc(x->x_table, n * sizeof(float)); + } + x->x_blocksize = n; + fillWelch(x->x_table, x->x_blocksize); + } + for (i = 0; i < n; i++) { + *out++ = *(in++) * x->x_table[i]; + } + return (w + 5); +} + +static void welch_dsp(t_welch *x, t_signal **sp) { + dsp_add(welch_perform, 4, x, sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); +} + +static void* welch_new(void) { + t_welch *x = (t_welch *)pd_new(welch_class); + x->x_blocksize = DEFBLOCKSIZE; + x->x_table = malloc(x->x_blocksize * sizeof(float)); + fillWelch(x->x_table, x->x_blocksize); + outlet_new(&x->x_obj, gensym("signal")); + return (x); +} + +static void welch_free(t_welch *x) { + free(x->x_table); +} + +void welch_tilde_setup(void) { + welch_class = class_new(gensym("welch~"), + (t_newmethod)welch_new, + (t_method)welch_free, + sizeof(t_welch), + 0, + A_DEFFLOAT, + 0); + class_addmethod(welch_class, nullfn, gensym("signal"), 0); + class_addmethod(welch_class, (t_method)welch_dsp, gensym("dsp"), 0); +} diff --git a/windowFunctions.c b/windowFunctions.c new file mode 100644 index 0000000..acb7e9f --- /dev/null +++ b/windowFunctions.c @@ -0,0 +1,136 @@ +/* Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +#include +#include +#include +#ifdef NT +#define M_PI 3.14159265358979323846 +#endif + +/* modified bessel function of zeroth order */ +double i0(double x); + +void fillHanning(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)(0.5 * (1 + cos(M_PI * x))); + } +} + +void fillHamming(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)(0.54 + 0.46 * cos(M_PI * x)); + } +} + +void fillBlackman(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)(0.42 + (0.5 * cos(M_PI * x)) + (0.08 * cos (2 * M_PI * x))); + } +} + +void fillConnes(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)((1 - (x * x)) * (1 - (x * x))); + } +} + +void fillCosine(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)cos(M_PI * x / 2); + } +} + +void fillWelch(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = 1 - (x * x); + } +} + +void fillBartlett(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)(1 - fabs(x)); + } +} + +void fillLanczos(float *vec, int n) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + if (x == 0) { + vec[i] = 1; + } + else { + vec[i] = (float)(sin(M_PI * x) / (M_PI * x)); + } + } +} + +void fillGaussian(float *vec, int n, float delta) { + int i; + float xShift = (float)n / 2; + float x; + if (delta == 0) { + delta = 1; + } + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)(pow(2, (-1 * (x / delta) * (x / delta)))); + } +} + +void fillKaiser(float *vec, int n, float alpha) { + int i; + float xShift = (float)n / 2; + float x; + for (i = 0; i < n; i++) { + x = (i - xShift) / xShift; + vec[i] = (float)(i0(alpha * sqrt(1 - (x * x))) / i0(alpha)); + } +} diff --git a/windowFunctions.h b/windowFunctions.h new file mode 100644 index 0000000..9aed7ba --- /dev/null +++ b/windowFunctions.h @@ -0,0 +1,30 @@ +/* Copyright (C) 2002 Joseph A. Sarlo +** +** This program 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 2 +** of the License, or (at your option) any later version. +** +** This program 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 this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** jsarlo@mambo.peabody.jhu.edu +*/ + +void fillHanning(float *vec, int n); +void fillHamming(float *vec, int n); +void fillBlackman(float *vec, int n); +void fillConnes(float *vec, int n); +void fillCosine(float *vec, int n); +void fillWelch(float *vec, int n); +void fillBartlett(float *vec, int n); +void fillLanczos(float *vec, int n); +void fillGaussian(float *vec, int n, float delta); +void fillKaiser(float *vec, int n, float delta); + diff --git a/windowing.pd b/windowing.pd new file mode 100644 index 0000000..5254373 --- /dev/null +++ b/windowing.pd @@ -0,0 +1,100 @@ +#N canvas 117 0 857 741 10; +#X obj 13 70 hanning~; +#X obj 13 96 tabsend~ hanning; +#X obj 13 47 sig~ 1; +#X obj 181 48 sig~ 1; +#X obj 181 72 hamming~; +#X obj 181 97 tabsend~ hamming; +#X obj 15 186 sig~ 1; +#X obj 183 187 sig~ 1; +#X obj 15 209 blackman~; +#X obj 183 211 connes~; +#X obj 14 335 sig~ 1; +#X obj 182 339 sig~ 1; +#X obj 14 361 cosine~; +#X obj 182 363 bartlett~; +#X obj 15 492 sig~ 1; +#X obj 183 494 sig~ 1; +#X obj 15 515 welch~; +#X obj 183 518 lanczos~; +#X obj 16 624 sig~ 1; +#X obj 16 683 tabsend~ gaussian; +#X floatatom 68 624 5 0 0; +#X obj 184 643 sig~ 1; +#X floatatom 236 643 5 0 0; +#X obj 184 702 tabsend~ kaiser; +#X obj 15 235 tabsend~ blackman; +#X obj 183 236 tabsend~ connes; +#X obj 14 387 tabsend~ cosine; +#X obj 182 388 tabsend~ bartlett; +#X obj 15 542 tabsend~ welch; +#X obj 183 543 tabsend~ lanczos; +#X graph graph1 0 -1 63 1 369 152 569 12; +#X array hanning 64 float 0; +#X pop; +#X graph graph2 0 -1 63 1 630 151 830 11; +#X array hamming 64 float 0; +#X pop; +#X graph graph3 0 -1 63 1 369 295 569 155; +#X array blackman 64 float 0; +#X pop; +#X graph graph4 0 -1 63 1 631 294 831 154; +#X array connes 64 float 0; +#X pop; +#X graph graph5 0 -1 63 1 369 438 569 298; +#X array cosine 64 float 0; +#X pop; +#X graph graph6 0 -1 63 1 631 437 831 297; +#X array bartlett 64 float 0; +#X pop; +#X graph graph7 0 -1 63 1 369 582 569 442; +#X array welch 64 float 0; +#X pop; +#X graph graph8 0 -1 63 1 631 581 831 441; +#X array lanczos 64 float 0; +#X pop; +#X graph graph9 0 -1 63 1 369 726 569 586; +#X array gaussian 64 float 0; +#X pop; +#X graph graph10 0 -1 63 1 631 725 831 585; +#X array kaiser 64 float 0; +#X pop; +#X obj 16 657 gaussian~ 0.5; +#X obj 184 676 kaiser~ 10; +#X text 250 362 (triangle); +#X text 245 518 (sinc); +#X text 12 23 0.5*(1+cos(pi*x)); +#X text 179 24 0.54+0.46*(cos(pi*x)); +#X text 14 164 0.8*cos(2*pi*x); +#X text 180 161 (1-x^2)^2; +#X text 14 149 0.42+(0.5*cos(pi*x))+; +#X text 13 311 cos(pi*x/2); +#X text 179 312 1-x^2; +#X text 14 465 1 - abs(x); +#X text 180 466 sin(pi*x)/(pi*x); +#X text 16 602 2^(-(x/d)^2); +#X text 184 622 modified Bessel function; +#X text 184 608 where Io is 0th order; +#X text 183 593 Io(a*sqrt(1-x^2))/Io(a); +#X connect 0 0 1 0; +#X connect 2 0 0 0; +#X connect 3 0 4 0; +#X connect 4 0 5 0; +#X connect 6 0 8 0; +#X connect 7 0 9 0; +#X connect 8 0 24 0; +#X connect 9 0 25 0; +#X connect 10 0 12 0; +#X connect 11 0 13 0; +#X connect 12 0 26 0; +#X connect 13 0 27 0; +#X connect 14 0 16 0; +#X connect 15 0 17 0; +#X connect 16 0 28 0; +#X connect 17 0 29 0; +#X connect 18 0 40 0; +#X connect 20 0 40 0; +#X connect 21 0 41 0; +#X connect 22 0 41 0; +#X connect 40 0 19 0; +#X connect 41 0 23 0; -- cgit v1.2.1