1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
/*
QM DSP Library
Centre for Digital Music, Queen Mary, University of London.
This file 2005-2006 Christian Landone.
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. See the file
COPYING included with this distribution for more information.
*/
#ifndef MATHUTILITIES_H
#define MATHUTILITIES_H
#include <vector>
#include "nan-inf.h"
/**
* Static helper functions for simple mathematical calculations.
*/
class MathUtilities
{
public:
/**
* Round x to the nearest integer.
*/
static double round( double x );
/**
* Return through min and max pointers the highest and lowest
* values in the given array of the given length.
*/
static void getFrameMinMax( const double* data, int len, double* min, double* max );
/**
* Return the mean of the given array of the given length.
*/
static double mean( const double* src, int len );
/**
* Return the mean of the subset of the given vector identified by
* start and count.
*/
static double mean( const std::vector<double> &data,
int start, int count );
/**
* Return the sum of the values in the given array of the given
* length.
*/
static double sum( const double* src, int len );
/**
* Return the median of the values in the given array of the given
* length. If the array is even in length, the returned value will
* be half-way between the two values adjacent to median.
*/
static double median( const double* src, int len );
/**
* The principle argument function. Map the phase angle ang into
* the range [-pi,pi).
*/
static double princarg( double ang );
/**
* Floating-point division modulus: return x % y.
*/
static double mod( double x, double y);
/**
* The alpha norm is the alpha'th root of the mean alpha'th power
* magnitude. For example if alpha = 2 this corresponds to the RMS
* of the input data, and when alpha = 1 this is the mean
* magnitude.
*/
static void getAlphaNorm(const double *data, int len, int alpha, double* ANorm);
/**
* The alpha norm is the alpha'th root of the mean alpha'th power
* magnitude. For example if alpha = 2 this corresponds to the RMS
* of the input data, and when alpha = 1 this is the mean
* magnitude.
*/
static double getAlphaNorm(const std::vector <double> &data, int alpha );
enum NormaliseType {
NormaliseNone,
NormaliseUnitSum,
NormaliseUnitMax
};
static void normalise(double *data, int length,
NormaliseType n = NormaliseUnitMax);
static void normalise(std::vector<double> &data,
NormaliseType n = NormaliseUnitMax);
/**
* Calculate the L^p norm of a vector. Equivalent to MATLAB's
* norm(data, p).
*/
static double getLpNorm(const std::vector<double> &data,
int p);
/**
* Normalise a vector by dividing through by its L^p norm. If the
* norm is below the given threshold, the unit vector for that
* norm is returned. p may be 0, in which case no normalisation
* happens and the data is returned unchanged.
*/
static std::vector<double> normaliseLp(const std::vector<double> &data,
int p,
double threshold = 1e-6);
/**
* Threshold the input/output vector data against a moving-mean
* average filter.
*/
static void adaptiveThreshold(std::vector<double> &data);
static void circShift( double* data, int length, int shift);
static int getMax( double* data, int length, double* max = 0 );
static int getMax( const std::vector<double> &data, double* max = 0 );
static int compareInt(const void * a, const void * b);
/**
* Return true if x is 2^n for some integer n >= 0.
*/
static bool isPowerOfTwo(int x);
/**
* Return the next higher integer power of two from x, e.g. 1300
* -> 2048, 2048 -> 2048.
*/
static int nextPowerOfTwo(int x);
/**
* Return the next lower integer power of two from x, e.g. 1300 ->
* 1024, 2048 -> 2048.
*/
static int previousPowerOfTwo(int x);
/**
* Return the nearest integer power of two to x, e.g. 1300 -> 1024,
* 12 -> 16 (not 8; if two are equidistant, the higher is returned).
*/
static int nearestPowerOfTwo(int x);
/**
* Return x!
*/
static double factorial(int x); // returns double in case it is large
/**
* Return the greatest common divisor of natural numbers a and b.
*/
static int gcd(int a, int b);
};
#endif
|
