ITANumericUtils.h 16.8 KB
Newer Older
Jonas Stienen's avatar
Jonas Stienen committed
1
/*
2 3 4 5
 * ----------------------------------------------------------------
 *
 *		ITA core libs
 *		(c) Copyright Institute of Technical Acoustics (ITA)
6
 *		RWTH Aachen University, Germany, 2015-2018
7 8 9 10 11 12 13 14 15 16 17
 *
 * ----------------------------------------------------------------
 *				    ____  __________  _______
 *				   //  / //__   ___/ //  _   |
 *				  //  /    //  /    //  /_|  |
 *				 //  /    //  /    //  ___   |
 *				//__/    //__/    //__/   |__|
 *
 * ----------------------------------------------------------------
 *
 */
Jonas Stienen's avatar
Jonas Stienen committed
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

#ifndef INCLUDE_WATCHER_ITA_NUMERIC_UTILS
#define INCLUDE_WATCHER_ITA_NUMERIC_UTILS

#include <ITABaseDefinitions.h>

#include <algorithm>
#include <cmath>
#include <limits>
#include <vector>

// Ein Makro für die Berechnung von Prozentsätzen (Wieviel Prozent p sind P von G?)
// Wichtiges Feature: Behandlung des Falles G = 0. Rückgabewert in diesem Fall 0.
#define PERCENT_OF(P, G) (G == 0 ? 0 : 100*(double) P/(double) G)

//! Zweierexponent einer natürlichen Zahl ermitteln
/**
 * Ermittelt die natürliche Zahl k, welche 2^k = x erfüllt.
 * Existiert keine solche, d.h. ist x keine Zweierpotenz, so
 * gibt die Funktion -1 zurück.
 */
39
ITA_BASE_API int getExp2( unsigned int x );
Jonas Stienen's avatar
Jonas Stienen committed
40 41

//! Test auf Zweierpotenz
42
ITA_BASE_API bool isPow2( unsigned int x );
Jonas Stienen's avatar
Jonas Stienen committed
43 44

//! Nächstgrößeres Zweierpotenz zurückgeben
45
ITA_BASE_API unsigned int nextPow2( unsigned int x );
Jonas Stienen's avatar
Jonas Stienen committed
46 47 48 49

// Rundung auf Compilern definieren die dies nicht standardmäßig mitliefern

#ifndef HAVE_ROUND
50 51 52 53 54 55 56 57 58
ITA_BASE_API inline double round( double x )
{
	return ( x < 0 ? ceil( ( x ) -0.5 ) : floor( ( x ) +0.5 ) );
};

ITA_BASE_API inline float roundf( float x )
{
	return ( x < 0 ? ceil( ( x ) -0.5f ) : floor( ( x ) +0.5f ) );
};
Jonas Stienen's avatar
Jonas Stienen committed
59 60 61 62 63 64 65 66 67 68 69
#endif

//! Nächstkleineres Vielfaches von mul zu einer Zahl x zurückgeben
/**
 * Beispiele: lwrmul(10, 5) = 10
 *            lwrmul(10, 6) = 6
 *            lwrmul(-10, 5) = -10
 *            lwrmul(-10, -6) = -12 (Kleiner!)
 *            lwrmul(-10, 6) = -12
 *            lwrmul(10, -6) = 12
 */
70
ITA_BASE_API int lwrmul( const int x, const int mul );
Jonas Stienen's avatar
Jonas Stienen committed
71 72 73 74 75 76 77 78 79 80

//! Nächstgrößeres Vielfaches von mul zu einer Zahl x zurückgeben
/**
 * Beispiele: uprmul(10, 5) = 10
 *            uprmul(10, 6) = 12
 *            uprmul(-10, 5) = -10
 *            uprmul(-10, -6) = -6 (Größer!)
 *            uprmul(-10, 6) = -6
 *            uprmul(10, -6) = 12
 */
81
ITA_BASE_API int uprmul( const int x, const int mul );
Jonas Stienen's avatar
Jonas Stienen committed
82 83 84 85 86 87

//! Nächstkleineres Vielfaches von mul zu einer Zahl x zurückgeben
/**
 * Beispiele: lwrmulu(10, 5) = 10
 *            lwrmulu(10, 6) = 6
 */
88
ITA_BASE_API unsigned int lwrmulu( const unsigned int x, const unsigned int mul );
Jonas Stienen's avatar
Jonas Stienen committed
89 90 91 92 93 94

//! Nächstgrößeres Vielfaches von mul zu einer Zahl x zurückgeben
/**
 * Beispiele: uprmulu(10, 5) = 10
 *            uprmulu(10, 6) = 12
 */
95
ITA_BASE_API unsigned int uprmulu( const unsigned int x, const unsigned int mul );
Jonas Stienen's avatar
Jonas Stienen committed
96 97 98 99 100 101 102

//! Aufrundende Ganzzahl-Division
/**
 * Fährt die Ganzzahl-Division c=a/b durch. Falls b nicht a teil
 * (d.h. es bleibt ein Rest a mod b != 0 übrig), so wird c um
 * eins inkrementiert. Danach gibt die Funktion c zurück
 *
103
 * Anwendungen: Wieviele Blöcke der Länge b sind erforderlich
Jonas Stienen's avatar
Jonas Stienen committed
104 105
 *              um ein Signal der Länge l zu beschreiben: uprdiv(l, b)
 */
106
ITA_BASE_API int uprdiv( const int a, const int b );
Jonas Stienen's avatar
Jonas Stienen committed
107 108 109 110 111

//! Aufrundende Ganzzahl-Division
/**
 * Variante von uprdiv für vorzeichenlose Ganzzahlen.
 */
112
ITA_BASE_API unsigned int uprdivu( const unsigned int a, const unsigned int b );
Jonas Stienen's avatar
Jonas Stienen committed
113 114 115 116 117 118 119

//! Einen (beliebigen) Winkel ins Interval (-180,180] abbilden
/**
 * Beispiel: correctAngle(380°) = 20°
 * \note Der exakte Wert -180 wird durch die Funktion erhalten
 *       und nicht auf +180 abgebildet (Ästethik :-))
 */
120
ITA_BASE_API float correctAngle180( const float fPhiDeg );
Jonas Stienen's avatar
Jonas Stienen committed
121 122 123 124 125

//! Einen (beliebigen) Winkel ins Interval [0,360) abbilden
/**
 * Beispiel: correctAngle(380°) = 20°
 */
126
ITA_BASE_API float correctAngle360( const float fPhiDeg );
Jonas Stienen's avatar
Jonas Stienen committed
127 128 129 130 131 132 133 134 135

//! Verhältnis in Dezibel (Energie) (im 10er-Logarithmus) umrechnen
/**
 * \param db Dezibel (Wertebereich: -Unendlich..+Unendlich)
 * \return Verhältnis (Wertebereich: 0..+Unendlich)
 *
 * \note Für die symbolische Konstante DECIBEL_MINUS_INFINITY gibt die
 *       Funktion den Wert 0 zurück.
 */
136
ITA_BASE_API double db10_to_ratio( const double db );
Jonas Stienen's avatar
Jonas Stienen committed
137 138 139 140 141 142 143 144 145 146 147 148

//! Dezibel (Energie) (im 10er-Logarithmus) in Verhältnis umrechnen
/**
 * \param Verhältnis (Wertebereich: 0..+Unendlich)
 * \return db Dezibel (Wertebereich: -Unendlich..+Unendlich)
 *
 * \note Für den Wert 0 gibt die Funktion die die symbolische Konstante
 *       DECIBEL_MINUS_INFINITY zurück.
 *
 * \important Negative Verhältnisse sind nicht erlaubt. In diesem
 *            Falle wird eine ITAException (INVALID_PARAMETER) ausgelöst!
 */
149
ITA_BASE_API double ratio_to_db10( const double r );
Jonas Stienen's avatar
Jonas Stienen committed
150 151 152 153 154 155 156 157 158 159


//! Verhältnis in Dezibel (Spannung) (im 10er-Logarithmus) umrechnen
/**
 * \param db Dezibel (Wertebereich: -Unendlich..+Unendlich)
 * \return Verhältnis (Wertebereich: 0..+Unendlich)
 *
 * \note Für die symbolische Konstante DECIBEL_MINUS_INFINITY gibt die
 *       Funktion den Wert 0 zurück.
 */
160
ITA_BASE_API double db20_to_ratio( const double db );
Jonas Stienen's avatar
Jonas Stienen committed
161 162 163 164 165 166 167 168 169 170 171 172

//! Dezibel (Spannung) (im 10er-Logarithmus) in Verhältnis umrechnen
/**
 * \param Verhältnis (Wertebereich: 0..+Unendlich)
 * \return db Dezibel (Wertebereich: -Unendlich..+Unendlich)
 *
 * \note Für den Wert 0 gibt die Funktion die die symbolische Konstante
 *       DECIBEL_MINUS_INFINITY zurück.
 *
 * \important Negative Verhältnisse sind nicht erlaubt. In diesem
 *            Falle wird eine ITAException (INVALID_PARAMETER) ausgelöst!
 */
173
ITA_BASE_API double ratio_to_db20( const double r );
Jonas Stienen's avatar
Jonas Stienen committed
174 175 176 177 178 179 180 181

/* +------------------------------------+
   |                                    |
   |   Funktionen für komplexe Zahlen   |
   |                                    |
   +------------------------------------+ */

//! Betrag einer komplexen Zahl berechnen
182 183 184 185 186
/**
  * @param[in] fReal Real part
  * @param[in] fImag Imaginary part
  */
ITA_BASE_API float cabsf( const float fReal, const float fImag );
Jonas Stienen's avatar
Jonas Stienen committed
187 188

//! Phase einer komplexen Zahl berechnen
189
ITA_BASE_API float canglef( const float fReal, const float fImag );
Jonas Stienen's avatar
Jonas Stienen committed
190 191

//! Betrag einer komplexen Zahl setzen, deren Phase aber erhalten (auch in-place)
192
ITA_BASE_API void csabsparg( const float fInReal, const float fInImag, const float fTargetAbs, float& fOutReal, float& fOutImag );
Jonas Stienen's avatar
Jonas Stienen committed
193 194

//! Winkel einer komplexen Zahl setzen, deren Betrag aber erhalten (auch in-place)
195
ITA_BASE_API void csargpabs( const float fInReal, const float fInImag, const float fTargetAbs, float& fOutReal, float& fOutImag );
Jonas Stienen's avatar
Jonas Stienen committed
196 197

//! Winkel im Bogenmaß in Grad [°] umrechnen
198
ITA_BASE_API float rad2gradf( const float fPhiRad );
Jonas Stienen's avatar
Jonas Stienen committed
199 200

//! Winkel im Bogenmaß in Grad [°] umrechnen
201
ITA_BASE_API double rad2grad( const double dPhiRad );
Jonas Stienen's avatar
Jonas Stienen committed
202 203

//! Winkel in Grad [°] ins Bogenmaß umrechnen
204
ITA_BASE_API float grad2radf( const float fPhiDeg );
Jonas Stienen's avatar
Jonas Stienen committed
205 206

//! Winkel im Bogenmaß in Grad [°] umrechnen
207
ITA_BASE_API double grad2rad( const double dPhiDeg );
Jonas Stienen's avatar
Jonas Stienen committed
208 209 210 211 212 213 214


/* ---------- RAD ----------- */

//! Einen Winkel (rad) in das Intervall [0, 2PI) projezieren
/**
 * Projeziert einen Winkel in Rad [rad] (nicht Grad) in das Intervall [0,2*PI) und
215
 * setzt somit negative Winkel (gegen den UZS) in positive (im UZS) um und entfernt
Jonas Stienen's avatar
Jonas Stienen committed
216 217 218 219
 * Mehrfachumdrehungen.
 *
 * Beispiele: 0->0, 2*PI->0, (-2*PI)->0, (2*PI+0.1)->0.1, (-0.1)->(2*PI-0.1)
 */
220
ITA_BASE_API float anglef_proj_0_2PI( const float fAlphaRad );
Jonas Stienen's avatar
Jonas Stienen committed
221 222 223 224 225 226 227 228 229 230

//! Einen Winkel (rad) in das Intervall (-PI, PI] projezieren
/**
 * Projeziert einen Winkel in Rad [rad] (nicht Grad) in das Intervall (-PI,PI] und
 * setzt somit negative Winkel über -PI (gegen den UZS) in positive (im UZS) um sowie
 * positive Winkel über PI (im UZS) in negative (gegen UZS) und entfernt Mehrfachumdrehungen.
 * Bemerkung: -PI wird auf PI abgebildet.
 *
 * Beispiele: 0->0, 2*PI->0, (-2*PI)->0, (PI+0.1)->(-PI+0.1), (-PI-0.1)->(PI-0.1)
 */
231
ITA_BASE_API float anglef_proj_NPI_PI( const float fAlphaRad );
Jonas Stienen's avatar
Jonas Stienen committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251

//! (Gerichtete) minimale Winkeldifferenz für zwei Winkel [rad] (nicht Grad) im Intervall [0,2PI)
/**
 * Für zwei gegebene Winkel 0<=alpha, beta<2*PI im Interval [0,2*PI) berechnet
 * die Funktion den betragskleinsten Winkel gamma, um den der Winkel alpha (weiter)gedreht
 * werden muss, um den Wert des Winkels beta zu erreichen. Dies kann durch Linksdrehung
 * (im UZS, positiver Drehwinkel gamma) oder Rechtsdrehung (gegen UZS, negativer Drehwinkel gamma)
 * geschehen. Die Funktion berechnet den betragskleinsten Drehwinkel (im UZS oder gegen den UZS)
 * und gibt ihn zurück. Das Ergebnis ist also die Drehung um den geringstmöglichen Winkel um
 * alpha in beta zu überführen.
 *
 * \return Minimaler Differenzwinkel (negatives Vorzeichen = Linksdrehung, positives Vorzeichen = Rechtsdrehung)
 *
 * \note Im Gegensatz zur Funktion anglef_mindiff_abs_0_2PI gibt hier das Vorzeichen die
 *       Drehrichtung an.
 *
 * \note Die Funktion ist nicht kommutativ: f(a,b) != f(b,a)
 *
 * Beispiele: (0,PI/2) -> PI/2, (PI/5,PI/4) -> PI/20, (PI/3,PI/4) -> -PI/12, (0,2*PI-0.1) -> -0.1
 */
252
ITA_BASE_API float anglef_mindiff_0_2PI( const float alpha, const float beta );
Jonas Stienen's avatar
Jonas Stienen committed
253 254 255 256 257 258 259 260 261 262 263 264 265

//! Absolute minimale Winkeldifferenz für zwei Winkel [rad] im Intervall [0,2PI)
/**
 * Für zwei gegebene Winkel 0<=alpha, beta<2*PI im Interval [0,2*PI) berechnet
 * die Funktion den minimalen Differenzwinkel. Dieser Winkel ist der kleinste Winkel
 * um den einer der beiden Winkel rotiert werden muss, um den Wert des anderen Winkels
 * zu erreichen. Hierbei wird keine Drehrichtung beachtet und der Rückgabewert ist
 * stets positiv.
 *
 * \note Die Funktion ist kommutativ: f(a,b) = f(b,a)
 *
 * Beispiele: (0,PI/2) -> PI/2, (PI/2,PI/3) -> PI/6, (PI/3,PI/2) -> PI/6, (0,2*PI-0.1) -> 0.1
 */
266
ITA_BASE_API float anglef_mindiff_abs_0_2PI( const float alpha, const float beta );
Jonas Stienen's avatar
Jonas Stienen committed
267 268 269 270 271 272

/* ---------- GRAD ---------- */

//! Einen Winkel [°] in das Intervall [0°,360°) projezieren
/**
 * Projeziert einen Winkel in Grad [°] (nicht Bogenmaß) in das Intervall [0°,360°) und
273
 * setzt somit negative Winkel (gegen den UZS) in positive (im UZS) um und entfernt
Jonas Stienen's avatar
Jonas Stienen committed
274 275 276 277
 * Mehrfachumdrehungen.
 *
 * Beispiele: 0°->0°, 360°->0°, -360°->0°, 361°->1°, -1°->359°
 */
278
ITA_BASE_API float anglef_proj_0_360_DEG( const float alpha );
Jonas Stienen's avatar
Jonas Stienen committed
279 280 281 282 283 284 285 286 287 288

//! Einen Winkel (°) in das Intervall (-180°, 180°] projezieren
/**
 * Projeziert einen Winkel in Grad [°] (nicht Bogenmaß) in das Intervall (-180°,180°] und
 * setzt somit negative Winkel über -PI (gegen den UZS) in positive (im UZS) um sowie
 * positive Winkel über PI (im UZS) in negative (gegen UZS) und entfernt Mehrfachumdrehungen.
 * Bemerkung: -180° wird auf 180° abgebildet.
 *
 * Beispiele: 0°->0°, 360°->0°, -360°->0°, 181°->-179°, -181°->179°
 */
289
ITA_BASE_API float anglef_proj_N180_180_DEG( const float alpha );
Jonas Stienen's avatar
Jonas Stienen committed
290

291 292 293
//! Project an angle into interval of -90 and 90 degree
ITA_BASE_API float anglef_proj_N90_90_DEG( const float alpha );

Jonas Stienen's avatar
Jonas Stienen committed
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
//! (Gerichtete) minimale Winkeldifferenz für zwei Winkel [°] im Intervall [0°,360°)
/**
 * Für zwei gegebene Winkel 0°<= alpha, beta < 360° im Interval [0°,360°) berechnet
 * die Funktion den betragskleinsten Winkel gamma, um den der Winkel alpha (weiter)gedreht
 * werden muss, um den Wert des Winkels beta zu erreichen. Dies kann durch Linksdrehung
 * (im UZS, positiver Drehwinkel gamma) oder Rechtsdrehung (gegen UZS, negativer Drehwinkel gamma)
 * geschehen. Die Funktion berechnet den betragskleinsten Drehwinkel (im UZS oder gegen den UZS)
 * und gibt ihn zurück. Das Ergebnis ist also die Drehung um den geringstmöglichen Winkel um
 * alpha in beta zu überführen.
 *
 * \return Minimaler Differenzwinkel (negatives Vorzeichen = Linksdrehung, positives Vorzeichen = Rechtsdrehung)
 *
 * \note Im Gegensatz zur Funktion anglef_mindiff_abs_0_360_DEG gibt hier das Vorzeichen die
 *       Drehrichtung an.
 *
 * \note Die Funktion ist nicht kommutativ: f(a,b) != f(b,a)
 *
 * Beispiele: (0°,90°) -> 90°, (45°,70°) -> 25°, (70°,45°) -> -25°, (0°,359°) -> -1°
 */
313
ITA_BASE_API float anglef_mindiff_0_360_DEG( const float alpha, const float beta );
Jonas Stienen's avatar
Jonas Stienen committed
314 315 316 317 318 319 320 321 322 323 324 325 326

//! Absolute minimale Winkeldifferenz für zwei Winkel [°] im Intervall [0°,360°)
/**
 * Für zwei gegebene Winkel 0°<= alpha, beta < 360° im Interval [0°,360°) berechnet
 * die Funktion den minimalen Differenzwinkel. Dieser Winkel ist der kleinste Winkel
 * um den einer der beiden Winkel rotiert werden muss, um den Wert des anderen Winkels
 * zu erreichen. Hierbei wird keine Drehrichtung beachtet und der Rückgabewert ist
 * stets positiv.
 *
 * \note Die Funktion ist kommutativ: f(a,b) = f(b,a)
 *
 * Beispiele: (0°,90°) -> 90°, (45°,70°) -> 25°, (70°,45°) -> 25°, (0°,359°) -> 1°
 */
327
ITA_BASE_API float anglef_mindiff_abs_0_360_DEG( const float alpha, const float beta );
Jonas Stienen's avatar
Jonas Stienen committed
328 329


330 331
//! Orientierung in Yaw-Pitch-Roll Winkeln in View-Up-Vektor umrechnen (Alle Winkel in Bogenmaß)
ITA_BASE_API void convertYPR2VU( const double yaw, const double pitch, const double roll, double& vx, double& vy, double& vz, double& ux, double& uy, double& uz );
Jonas Stienen's avatar
Jonas Stienen committed
332

333 334
//! Orientierung in Yaw-Pitch-Roll Winkeln in View-Up-Vektor umrechnen (Alle Winkel in Bogenmaß)
ITA_BASE_API void convertYPR2VU( const float yaw, const float pitch, const float roll, float& vx, float& vy, float& vz, float& ux, float& uy, float& uz );
Jonas Stienen's avatar
Jonas Stienen committed
335 336

// Orientierung in View-Up-Vektor in Yaw-Pitch-Roll Winkeln umrechnen (Alle Winkel in Bogenmaß)
337
ITA_BASE_API void convertVU2YPR( const double vx, const double vy, const double vz,
Jonas Stienen's avatar
Jonas Stienen committed
338
	const double ux, const double uy, const double uz,
339
	double& yaw, double& pitch, double& roll );
Jonas Stienen's avatar
Jonas Stienen committed
340

341 342
//! Orientierung in View-Up-Vektor in Yaw-Pitch-Roll Winkeln umrechnen (Alle Winkel in Bogenmaß)
ITA_BASE_API void convertVU2YPR( const float vx, const float vy, const float vz, const float ux, const float uy, const float uz, float& yaw, float& pitch, float& roll );
Jonas Stienen's avatar
Jonas Stienen committed
343

344
//! Datenklasse für Fehlerwerte
345 346 347
template< typename T >
class ITA_BASE_API ErrorValues
{
Jonas Stienen's avatar
Jonas Stienen committed
348 349 350 351 352 353 354
public:
	T minAbsError;
	T avgAbsError;
	T maxAbsError;

	int indexMaxAbsError;	// Index of element where max abs error

355 356 357 358 359 360
	inline ErrorValues()
		: minAbsError( 0 )
		, avgAbsError( 0 )
		, maxAbsError( 0 )
		, indexMaxAbsError( 0 )
	{};
Jonas Stienen's avatar
Jonas Stienen committed
361 362
};

363
//! Fehler zwischen zwei Vektoren berechnen
364 365
template< typename Tc, typename Ta, typename Tb >
inline ErrorValues<Tc> computeErrorValues( const Ta* A, const Tb* B, const int size )
Jonas Stienen's avatar
Jonas Stienen committed
366 367
{
	ErrorValues<Tc> v;
368
	if( size == 0 ) return v;
Jonas Stienen's avatar
Jonas Stienen committed
369

370
	Tb absErr = std::abs( ( Tc ) A[ 0 ] - ( Tc ) B[ 0 ] );
Jonas Stienen's avatar
Jonas Stienen committed
371 372
	v.minAbsError = v.avgAbsError = v.maxAbsError = absErr;

373 374
	for( int i = 1; i < size; ++i )
	{
375 376 377
		absErr = std::abs( ( Tc ) A[ i ] - ( Tc ) B[ i ] );
		v.minAbsError = std::min( v.minAbsError, absErr );

378 379
		if( absErr > v.maxAbsError )
		{
Jonas Stienen's avatar
Jonas Stienen committed
380 381 382 383 384 385 386 387 388 389 390 391
			v.maxAbsError = absErr;
			v.indexMaxAbsError = i;
		}

		v.avgAbsError += absErr;
	}
	v.avgAbsError /= size;

	return v;
};


392
//! Fills a vector with numbers dest = { a+n*s < b | n in N }
393 394
template< typename T > inline void linspace( std::vector< T >& dest, T a, T b, T s = 1 )
{
Jonas Stienen's avatar
Jonas Stienen committed
395
	dest.clear();
396 397
	if( s == 0 )
	{
398
		dest.push_back( a );
Jonas Stienen's avatar
Jonas Stienen committed
399 400 401
		return;
	}

402 403 404 405
	if( s < 0 )
	{
		if( a < b )
			return; // No elements contained
406
		dest.reserve( ( a - b ) / s + 1 );
407 408
		for( T x = a; x >= b; x += s )
			dest.push_back( x );
409
	}
410 411 412 413
	else
	{
		if( a > b )
			return; // No elements contained
414
		dest.reserve( ( b - a ) / s + 1 );
415 416
		for( T x = a; x <= b; x += s )
			dest.push_back( x );
Jonas Stienen's avatar
Jonas Stienen committed
417 418 419
	}
};

420 421 422 423
//! Fills a vector with powers of two in the range a=2^i <= 2^j <= 2^k=b
/**
  * @note a and b must be powers of two, otherwise an exception is thrown)
  */
424
ITA_BASE_API void pow2space( std::vector< int >& dest, const int a, const int b );
Jonas Stienen's avatar
Jonas Stienen committed
425

426 427
//! Returns the elevation angle (0 = frontal direction) in radians from a polar angle theta (0 = above)
ITA_BASE_API double theta2elevation( const double dThetaRAD );
428

429 430
//! returns the polar angle theta (0 = above) in radians from a given elevation angle (0 = frontal direction)
ITA_BASE_API double elevation2theta( const double dElevationRAD );
431

Jonas Stienen's avatar
Jonas Stienen committed
432
// Calculates the factorial of an positive integer m
433
ITA_BASE_API int factorial( const int m );
Jonas Stienen's avatar
Jonas Stienen committed
434

435
//! Calculates the normalizing constant for SHRealvaluedBasefunctions
436
ITA_BASE_API double SHNormalizeConst( const int m, const int n );
Jonas Stienen's avatar
Jonas Stienen committed
437

438
//! Calculates the Kronecker delta
439
ITA_BASE_API int SHKronecker( const int m );
Jonas Stienen's avatar
Jonas Stienen committed
440

441
//! Returns the linear index of a basefunction with degree m and order n, linear indexing starts with 0
442
ITA_BASE_API int SHDegreeOrder2Linear( const int m, const int n );
Jonas Stienen's avatar
Jonas Stienen committed
443

444 445
//! Returns degree and order of a basefunctions from a linear index, linear indexing starts with 0
ITA_BASE_API void SHLinear2DegreeOrder( const int iLinear, int &m, int &n );
446

447 448
//! Calculates the remax weightings up to a given order
ITA_BASE_API std::vector< double > HOARemaxWeights( int iTruncationOrder );
449

450 451
//! Calculates the realvalued Basefunctions of SH for e.g. Ambisonics
ITA_BASE_API std::vector< double > SHRealvaluedBasefunctions( const double thetaRAD, const double azimuthRAD, const int maxOrder );
Jonas Stienen's avatar
Jonas Stienen committed
452

453 454
//! Calculates the associated legendre polynomials
ITA_BASE_API std::vector< double > SHAssociatedLegendre( const int N, const double mu );
Jonas Stienen's avatar
Jonas Stienen committed
455 456

#endif // INCLUDE_WATCHER_ITA_NUMERIC_UTILS