Classes
union	f32_t

struct	f32pair_t

Constants
#define	M_E 2.718281828459045f

#define	M_LOG2E 1.44269504088896f

#define	M_LOG10E 0.4342944819032518f

#define	M_LN2 0.6931471805599453094f

#define	M_LN10 2.30258509299404568402f

#define	M_PI 3.141592653589793f

#define	M_TWOPI 6.283185307179586f

#define	M_PI_2 1.5707963267948966f

#define	M_PI_4 0.7853981633974483f

#define	M_1_PI 0.3183098861837907f

#define	M_2_PI 0.6366197723675814f

#define	M_4_PI 1.2732395447351627f

#define	M_1_TWOPI 0.15915494309189534f

#define	M_2_SQRTPI 1.1283791670955126f

#define	M_4_PI2 0.40528473456935109f

#define	M_SQRT2 1.41421356237309504880f

#define	M_1_SQRT2 0.7071067811865475f

Macros
#define	F32_FRAC_MASK ((1L<<23)-1)

#define	F32_EXP_MASK (((1L<<9)-1)<<23)

#define	F32_SIGN_MASK (0x80000000)

#define	f32_frac_bits(f) ((f) & F32_FRAC_MASK)

#define	f32_exp_bits(f) ((f) & F32_EXP_MASK)

#define	f32_sign_bit(f) ((f) & F32_SIGN_MASK)

Types
static f32pair_t	f32pair (const float a, const float b)
	Make a float pair.

Operations
static float	fsel (const float a, const float b, const float c)
	FSEL construct.

static uint8_t	fselb (const float a)
	FSEL boolean construct.

static uint8_t	float_is_neg (const f32_t f)
	Sign bit check.

static int32_t	float_mantissa (f32_t f)
	Obtain mantissa.

static int32_t	float_exponent (f32_t f)
	Obtain exponent.

static f32pair_t	f32pair_add (const f32pair_t p0, const f32pair_t p1)
	Pair-wise addition.

static f32pair_t	f32pair_sub (const f32pair_t p0, const f32pair_t p1)
	Pair-wise subtraction.

static f32pair_t	f32pair_addscal (const f32pair_t p, const float scl)
	Pair-wise scalar addition.

static f32pair_t	f32pair_mul (const f32pair_t p0, const f32pair_t p1)
	Pair-wise product.

static f32pair_t	f32pair_mulscal (const f32pair_t p, const float scl)
	Pair-wise scalar product.

static f32pair_t	f32pair_linint (const float fr, const f32pair_t p0, const f32pair_t p1)
	Pair-wise linear interpolation.

static float	si_copysignf (const float x, const float y)
	Return x with sign of y applied.

static float	si_fabsf (float x)
	Absolute value.

static float	si_floorf (float x)
	Floor function.

static float	si_ceilf (float x)
	Ceiling function.

static float	si_roundf (float x)
	Round to nearest integer.

static float	clampfsel (const float min, float x, const float max)

static float	clampminfsel (const float min, const float x)

static float	clampmaxfsel (const float x, const float max)

static float	clipmaxf (const float x, const float m)
	Clip upper bound of x to m (inclusive)

static float	clipminf (const float m, const float x)
	Clip lower bound of x to m (inclusive)

static float	clipminmaxf (const float min, const float x, const float max)
	Clip x to min and max (inclusive)

static float	clip0f (const float x)
	Clip lower bound of x to 0.f (inclusive)

static float	clip1f (const float x)
	Clip upper bound of x to 1.f (inclusive)

static float	clip01f (const float x)
	Clip x to [0.f, 1.f] (inclusive)

static float	clipm1f (const float x)
	Clip lower bound of x to -1.f (inclusive)

static float	clip1m1f (const float x)
	Clip x to [-1.f, 1.f] (inclusive)

Faster direct approximations of common trigonometric functions
Note Use with care. Depending on optimizations and targets these can provide little benefit over libc versions.
static float	fastsinf (float x)
	"Fast" sine approximation, valid for x in [-M_PI, M_PI] More...

static float	fastersinf (float x)
	"Faster" sine approximation, valid for x in [-M_PI, M_PI] More...

static float	fastsinfullf (float x)
	"Fast" sine approximation, valid on full x domain More...

static float	fastersinfullf (float x)
	"Faster" sine approximation, valid on full x domain More...

static float	fastcosf (float x)
	"Fast" cosine approximation, valid for x in [-M_PI, M_PI] More...

static float	fastercosf (float x)
	"Faster" cosine approximation, valid for x in [-M_PI, M_PI] More...

static float	fastcosfullf (float x)
	"Fast" cosine approximation, valid on full x domain More...

static float	fastercosfullf (float x)
	"Faster" cosine approximation, valid on full x domain More...

static float	fasttanf (float x)
	"Fast" tangent approximation, valid for x in [-M_PI_2, M_PI_2] More...

static float	fastertanf (float x)
	"Faster" tangent approximation, valid for x in [-M_PI_2, M_PI_2] More...

static float	fasttanfullf (float x)
	"Fast" tangent approximation, valid on full x domain, except where tangent diverges. More...

static float	fastertanfullf (float x)
	"Faster" tangent approximation, valid on full x domain, except where tangent diverges. More...

static float	fastlog2f (float x)
	"Fast" log base 2 approximation, valid for positive x as precision allows. More...

static float	fasterlog2f (float x)
	"Faster" log base 2 approximation, valid for positive x as precision allows. More...

static float	fastlogf (float x)
	"Fast" natural logarithm approximation, valid for positive x as precision allows. More...

static float	fasterlogf (float x)
	"Fast" natural logarithm approximation, valid for positive x as precision allows. More...

static float	fastpow2f (float p)
	"Fast" power of 2 approximation, valid for x in [ -126, ... More...

static float	fasterpow2f (float p)
	"Faster" power of 2 approximation, valid for x in [ -126, ... More...

static float	fastpowf (float x, float p)
	"Fast" x to the power of p approximation More...

static float	fasterpowf (float x, float p)
	"Faster" x to the power of p approximation More...

static float	fastexpf (float p)
	"Fast" exponential approximation, valid for x in [ ~ -87, ... More...

static float	fasterexpf (float p)
	"Faster" exponential approximation, valid for x in [ ~ -87, ... More...

static float	fasteratan2f (float y, float x)
	atan2 approximation More...

static float	fastertanhf (float x)
	Hyperbolic tangent approximation. More...

Useful Conversions
Note These can be very slow, use with caution. Should use table lookups in performance critical sections.
static float	ampdbf (const float amp)
	Amplitude to dB. More...

static float	fasterampdbf (const float amp)
	"Faster" Amplitude to dB

static float	dbampf (const float db)
	dB to ampltitude

static float	fasterdbampf (const float db)
	"Faster" dB to ampltitude

Interpolations
Todo: Add cubic/spline interpolations
static float	linintf (const float fr, const float x0, const float x1)
	Linear interpolation.

static float	cosintf (const float fr, const float x0, const float x1)
	Cosine interpolation.

Detailed Description

Function Documentation

◆ ampdbf()

static float ampdbf ( const float amp )

inlinestatic

Amplitude to dB.

Note: Will remove low boundary check in future version

Definition at line 784 of file float_math.h.

                               {
   return (amp < 0.f) ? -999.f : 20.f*log10f(amp);
 }

◆ fastcosf()

static float fastcosf ( float x )

inlinestatic

"Fast" cosine approximation, valid for x in [-M_PI, M_PI]

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 559 of file float_math.h.

                         {
   const float halfpiminustwopi = -4.7123889803846899f;
   float offset = (x > M_PI_2) ? halfpiminustwopi : M_PI_2;
   return fastsinf(x + offset);
 }

◆ fastcosfullf()

static float fastcosfullf ( float x )

inlinestatic

"Fast" cosine approximation, valid on full x domain

Note: Adapted from Paul Mineiro's FastFloat; Warning: can be slower than libc version!

Definition at line 582 of file float_math.h.

                             {
   return fastersinfullf(x + M_PI_2);
 }

◆ fasteratan2f()

static float fasteratan2f	(	float	y,
		float	x
	)

inlinestatic

atan2 approximation

Note: Adapted from http://dspguru.com/dsp/tricks/fixed-point-atan2-with-self-normalization

Definition at line 739 of file float_math.h.

                                      {
   const float coeff_1 = M_PI_4;
   const float coeff_2 = 3 * coeff_1;
   float abs_y = si_fabsf(y) + 1e-10f; // kludge to prevent 0/0 condition
   float r, angle;
   if (x >= 0) {
     r = (x - abs_y) / (x + abs_y);
     angle = coeff_1 - coeff_1 * r;
   }
   else {
     r = (x + abs_y) / (abs_y - x);
     angle = coeff_2 - coeff_1 * r;
   }
   return (y < 0) ? -angle : angle; // negate if in quad III or IV
 }

◆ fastercosf()

static float fastercosf ( float x )

inlinestatic

"Faster" cosine approximation, valid for x in [-M_PI, M_PI]

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 569 of file float_math.h.

                           {
   static const float p = 0.54641335845679634f;
   union { float f; uint32_t i; } vx = { x };
   vx.i &= 0x7FFFFFFF;
   const float qpprox = 1.0f - M_2_PI * vx.f;
   return qpprox + p * qpprox * (1.0f - qpprox * qpprox);
 }

◆ fastercosfullf()

static float fastercosfullf ( float x )

inlinestatic

"Faster" cosine approximation, valid on full x domain

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 590 of file float_math.h.

                               {
   return fastersinfullf(x + M_PI_2);
 }

◆ fasterexpf()

static float fasterexpf ( float p )

inlinestatic

"Faster" exponential approximation, valid for x in [ ~ -87, ...

as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 729 of file float_math.h.

                           {
   return fasterpow2f(1.442695040f * p);
 }

◆ fasterlog2f()

static float fasterlog2f ( float x )

inlinestatic

"Faster" log base 2 approximation, valid for positive x as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 652 of file float_math.h.

                            {
   union { float f; uint32_t i; } vx = { x };
   float y = (float)(vx.i);
   y *= 1.1920928955078125e-7f;
   return y - 126.94269504f;
 }

◆ fasterlogf()

static float fasterlogf ( float x )

inlinestatic

"Fast" natural logarithm approximation, valid for positive x as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 671 of file float_math.h.

                           {
   return 0.69314718f * fasterlog2f(x);
 }

◆ fasterpow2f()

static float fasterpow2f ( float p )

inlinestatic

"Faster" power of 2 approximation, valid for x in [ -126, ...

as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 694 of file float_math.h.

                            {
   float clipp = (p < -126) ? -126.0f : p;
   union { uint32_t i; float f; } v = { (uint32_t)( (1 << 23) * (clipp + 126.94269504f) ) };
   return v.f;
 }

◆ fasterpowf()

static float fasterpowf	(	float	x,
		float	p
	)

inlinestatic

"Faster" x to the power of p approximation

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 713 of file float_math.h.

                                    {
   return fasterpow2f(p * fasterlog2f(x));
 }

◆ fastersinf()

static float fastersinf ( float x )

inlinestatic

"Faster" sine approximation, valid for x in [-M_PI, M_PI]

Note: Adapted from Paul Mineiro's FastFloat; Warning: can be slower than libc version!

Definition at line 524 of file float_math.h.

                           {
   static const float q = 0.77633023248007499f;
   union { float f; uint32_t i; } p = { 0.22308510060189463f };
   union { float f; uint32_t i; } vx = { x };
   const uint32_t sign = vx.i & 0x80000000;
   vx.i &= 0x7FFFFFFF;
   const float qpprox = M_4_PI * x - M_4_PI2 * x * vx.f;
   p.i |= sign;
   return qpprox * (q + p.f * qpprox);
 }

◆ fastersinfullf()

static float fastersinfullf ( float x )

inlinestatic

"Faster" sine approximation, valid on full x domain

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 549 of file float_math.h.

                               {
   const int32_t k = (int32_t)(x * M_1_TWOPI);
   const float half = (x < 0) ? -0.5f : 0.5f;
   return fastersinf((half + k) * M_TWOPI - x);
 }

◆ fastertanf()

static float fastertanf ( float x )

inlinestatic

"Faster" tangent approximation, valid for x in [-M_PI_2, M_PI_2]

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 606 of file float_math.h.

                           {
   return fastcosf(x) / fastercosf(x);
 }

◆ fastertanfullf()

static float fastertanfullf ( float x )

inlinestatic

"Faster" tangent approximation, valid on full x domain, except where tangent diverges.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 626 of file float_math.h.

                               {
   const int32_t k = (int32_t)(x * M_1_TWOPI);
   const float half = (x < 0) ? -0.5f : 0.5f;
   const float xnew = x - (half + k) * M_TWOPI;
   return fastersinf(xnew)/fastercosf(xnew);
 }

◆ fastertanhf()

static float fastertanhf ( float x )

inlinestatic

Hyperbolic tangent approximation.

Note: Adapted from http://math.stackexchange.com/questions/107292/rapid-approximation-of-tanhx

Definition at line 759 of file float_math.h.

                            {
   return (-0.67436811832e-5f +
           (0.2468149110712040f +
            (0.583691066395175e-1f + 0.3357335044280075e-1f * x) * x) * x) /
     (0.2464845986383725f +
      (0.609347197060491e-1f +
       (0.1086202599228572f + 0.2874707922475963e-1f * x) * x) * x);
 }

◆ fastexpf()

static float fastexpf ( float p )

inlinestatic

"Fast" exponential approximation, valid for x in [ ~ -87, ...

as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 721 of file float_math.h.

                         {
   return fastpow2f(1.442695040f * p);
 }

◆ fastlog2f()

static float fastlog2f ( float x )

inlinestatic

"Fast" log base 2 approximation, valid for positive x as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 637 of file float_math.h.

                          {
   union { float f; uint32_t i; } vx = { x };
   union { uint32_t i; float f; } mx = { (vx.i & 0x007FFFFF) | 0x3f000000 };
   float y = vx.i;
   y *= 1.1920928955078125e-7f;
  
   return y - 124.22551499f
            - 1.498030302f * mx.f 
            - 1.72587999f / (0.3520887068f + mx.f);
 }

◆ fastlogf()

static float fastlogf ( float x )

inlinestatic

"Fast" natural logarithm approximation, valid for positive x as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 663 of file float_math.h.

                         {
   return 0.69314718f * fastlog2f(x);
 }

◆ fastpow2f()

static float fastpow2f ( float p )

inlinestatic

"Fast" power of 2 approximation, valid for x in [ -126, ...

as precision allows.

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 679 of file float_math.h.

                          {
   float clipp = (p < -126) ? -126.0f : p;
   int w = clipp;
   float z = clipp - w + 1.f;
   union { uint32_t i; float f; } v = { (uint32_t) ( (1 << 23) * 
       (clipp + 121.2740575f + 27.7280233f / (4.84252568f - z) - 1.49012907f * z)
       ) };
  
   return v.f;
 }

◆ fastpowf()

static float fastpowf	(	float	x,
		float	p
	)

inlinestatic

"Fast" x to the power of p approximation

Note: Adapted from Paul Mineiro's FastFloat; Warning: Seems to have divergent segments with discontinuities for some base/exponent combinations

Definition at line 705 of file float_math.h.

                                  {
   return fastpow2f(p * fastlog2f(x));
 }

◆ fastsinf()

static float fastsinf ( float x )

inlinestatic

"Fast" sine approximation, valid for x in [-M_PI, M_PI]

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 499 of file float_math.h.

                         {
   static const float q = 0.78444488374548933f;
   union { float f; uint32_t i; } p = { 0.20363937680730309f };
   union { float f; uint32_t i; } r = { 0.015124940802184233f };
   union { float f; uint32_t i; } s = { -0.0032225901625579573f };
  
   union { float f; uint32_t i; } vx = { x };
   uint32_t sign = vx.i & 0x80000000;
   vx.i = vx.i & 0x7FFFFFFF;
  
   float qpprox = M_4_PI * x - M_4_PI2 * x * vx.f;
   float qpproxsq = qpprox * qpprox;
  
   p.i |= sign;
   r.i |= sign;
   s.i ^= sign;
  
   return q * qpprox + qpproxsq * (p.f + qpproxsq * (r.f + qpproxsq * s.f));
 }

◆ fastsinfullf()

static float fastsinfullf ( float x )

inlinestatic

"Fast" sine approximation, valid on full x domain

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 539 of file float_math.h.

                             {
   const int32_t k = (int32_t)(x * M_1_TWOPI);
   const float half = (x < 0) ? -0.5f : 0.5f;
   return fastsinf((half + k) * M_TWOPI - x);
 }

◆ fasttanf()

static float fasttanf ( float x )

inlinestatic

"Fast" tangent approximation, valid for x in [-M_PI_2, M_PI_2]

Note: Adapted from Paul Mineiro's FastFloat

Definition at line 598 of file float_math.h.

                         {
   return fastsinf(x) / fastsinf(x + M_PI_2);
 }

◆ fasttanfullf()

static float fasttanfullf ( float x )

inlinestatic

"Fast" tangent approximation, valid on full x domain, except where tangent diverges.

Note: Adapted from Paul Mineiro's FastFloat; Warning: can be slower than libc version!

Definition at line 615 of file float_math.h.

                             {
   const int32_t k = (int32_t)(x * M_1_TWOPI);
   const float half = (x < 0) ? -0.5f : 0.5f;
   const float xnew = x - (half + k) * M_TWOPI;
   return fastsinf(xnew)/fastcosf(xnew);
 }

Classes

Constants

Macros

Types

Operations

Faster direct approximations of common trigonometric functions

Useful Conversions

Interpolations

Detailed Description

Function Documentation

◆ ampdbf()

◆ fastcosf()

◆ fastcosfullf()

◆ fasteratan2f()

◆ fastercosf()

◆ fastercosfullf()

◆ fasterexpf()

◆ fasterlog2f()

◆ fasterlogf()

◆ fasterpow2f()

◆ fasterpowf()

◆ fastersinf()

◆ fastersinfullf()

◆ fastertanf()

◆ fastertanfullf()

◆ fastertanhf()

◆ fastexpf()

◆ fastlog2f()

◆ fastlogf()

◆ fastpow2f()

◆ fastpowf()

◆ fastsinf()

◆ fastsinfullf()

◆ fasttanf()

◆ fasttanfullf()