source: src/mathutils.h @ 9499eefb

feature/autosinkfeature/constantqfeature/pitchshiftfeature/pydocstringsfeature/timestretchpitchshiftsamplertimestretchyinfft+
Last change on this file since 9499eefb was 9499eefb, checked in by Paul Brossier <piem@piem.org>, 8 years ago

src/mathutils.{c,h}: add fvec_quadratic_peak_pos, a fixed replacement for fvec_quadint

  • Property mode set to 100644
File size: 7.4 KB
Line 
1/*
2  Copyright (C) 2003-2009 Paul Brossier <piem@aubio.org>
3
4  This file is part of aubio.
5
6  aubio is free software: you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10
11  aubio is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  GNU General Public License for more details.
15
16  You should have received a copy of the GNU General Public License
17  along with aubio.  If not, see <http://www.gnu.org/licenses/>.
18
19*/
20
21/** \file
22
23  Various math functions
24
25  \example test-mathutils.c
26  \example test-mathutils-window.c
27
28 */
29
30#ifndef MATHUTILS_H
31#define MATHUTILS_H
32
33#include "fvec.h"
34#include "musicutils.h"
35
36#ifdef __cplusplus
37extern "C" {
38#endif
39
40/** compute the mean of a vector
41
42  \param s vector to compute mean from
43
44  \return the mean of v
45
46*/
47smpl_t fvec_mean (fvec_t * s);
48
49/** find the max of a vector
50
51  \param s vector to get the max from
52
53  \return the value of the minimum of v
54
55*/
56smpl_t fvec_max (fvec_t * s);
57
58/** find the min of a vector
59
60  \param s vector to get the min from
61
62  \return the value of the maximum of v
63
64*/
65smpl_t fvec_min (fvec_t * s);
66
67/** find the index of the min of a vector
68
69  \param s vector to get the index from
70
71  \return the index of the minimum element of v
72
73*/
74uint_t fvec_min_elem (fvec_t * s);
75
76/** find the index of the max of a vector
77
78  \param s vector to get the index from
79
80  \return the index of the maximum element of v
81
82*/
83uint_t fvec_max_elem (fvec_t * s);
84
85/** swap the left and right halves of a vector
86 
87  This function swaps the left part of the signal with the right part of the
88signal. Therefore
89
90  \f$ a[0], a[1], ..., a[\frac{N}{2}], a[\frac{N}{2}+1], ..., a[N-1], a[N] \f$
91 
92  becomes
93 
94  \f$ a[\frac{N}{2}+1], ..., a[N-1], a[N], a[0], a[1], ..., a[\frac{N}{2}] \f$
95
96  This operation, known as 'fftshift' in the Matlab Signal Processing Toolbox,
97can be used before computing the FFT to simplify the phase relationship of the
98resulting spectrum. See Amalia de Götzen's paper referred to above.
99 
100*/
101void fvec_shift (fvec_t * v);
102
103/** compute the sum of all elements of a vector
104
105  \param v vector to compute the sum of
106
107  \return the sum of v
108
109*/
110smpl_t fvec_sum (fvec_t * v);
111
112/** compute the energy of a vector
113
114  This function compute the sum of the squared elements of a vector, normalised
115  by its length.
116 
117  \param v vector to get the energy from
118
119  \return the energy of v
120 
121*/
122smpl_t fvec_local_energy (fvec_t * v);
123
124/** compute the High Frequency Content of a vector
125
126  The High Frequency Content is defined as \f$ \sum_0^{N-1} (k+1) v[k] \f$.
127 
128  \param v vector to get the energy from
129
130  \return the HFC of v
131 
132*/
133smpl_t fvec_local_hfc (fvec_t * v);
134
135/** computes the p-norm of a vector
136 
137  Computes the p-norm of a vector for \f$ p = \alpha \f$
138
139  \f$ L^p = ||x||_p = (|x_1|^p + |x_2|^p + ... + |x_n|^p ) ^ \frac{1}{p} \f$
140 
141  If p = 1, the result is the Manhattan distance.
142
143  If p = 2, the result is the Euclidean distance.
144
145  As p tends towards large values, \f$ L^p \f$ tends towards the maximum of the
146input vector.
147
148  References:
149 
150    - <a href="http://en.wikipedia.org/wiki/Lp_space">\f$L^p\f$ space</a> on
151  Wikipedia
152
153  \param v vector to compute norm from
154  \param p order of the computed norm
155
156  \return the p-norm of v
157 
158*/
159smpl_t fvec_alpha_norm (fvec_t * v, smpl_t p);
160
161/**  alpha normalisation
162
163  This function divides all elements of a vector by the p-norm as computed by
164fvec_alpha_norm().
165
166  \param v vector to compute norm from
167  \param p order of the computed norm
168
169*/
170void fvec_alpha_normalise (fvec_t * v, smpl_t p);
171
172/** add a constant to each elements of a vector
173
174  \param v vector to add constant to
175  \param c constant to add to v
176
177*/
178void fvec_add (fvec_t * v, smpl_t c);
179
180/** remove the minimum value of the vector to each elements
181 
182  \param v vector to remove minimum from
183
184*/
185void fvec_min_removal (fvec_t * v);
186
187/** compute moving median threshold of a vector
188
189  This function computes the moving median threshold value of at the given
190position of a vector, taking the median among post elements before and up to
191pre elements after pos.
192 
193  \param v input vector
194  \param tmp temporary vector of length post+1+pre
195  \param post length of causal part to take before pos
196  \param pre length of anti-causal part to take after pos
197  \param pos index to compute threshold for
198
199  \return moving median threshold value
200
201*/
202smpl_t fvec_moving_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre,
203    uint_t pos);
204
205/** apply adaptive threshold to a vector
206
207  For each points at position p of an input vector, this function remove the
208moving median threshold computed at p.
209
210  \param v input vector
211  \param tmp temporary vector of length post+1+pre
212  \param post length of causal part to take before pos
213  \param pre length of anti-causal part to take after pos
214
215*/
216void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre);
217
218/** returns the median of a vector
219
220  The QuickSelect routine is based on the algorithm described in "Numerical
221recipes in C", Second Edition, Cambridge University Press, 1992, Section 8.5,
222ISBN 0-521-43108-5
223
224  This implementation of the QuickSelect routine is based on Nicolas
225Devillard's implementation, available at http://ndevilla.free.fr/median/median/
226and in the Public Domain.
227
228  \param v vector to get median from
229
230  \return the median of v
231 
232*/
233smpl_t fvec_median (fvec_t * v);
234
235/** finds exact peak index by quadratic interpolation*/
236smpl_t fvec_quadint (fvec_t * x, uint_t pos);
237
238/** finds exact peak index by quadratic interpolation
239
240  See [Quadratic Interpolation of Spectral
241  Peaks](https://ccrma.stanford.edu/~jos/sasp/Quadratic_Peak_Interpolation.html),
242  by Julius O. Smith III
243
244  \f$ p_{frac} = \frac{1}{2} \frac {x[p-1] - x[p+1]} {x[p-1] - 2 x[p] + x[p+1]} \in [ -.5, .5] \f$
245
246  \param x vector to get the interpolated peak position from
247  \param p index of the peak in vector `x`
248  \return \f$ p + p_{frac} \f$ exact peak position of interpolated maximum or minimum
249
250*/
251smpl_t fvec_quadratic_peak_pos (fvec_t * x, uint_t p);
252
253/** Quadratic interpolation using Lagrange polynomial.
254 
255  Inspired from ``Comparison of interpolation algorithms in real-time sound
256processing'', Vladimir Arnost,
257 
258  \param s0,s1,s2 are 3 consecutive samples of a curve
259  \param pf is the floating point index [0;2]
260 
261  \return s0 + (pf/2.)*((pf-3.)*s0-2.*(pf-2.)*s1+(pf-1.)*s2);
262
263*/
264smpl_t aubio_quadfrac (smpl_t s0, smpl_t s1, smpl_t s2, smpl_t pf);
265
266/** return 1 if v[p] is a peak and positive, 0 otherwise
267
268  This function returns 1 if a peak is found at index p in the vector v. The
269peak is defined as follows:
270
271  - v[p] is positive
272  - v[p-1] < v[p]
273  - v[p] > v[p+1]
274
275  \param v input vector
276  \param p position of supposed for peak
277
278  \return 1 if a peak is found, 0 otherwise
279
280*/
281uint_t fvec_peakpick (fvec_t * v, uint_t p);
282
283/** return 1 if a is a power of 2, 0 otherwise */
284uint_t aubio_is_power_of_two(uint_t a);
285
286/** return the next power of power of 2 greater than a */
287uint_t aubio_next_power_of_two(uint_t a);
288
289/** compute normalised autocorrelation function
290
291  \param input vector to compute autocorrelation from
292  \param output vector to store autocorrelation function to
293
294*/
295void aubio_autocorr (fvec_t * input, fvec_t * output);
296
297#ifdef __cplusplus
298}
299#endif
300
301#endif
302
Note: See TracBrowser for help on using the repository browser.