maths.h

Go to the documentation of this file.

 
#ifndef _MATHS_H_
#define _MATHS_H_
 
 
 
// 1° step is enough for FIX16
extern const fix16 trigtab_f16[90 + 1];
// 0.25° step is ok for fix32
extern const fix32 trigtab_f32[(90 * 4) + 1];
 
extern const fix16 log2tab_f16[0x10000];
extern const fix16 log10tab_f16[0x10000];
extern const fix16 sqrttab_f16[0x10000];
 
 
#ifndef PI
#define PI                          3.14159265358979323846
#endif
 
 
#define FIX16_INT_BITS              10
#define FIX16_FRAC_BITS             (16 - FIX16_INT_BITS)
#define FIX16_INT_MASK              (((1 << FIX16_INT_BITS) - 1) << FIX16_FRAC_BITS)
#define FIX16_FRAC_MASK             ((1 << FIX16_FRAC_BITS) - 1)
 
#define FIX32_INT_BITS              22
#define FIX32_FRAC_BITS             (32 - FIX32_INT_BITS)
#define FIX32_INT_MASK              (((1 << FIX32_INT_BITS) - 1) << FIX32_FRAC_BITS)
#define FIX32_FRAC_MASK             ((1 << FIX32_FRAC_BITS) - 1)
 
#define FASTFIX16_INT_BITS          8
#define FASTFIX16_FRAC_BITS         (16 - FASTFIX16_INT_BITS)
#define FASTFIX16_INT_MASK          (((1 << FASTFIX16_INT_BITS) - 1) << FASTFIX16_FRAC_BITS)
#define FASTFIX16_FRAC_MASK         ((1 << FASTFIX16_FRAC_BITS) - 1)
 
#define FASTFIX32_INT_BITS          16
#define FASTFIX32_FRAC_BITS         (32 - FASTFIX32_INT_BITS)
#define FASTFIX32_INT_MASK          (((1 << FASTFIX32_INT_BITS) - 1) << FASTFIX32_FRAC_BITS)
#define FASTFIX32_FRAC_MASK         ((1 << FASTFIX32_FRAC_BITS) - 1)

#define FIX16(value)                ((fix16) ((value) * (1 << FIX16_FRAC_BITS)))
#define FIX32(value)                ((fix32) ((value) * (1 << FIX32_FRAC_BITS)))

#define FASTFIX16(value)            ((fastfix16) ((value) * (1 << FASTFIX16_FRAC_BITS)))
#define FASTFIX32(value)            ((fastfix32) ((value) * (1 << FASTFIX32_FRAC_BITS)))

#define F16(value)                  FIX16(value)
#define F32(value)                  FIX32(value)
#define FF16(value)                 FASTFIX16(value)
#define FF32(value)                 FASTFIX32(value)
 
 
#define F16_PI                      ((fix16) F16(PI))
#define F16_RAD_TO_DEG              F16(57.29577951308232)
 
#define F32_PI                      ((fix32) F32(PI))
 
 
// 2D base structures

typedef struct
{
    u16 x;
    u16 y;
} Vect2D_u16;

typedef struct
{
    s16 x;
    s16 y;
} Vect2D_s16;

typedef struct
{
    u32 x;
    u32 y;
} Vect2D_u32;

typedef struct
{
    s32 x;
    s32 y;
} Vect2D_s32;

typedef struct
{
    fix16 x;
    fix16 y;
} Vect2D_f16;

typedef struct
{
    fix32 x;
    fix32 y;
} Vect2D_f32;

typedef struct
{
    fastfix16 x;
    fastfix16 y;
} Vect2D_ff16;

typedef struct
{
    fastfix32 x;
    fastfix32 y;
} Vect2D_ff32;

typedef struct
{
    Vect2D_f16 a;
    Vect2D_f16 b;
} Mat2D_f16;

typedef struct
{
    Vect2D_f32 a;
    Vect2D_f32 b;
} Mat2D_f32;

typedef struct
{
    Vect2D_ff16 a;
    Vect2D_ff16 b;
} Mat2D_ff16;

typedef struct
{
    Vect2D_ff32 a;
    Vect2D_ff32 b;
} Mat2D_ff32;
 
// short alias

typedef Vect2D_u16 V2u16;
typedef Vect2D_s16 V2s16;
typedef Vect2D_u32 V2u32;
typedef Vect2D_s32 V2s32;
typedef Vect2D_f16 V2f16;
typedef Vect2D_f32 V2f32;
typedef Vect2D_ff16 V2ff16;
typedef Vect2D_ff32 V2ff32;
typedef Mat2D_f16 M2f16;
typedef Mat2D_f32 M2f32;
typedef Mat2D_ff16 M2ff16;
typedef Mat2D_ff32 M2ff32;

//  Basic math functions

#define min(X, Y)       (((X) < (Y))?(X):(Y))

#define max(X, Y)       (((X) > (Y))?(X):(Y))

#define clamp(X, L, H)  (min(max((X), (L)), (H)))
 
#if (ENABLE_NEWLIB == 0)
#define abs(X)          (((X) < 0)?-(X):(X))
#endif  // ENABLE_NEWLIB
 

u8  rol8(u8 value, u16 number);
u16 rol16(u16 value, u16 number);
u32 rol32(u32 value, u16 number);
u8  ror8(u8 value, u16 number);
u16 ror16(u16 value, u16 number);
u32 ror32(u32 value, u16 number);

u32 mulu(u16 op1, u16 op2);
s32 muls(s16 op1, s16 op2);
u16 divu(u32 op1, u16 op2);
s16 divs(s32 op1, s16 op2);
u16 modu(u32 op1, u16 op2);
s16 mods(s32 op1, s16 op2);

u32 divmodu(u32 op1, u16 op2);
s32 divmods(s32 op1, s16 op2);

u32 u16ToBCD(u16 value);
u32 u32ToBCD(u32 value);

u32 getNextPow2(u32 value);
u16 getLog2(u32 value);

u32 getApproximatedDistance(s32 dx, s32 dy);
u32 getApproximatedDistanceV(V2s32* v);
 
 
#define distance_approx(dx, dy)     _Pragma("GCC error \"This method is deprecated, use getApproximatedDistance(..) instead.\"")
#define getApproximatedLog2(value)  _Pragma("GCC error \"This method is deprecated, use FF32_getLog2Fast(..) instead.\"")
#define getLog2Int(value)           _Pragma("GCC error \"This method is deprecated, use getLog2(..) instead.\"")
 

//  Fix16 Fixed point math functions

s16 F16_toInt(fix16 value);
fix32 F16_toFix32(fix16 value);
fastfix16 F16_toFastFix16(fix16 value);
fastfix32 F16_toFastFix32(fix16 value);
fix16 F16_frac(fix16 value);
fix16 F16_int(fix16 value);
fix16 F16_abs(fix16 x);
fix16 F16_round(fix16 value);
s16 F16_toRoundedInt(fix16 value);

fix16 F16_mul(fix16 val1, fix16 val2);
fix16 F16_div(fix16 val1, fix16 val2);
fix16 F16_avg(fix16 val1, fix16 val2);

fix16 F16_log2(fix16 value);
fix16 F16_log10(fix16 value);
fix16 F16_sqrt(fix16 value);

fix16 F16_normalizeAngle(fix16 angle);
fix16 F16_sin(fix16 angle);
fix16 F16_cos(fix16 angle);
fix16 F16_tan(fix16 angle);
fix16 F16_atan(fix16 x);
fix16 F16_atan2(fix16 y, fix16 x);

fix16 sinFix16(u16 value);
fix16 cosFix16(u16 value);

fix16 F16_degreeToRadian(fix16 degree);
fix16 F16_radianToDegree(fix16 radian);
fix16 F16_getAngle(fix16 x1, fix16 y1, fix16 x2, fix16 y2);
void F16_computePosition(fix16 *x2, fix16 *y2, fix16 x1, fix16 y1, fix16 ang, fix16 dist);
void F16_computePositionEx(fix16 *x2, fix16 *y2, fix16 x1, fix16 y1, fix16 ang, fix16 dist, fix16 cosMul, fix16 sinMul);
 
 
// Deprecated functions
#define intToFix16(a)           _Pragma("GCC error \"This method is deprecated, use FIX16(..) instead.\"")
#define fix16ToInt(a)           _Pragma("GCC error \"This method is deprecated, use F16_toInt(..) instead.\"")
#define fix16ToFix32(a)         _Pragma("GCC error \"This method is deprecated, use F16_toFix32(..) instead.\"")
#define fix16Frac(a)            _Pragma("GCC error \"This method is deprecated, use F16_frac(..) instead.\"")
#define fix16Int(a)             _Pragma("GCC error \"This method is deprecated, use F16_int(..) instead.\"")
#define fix16Round(a)           _Pragma("GCC error \"This method is deprecated, use F16_round(..) instead.\"")
#define fix16ToRoundedInt(a)    _Pragma("GCC error \"This method is deprecated, use F16_toRoundedInt(..) instead.\"")
#define fix16Add(a, b)          _Pragma("GCC error \"This method is deprecated, simply use '+' operator to add fix16 values together.\"")
#define fix16Sub(a, b)          _Pragma("GCC error \"This method is deprecated, simply use '-' operator to subtract fix16 values.\"")
#define fix16Neg(a)             _Pragma("GCC error \"This method is deprecated, simply use '0 - value' to get the negative fix16 value.\"")
#define fix16Mul(a, b)          _Pragma("GCC error \"This method is deprecated, use F16_mul(..) instead.\"")
#define fix16Div(a, b)          _Pragma("GCC error \"This method is deprecated, use F16_div(..) instead.\"")
#define fix16Avg(a, b)          _Pragma("GCC error \"This method is deprecated, use F16_avg(..) instead.\"")
#define fix16Log2(a)            _Pragma("GCC error \"This method is deprecated, use F16_log2(..) instead.\"")
#define fix16Log10(a)           _Pragma("GCC error \"This method is deprecated, use F16_log10(..) instead.\"")
#define fix16Sqrt(a)            _Pragma("GCC error \"This method is deprecated, use F16_sqrt(..) instead.\"")
 

//  Fix32 Fixed point math functions

s32 F32_toInt(fix32 value);
fix16 F32_toFix16(fix32 value);
fastfix16 F32_toFastFix16(fix32 value);
fastfix32 F32_toFastFix32(fix32 value);
fix32 F32_frac(fix32 value);
fix32 F32_int(fix32 value);
fix32 F32_round(fix32 value);
s32 F32_toRoundedInt(fix32 value);

fix32 F32_mul(fix32 val1, fix32 val2);
fix32 F32_div(fix32 val1, fix32 val2);
fix32 F32_avg(fix32 val1, fix32 val2);

fix32 F32_sin(fix16 angle);
fix32 F32_cos(fix16 angle);

fix32 sinFix32(u16 value);
fix32 cosFix32(u16 value);
 
 
// Deprecated functions
#define intToFix32(a)           _Pragma("GCC error \"This method is deprecated, use FIX32(..) instead.\"")
#define fix32ToInt(a)           _Pragma("GCC error \"This method is deprecated, use F32_toInt(..) instead.\"")
#define fix32ToFix16(a)         _Pragma("GCC error \"This method is deprecated, use F32_toFix16(..) instead.\"")
#define fix32Frac(a)            _Pragma("GCC error \"This method is deprecated, use F32_frac(..) instead.\"")
#define fix32Int(a)             _Pragma("GCC error \"This method is deprecated, use F32_int(..) instead.\"")
#define fix32Round(a)           _Pragma("GCC error \"This method is deprecated, use F32_round(..) instead.\"")
#define fix32ToRoundedInt(a)    _Pragma("GCC error \"This method is deprecated, use F32_toRoundedInt(..) instead.\"")
#define fix32Add(a, b)          _Pragma("GCC error \"This method is deprecated, simply use '+' operator to add fix32 values together.\"")
#define fix32Sub(a, b)          _Pragma("GCC error \"This method is deprecated, simply use '-' operator to subtract fix32 values.\"")
#define fix32Neg(a)             _Pragma("GCC error \"This method is deprecated, simply use '0 - value' to get the negative fix32 value.\"")
#define fix32Mul(a, b)          _Pragma("GCC error \"This method is deprecated, use F32_mul(..) instead.\"")
#define fix32Div(a, b)          _Pragma("GCC error \"This method is deprecated, use F32_div(..) instead.\"")
#define fix32Avg(a, b)          _Pragma("GCC error \"This method is deprecated, use F32_avg(..) instead.\"")
 

//  Fast Fix16 Fixed point math functions

s16 FF16_toInt(fastfix16 value);
fix16 FF16_toFix16(fastfix16 value);
fix32 FF16_toFix32(fastfix16 value);
fastfix32 FF16_toFastFix32(fastfix16 value);
fastfix16 FF16_frac(fastfix16 value);
fastfix16 FF16_int(fastfix16 value);
fastfix16 FF16_round(fastfix16 value);
s16 FF16_toRoundedInt(fastfix16 value);

fastfix16 FF16_mul(fastfix16 val1, fastfix16 val2);
fastfix16 FF16_div(fastfix16 val1, fastfix16 val2);
 
 
// Deprecated functions
#define intToFastFix16(a)           _Pragma("GCC error \"This method is deprecated, use FASTFIX16(..) instead.\"")
#define fastFix16ToInt(a)           _Pragma("GCC error \"This method is deprecated, use FF16_toInt(..) instead.\"")
#define fastFix16Frac(a)            _Pragma("GCC error \"This method is deprecated, use FF16_frac(..) instead.\"")
#define fastFix16Int(a)             _Pragma("GCC error \"This method is deprecated, use FF16_int(..) instead.\"")
#define fastFix16Round(a)           _Pragma("GCC error \"This method is deprecated, use FF16_round(..) instead.\"")
#define fastFix16ToRoundedInt(a)    _Pragma("GCC error \"This method is deprecated, use FF16_toRoundedInt(..) instead.\"")
#define fastFix16Mul(a, b)          _Pragma("GCC error \"This method is deprecated, use FF16_mul(..) instead.\"")
#define fastFix16Div(a, b)          _Pragma("GCC error \"This method is deprecated, use FF16_div(..) instead.\"")
 

//  Fast Fix32 Fixed point math functions

fastfix32 FF32_fromInt(s16 value);
s16 FF32_toInt(fastfix32 value);
fix16 FF32_toFix16(fastfix32 value);
fix32 FF32_toFix32(fastfix32 value);
fastfix16 FF32_toFastFix16(fastfix32 value);
fastfix32 FF32_frac(fastfix32 value);
fastfix32 FF32_int(fastfix32 value);
fastfix32 FF32_round(fastfix32 value);
s32 FF32_toRoundedInt(fastfix32 value);

fastfix32 FF32_mul(fastfix32 val1, fastfix32 val2);
fastfix32 FF32_div(fastfix32 val1, fastfix32 val2);

fastfix32 FF32_getLog2Fast(fastfix32 value);
 
 
// Deprecated functions
#define intToFastFix32(a)           _Pragma("GCC error \"This method is deprecated, use FASTFIX32(..) instead.\"")
#define fastFix32ToInt(a)           _Pragma("GCC error \"This method is deprecated, use FF32_toInt(..) instead.\"")
#define fastFix32Frac(a)            _Pragma("GCC error \"This method is deprecated, use FF32_frac(..) instead.\"")
#define fastFix32Int(a)             _Pragma("GCC error \"This method is deprecated, use FF32_int(..) instead.\"")
#define fastFix32Round(a)           _Pragma("GCC error \"This method is deprecated, use FF32_round(..) instead.\"")
#define fastFix32ToRoundedInt(a)    _Pragma("GCC error \"This method is deprecated, use FF32_toRoundedInt(..) instead.\"")
#define fastFix32Mul(a, b)          _Pragma("GCC error \"This method is deprecated, use FF32_mul(..) instead.\"")
#define fastFix32Div(a, b)          _Pragma("GCC error \"This method is deprecated, use FF32_div(..) instead.\"")
 

//  Vector2D base math functions

fix16 V2D_F16_getAngle(V2f16* pt1, V2f16* pt2);

void V2D_F16_computePosition(V2f16* pt, fix16 ang, fix16 dist);
void V2D_F16_computePositionEx(V2f16* pt, fix16 ang, fix16 dist, fix16 cosMul, fix16 sinMUl);

u32 V2D_S32_getApproximatedDistance(V2s32* v);
 
 
// Deprecated functions
#define getApproximatedDistanceV(dx, dy)     _Pragma("GCC error \"This method is deprecated, use V2D_S32_getApproximatedDistance(..) instead.\"")
 
#endif // _MATHS_H_