936 lines
35 KiB
C
936 lines
35 KiB
C
/* ##H_FILE#
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
FILE : MTH_flt.h
|
|
MODULE : MTH (Common Mathematic Library)
|
|
|
|
DESCRIPTION : Real implementation for float
|
|
|
|
VERSION : MTH V5.0.13 / Alexandre LANGER [ALX] Ubi R&D / Add Comments
|
|
MTH V5.0.14 / Alexandre LANGER [ALX] Ubi R&D / Add MTH_C_MAX_UNSIGNED_CHAR
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*/
|
|
|
|
#ifndef MTH_FLT_H
|
|
#define MTH_FLT_H
|
|
|
|
|
|
/* ##INCLUDE#----------------------------------------------------------------------------
|
|
Includes Files
|
|
---------------------------------------------------------------------------------------*/
|
|
|
|
#ifdef MTH_CHECK
|
|
#include "MTH_fchk.h"
|
|
#else
|
|
#define MTH_M_vCHK(X) {}
|
|
#endif /* MTH_CHECK */
|
|
|
|
#ifdef MTH_OPTIMIZE
|
|
#include "MTH_fopt.h"
|
|
#else
|
|
#include "MTH_fnop.h"
|
|
#endif /* MTH_OPTIMIZE */
|
|
|
|
#ifdef MTH_U64_DEV
|
|
#include "MTH_trig.h"
|
|
#endif /* MTH_U64_DEV */
|
|
|
|
|
|
/* ##CONSTANTE#--------------------------------------------------------------------------
|
|
Real Constantes declaration
|
|
---------------------------------------------------------------------------------------*/
|
|
|
|
#define MTH_C_InfinitPlus (float) 3.402822E38
|
|
#define MTH_C_InfinitMinus (float) -3.402822E38
|
|
#define MTH_C_EpsilonPlus (float) 1.175495E-38
|
|
#define MTH_C_EpsilonMinus (float) -1.175495E-38
|
|
|
|
#define MTH_C_Pi (float) 3.141592653589793
|
|
#define MTH_C_2Pi (float) 6.283185307179586
|
|
#define MTH_C_PiBy2 (float) 1.570796326794896
|
|
#define MTH_C_PiBy4 (float) 7.853981633974482E-1
|
|
#define MTH_C_PiBy8 (float) 3.926990816987241E-1
|
|
#define MTH_C_PiBy180 (float) 1.745329251994329E-2
|
|
#define MTH_C_180ByPi (float) 5.729577951308233E1
|
|
#define MTH_C_e (float) 2.718281828459045
|
|
#define MTH_C_ONE (float) 1.0
|
|
#define MTH_C_ZERO (float) 0.0
|
|
|
|
#define MTH_C_MinusONE (float) -1.0
|
|
|
|
#define MTH_C_2 (float) 2.0
|
|
#define MTH_C_3 (float) 3.0
|
|
#define MTH_C_4 (float) 4.0
|
|
#define MTH_C_5 (float) 5.0
|
|
#define MTH_C_8 (float) 8.0
|
|
|
|
#define MTH_C_Minus2 (float) -2.0
|
|
#define MTH_C_Minus3 (float) -3.0
|
|
#define MTH_C_Minus4 (float) -4.0
|
|
#define MTH_C_Minus5 (float) -5.0
|
|
|
|
#define MTH_C_Inv2 (float) 0.5
|
|
#define MTH_C_Inv3 (float) 3.333333333333333E-1
|
|
#define MTH_C_Inv4 (float) 0.25
|
|
#define MTH_C_Inv5 (float) 0.2
|
|
|
|
#define MTH_C_MinusInv2 (float) -0.5
|
|
#define MTH_C_MinusInv3 (float) -3.333333333333333E-1
|
|
#define MTH_C_MinusInv4 (float) -0.25
|
|
#define MTH_C_MinusInv5 (float) -0.2
|
|
|
|
#define MTH_C_Sqrt2 (float) 1.414213562373095
|
|
#define MTH_C_Sqrt3 (float) 1.732050807568877
|
|
#define MTH_C_Sqrt4 (float) 2.0
|
|
#define MTH_C_Sqrt5 (float) 2.236067977499790
|
|
|
|
#define MTH_C_MinusSqrt2 (float) -1.414213562373095
|
|
#define MTH_C_MinusSqrt3 (float) -1.732050807568877
|
|
#define MTH_C_MinusSqrt4 (float) -2.0
|
|
#define MTH_C_MinusSqrt5 (float) -2.236067977499790
|
|
|
|
#define MTH_C_InvSqrt2 (float) 7.071067811865475E-1
|
|
#define MTH_C_InvSqrt3 (float) 5.773502691896259E-1
|
|
#define MTH_C_InvSqrt4 (float) 0.5
|
|
#define MTH_C_InvSqrt5 (float) 4.472135954999579E-1
|
|
|
|
#define MTH_C_MinusInvSqrt2 (float) -7.071067811865475E-1
|
|
#define MTH_C_MinusInvSqrt3 (float) -5.773502691896259E-1
|
|
#define MTH_C_MinusInvSqrt4 (float) -0.5
|
|
#define MTH_C_MinusInvSqrt5 (float) -4.472135954999579E-1
|
|
|
|
#define MTH_C_MAX_UNSIGNED_CHAR (float) 256.0
|
|
#define MTH_C_MAX_LONG (long) 2147483647
|
|
|
|
#define MTH_M_xInterpretLongAsFloat(a) (*((float*)&(a)))
|
|
|
|
|
|
/* ##MACRO#----------------------------------------------------------------------------
|
|
MACRO definition
|
|
---------------------------------------------------------------------------------------*/
|
|
|
|
/* ##-################################################
|
|
## MATHEMATICS MACRO AND FUNCTION FOR FLOAT REAL
|
|
################################################### */
|
|
|
|
|
|
/* ##-################################################
|
|
## Basic Mathematics MACRO
|
|
################################################### */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xRealToLongRound
|
|
DESCRIPTION : Return long round of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : round(a) : long
|
|
=======================================================================================*/
|
|
#ifdef MTH_OPTIMIZE
|
|
#define MTH_M_xRealToLongRound MTH_M_xRealToLongRoundOpt
|
|
#else /* NOT MTH_OPTIMIZE */
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xRealToLongRound(A) MTH_fn_xRealToLongRoundCHK(A)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xRealToLongRound(A) \
|
|
(long) ( (long)(A*2.0F)-(long)(A) )
|
|
#endif /* MTH_CHECK OR NOT */
|
|
#endif /* MTH_OPTIMIZE */
|
|
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xAdd
|
|
DESCRIPTION : Return the addition of two real numbers
|
|
INPUT : a, b : 2 MTH_tdxReal
|
|
OUTPUT : a + b : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xAdd( A, B) MTH_fn_xAddCHK( A, B)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xAdd( A, B) \
|
|
((A) + (B))
|
|
#endif /* MTH_CHECK OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSub
|
|
DESCRIPTION : Return the subtraction of two real numbers
|
|
INPUT : a, b : 2 MTH_tdxReal
|
|
OUTPUT : a - b : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xSub( A, B) MTH_fn_xSubCHK( A, B)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xSub( A, B) \
|
|
((A) - (B))
|
|
#endif /* MTH_CHECK OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMul
|
|
DESCRIPTION : Return the multiply of two real numbers
|
|
INPUT : a, b : 2 MTH_tdxReal
|
|
OUTPUT : a * b : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xMul( A, B) MTH_fn_xMulCHK( A, B)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xMul( A, B) \
|
|
((A) * (B))
|
|
#endif /* MTH_CHECK OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xDiv
|
|
DESCRIPTION : Return the division of two real numbers
|
|
INPUT : a, b : 2 MTH_tdxReal
|
|
OUTPUT : a / b : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_OPTIMIZE
|
|
#define MTH_M_xDiv MTH_M_xDivOpt
|
|
#else /* NOT MTH_OPTIMIZE */
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xDiv( A, B) MTH_fn_xDivCHK( A, B)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xDiv( A, B) \
|
|
((A) / (B))
|
|
#endif /* MTH_CHECK OR NOT */
|
|
#endif /* MTH_OPTIMIZE */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xNeg
|
|
DESCRIPTION : Return the negation of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : -a : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xNeg( A ) MTH_fn_xNegCHK( A )
|
|
|
|
#else
|
|
|
|
INLINE
|
|
float MTH_M_xNegOpt( MTH_tdxReal xA )
|
|
{
|
|
/* yann le tensorer, sept 28, 1998*/
|
|
unsigned long xNeg;
|
|
unsigned long* pA=(unsigned long*)&xA;
|
|
|
|
xNeg=(*pA)+0x80000000;
|
|
|
|
return MTH_M_xInterpretLongAsFloat(xNeg);
|
|
}
|
|
|
|
#define MTH_M_xNeg(a) (MTH_M_xNegOpt(a))
|
|
#endif
|
|
|
|
/*#define MTH_M_xNeg( A ) \
|
|
(- (A))
|
|
*/
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSqr
|
|
DESCRIPTION : Return the square of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a*a : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xSqr( A ) MTH_fn_xSqrCHK( A )
|
|
#else /* NOT MTH_CHECK */
|
|
INLINE
|
|
float MTH_M_xSqrOpt( MTH_tdxReal xA )
|
|
{
|
|
/* yann le tensorer, sept 28, 1998*/
|
|
return (xA*xA);
|
|
}
|
|
#define MTH_M_xSqr(a) (MTH_M_xSqrOpt(a))
|
|
|
|
/*#define MTH_M_xSqr( A ) \
|
|
( (A) * (A) )
|
|
*/
|
|
#endif /* MTH_CHECK OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSqrt
|
|
DESCRIPTION : Return the square root of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : sqrt(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
|
|
#ifdef MTH_OPTIMIZE
|
|
#define MTH_M_xSqrt MTH_M_xSqrtOpt
|
|
#else /* NOT MTH_OPTIMIZE */
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xSqrt(A) ( sqrtf( A ) )
|
|
#define MTH_M_xQuickSqrt(A) ( sqrtf( A ) )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xSqrt(A) MTH_fn_xSqrtCHK(A)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xSqrt(A) ( (float) sqrt((double) (A)) )
|
|
#endif /* MTH_CHECK OR NOT */
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
#endif /* MTH_OPTIMIZE */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xInvSqrt
|
|
DESCRIPTION : Return the inverse of the square root of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : 1/sqrt(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_OPTIMIZE
|
|
#define MTH_M_xInvSqrt MTH_M_xInvSqrtOpt
|
|
#else /* NOT MTH_OPTIMIZE */
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xInvSqrt( A ) MTH_fn_xInvSqrtCHK( A )
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xInvSqrt( A ) ( MTH_C_ONE / MTH_M_xSqrt( A ) )
|
|
#endif /* MTH_CHECK OR NOT */
|
|
#endif /* MTH_OPTIMIZE */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xInv
|
|
DESCRIPTION : Return the inverse of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : 1/a : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_OPTIMIZE
|
|
#define MTH_M_xInv MTH_M_xInvOpt
|
|
#else /* NOT MTH_OPTIMIZE */
|
|
#ifdef MTH_CHECK
|
|
#define MTH_M_xInv(A) MTH_fn_xInvCHK(A)
|
|
#else /* NOT MTH_CHECK */
|
|
#define MTH_M_xInv(A) ( MTH_C_ONE / (A) )
|
|
#endif /* MTH_CHECK OR NOT */
|
|
#endif /* MTH_OPTIMIZE */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSign
|
|
DESCRIPTION : Return the sign of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : -1 if(a<0), 1 if(a>0), else 0 : MTH_tdxReal
|
|
=======================================================================================*/
|
|
INLINE
|
|
MTH_tdxReal MTH_M_xSign( MTH_tdxReal x)
|
|
{
|
|
/* yann le tensorer, sept 22, 1998 */
|
|
register long* px=(long*)&x;
|
|
long xSign;
|
|
|
|
if (((*px)&0x7FFFFFFF)==0) return MTH_C_ZERO;
|
|
else
|
|
{
|
|
xSign=*px;
|
|
xSign&=0x80000000;
|
|
xSign|=0x3f800000;
|
|
return MTH_M_xInterpretLongAsFloat(xSign) ;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
#define MTH_M_xSign( A ) \
|
|
( ( (A)>MTH_C_ZERO ) ? MTH_C_ONE : ( ((A)<MTH_C_ZERO) ? MTH_C_MinusONE : MTH_C_ZERO) )
|
|
*/
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xAbs
|
|
DESCRIPTION : Return the asolute value of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : |a| : MTH_tdxReal
|
|
=======================================================================================*/
|
|
INLINE
|
|
MTH_tdxReal MTH_M_xAbs( MTH_tdxReal x)
|
|
{
|
|
#ifndef U64
|
|
/* yann le tensorer, sept 22, 1998*/
|
|
|
|
register long* px=(long*)&x;
|
|
long xAbs;
|
|
|
|
xAbs=(*px)&0x7FFFFFFF;
|
|
|
|
return MTH_M_xInterpretLongAsFloat(xAbs);
|
|
#else
|
|
/* U64 version*/
|
|
*((long *)&x) &= 0x7FFFFFFF;
|
|
return x;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
float compare + fld +fstp takes at least 10 cycles ! we better just clear the sign flag */
|
|
/*#define MTH_M_xAbs( A ) \
|
|
( ( ( A ) > MTH_C_ZERO ) ? ( A ) : ( -( A ) ) ) */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xNegAbs
|
|
DESCRIPTION : Return the negative absolute value of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : -|a| : MTH_tdxReal
|
|
=======================================================================================*/
|
|
INLINE
|
|
MTH_tdxReal MTH_M_xNegAbs( MTH_tdxReal x)
|
|
{
|
|
/* yann le tensorer, sept 22, 1998*/
|
|
|
|
register long* px=(long*)&x;
|
|
long xNegAbs;
|
|
|
|
xNegAbs=(*px)|0x80000000;
|
|
|
|
return MTH_M_xInterpretLongAsFloat(xNegAbs);
|
|
}
|
|
/*
|
|
#define MTH_M_xNegAbs( A ) \
|
|
( ( ( A ) < MTH_C_ZERO ) ? ( A ) : ( -( A ) ) )
|
|
*/
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMax
|
|
DESCRIPTION : Return the maximum of two real numbers
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : max(a, b) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMax( A, B) \
|
|
(( (A)>(B) ) ? (A) : (B))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMin
|
|
DESCRIPTION : Return the minimum of two real numbers
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : min(a, b) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMin( A, B) \
|
|
(( (A)<(B) ) ? (A) : (B))
|
|
|
|
|
|
|
|
|
|
|
|
/* ##-###########################
|
|
## Test on real
|
|
############################## */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bGreater
|
|
DESCRIPTION : Test if a real number is greater than a other
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a > b : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bGreater( A, B) \
|
|
( (A)>(B) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bLess
|
|
DESCRIPTION : Test if a real number is less than a other
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a < b : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bLess( A, B) \
|
|
( (A)<(B) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bGreaterEqual
|
|
DESCRIPTION : Test if a real number is greater or equal than a other
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a >= b : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bGreaterEqual( A, B) \
|
|
( (A)>=(B) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bLessEqual
|
|
DESCRIPTION : Test if a real number is less or equal than a other
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a <= b : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bLessEqual( A, B) \
|
|
( (A)<=(B) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bEqual
|
|
DESCRIPTION : Test if a real number is equal to a other
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a == b : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bEqual( A, B) \
|
|
( (A)==(B) )
|
|
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bDifferent
|
|
DESCRIPTION : Test if a real number is different to a other
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a != b : Boolean
|
|
=======================================================================================*/
|
|
/*INLINE
|
|
long MTH_M_bDifferent( MTH_tdxReal xA, MTH_tdxReal xB)
|
|
{
|
|
// yann le tensorer, sept 23, 1998
|
|
//we test if the floats are equal by direcly testing the memory (much faster)
|
|
|
|
register long* pA=(long*)&xA;
|
|
register long* pB=(long*)&xB;
|
|
// we have to do this becaus zero in float can be 0x80000000 or 0x00000000
|
|
|
|
#ifdef _DEBUG
|
|
// to be sure it always works...
|
|
// if it breaks here, inform yann le tensorer
|
|
long result1 = ( ( ((*pA)-(*pB)) & 0x7FFFFFFF )!=0);
|
|
long result2 = (xA!=xB);
|
|
if (result1!=result2)
|
|
{
|
|
__asm
|
|
{
|
|
int 3
|
|
}
|
|
// some troubles happenned, so we return the good result...
|
|
return result2;
|
|
}
|
|
#endif
|
|
|
|
return ( ( ((*pA)-(*pB)) & 0x7FFFFFFF )!=0);
|
|
|
|
}*/
|
|
|
|
#define MTH_M_bDifferent( A, B ) \
|
|
( (A)!=(B) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bIsNull
|
|
DESCRIPTION : Test if a real number is null
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a == 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bIsNull MTH_M_bEqualZero
|
|
|
|
|
|
|
|
/* ##-##############################
|
|
## Tools for MulMatrixMatrix 2D
|
|
################################# */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMulAddMul
|
|
DESCRIPTION : Return the addition of two multiplications
|
|
INPUT : a, b, c, d : MTH_tdxReal
|
|
OUTPUT : a*b + c*d : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMulAddMul(a, b, c, d) \
|
|
((a)*(b) + (c)*(d))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSqrAddSqr
|
|
DESCRIPTION : Return the addition of two squares
|
|
INPUT : a, b : MTH_tdxReal
|
|
OUTPUT : a*a + b*b : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xSqrAddSqr(a, b) \
|
|
((a)*(a) + (b)*(b))
|
|
|
|
|
|
|
|
/* ##-##############################
|
|
## Tools for MulMatrixMatrix 3D
|
|
################################# */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMulSubMul
|
|
DESCRIPTION : Return the subtraction of two multiplications
|
|
INPUT : a, b, c, d : MTH_tdxReal
|
|
OUTPUT : a*b - c*d : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMulSubMul(a, b, c, d) \
|
|
((a)*(b) - (c)*(d))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMulAddMulAddMul
|
|
DESCRIPTION : Return the adition of three multiplications
|
|
INPUT : a, b, c, d, e, f : MTH_tdxReal
|
|
OUTPUT : a*b + c*d + e*f : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMulAddMulAddMul(a, b, c, d, e, f) \
|
|
((a)*(b) + (c)*(d) + (e)*(f))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSqrAddSqrAddSqr
|
|
DESCRIPTION : Return the adition of three squares
|
|
INPUT : a, b, c : MTH_tdxReal
|
|
OUTPUT : a*a + b*b + c*c : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xSqrAddSqrAddSqr(a, b, c) \
|
|
(MTH_M_xSqr(a) + MTH_M_xSqr(b) + MTH_M_xSqr(c))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMul3
|
|
DESCRIPTION : Return the multiplication of three real numbers
|
|
INPUT : a, b, c : MTH_tdxReal
|
|
OUTPUT : a*b*c : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMul3(a, b, c) \
|
|
((a)*(b)*(c))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xMul4
|
|
DESCRIPTION : Return the multiplication of 4 real numbers
|
|
INPUT : a, b, c, d : MTH_tdxReal
|
|
OUTPUT : a*b*c*d : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xMul4(a, b, c, d) \
|
|
((a)*(b)*(c)*(d))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xAdd3
|
|
DESCRIPTION : Return the addition of three real numbers
|
|
INPUT : a, b, c : MTH_tdxReal
|
|
OUTPUT : a+b+c : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xAdd3(a, b, c) \
|
|
((a)+(b)+(c))
|
|
|
|
|
|
|
|
/* ##-###########################
|
|
## Test Real near Zero
|
|
############################## */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bEqualZero
|
|
DESCRIPTION : Test if a real is equal to zero
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a == 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#if defined(OPTIMIZED_FOR_PC_FLOATS_WITH_ASM)
|
|
#define MTH_M_bEqualZero(a) (MTH_M_bEqualZeroAsm(a))
|
|
|
|
#elif !defined(U64)
|
|
|
|
INLINE
|
|
unsigned char MTH_M_bEqualZeroOpt( MTH_tdxReal xA )
|
|
{
|
|
/* yann le tensorer, sept 23, 1998*/
|
|
/*we test if the float is zero by direcly testing the memory as a long (much faster)*/
|
|
register long* pA=(long*)&xA;
|
|
/* we have to clear the sign bit, because negative zero exists.. and is also zero !*/
|
|
return (((*pA)&0x7FFFFFFF)==0);
|
|
}
|
|
#define MTH_M_bEqualZero(a) (MTH_M_bEqualZeroOpt(a))
|
|
|
|
#else
|
|
/* sorry, but much faster like this on N64 (35% faster) - Oliv' - 26/02/1999 */
|
|
#define MTH_M_bEqualZero( x ) \
|
|
MTH_M_bEqual((x), MTH_C_ZERO )
|
|
|
|
#endif
|
|
/*
|
|
#define MTH_M_bEqualZero( x ) \
|
|
MTH_M_bEqual((x), MTH_C_ZERO )*/
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bDifferentZero
|
|
DESCRIPTION : Test if a real is different to zero
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a != 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#if defined(OPTIMIZED_FOR_PC_FLOATS_WITH_ASM)
|
|
#define MTH_M_bDifferentZero(a) (MTH_M_bDifferentZeroAsm(a))
|
|
|
|
#elif !defined(U64)
|
|
|
|
INLINE
|
|
long MTH_M_bDifferentZeroOpt( MTH_tdxReal xA )
|
|
{
|
|
/* yann le tensorer, sept 23, 1998*/
|
|
/*we test if the float is zero by direcly testing the memory as a long (much faster)*/
|
|
register long* pA=(long*)&xA;
|
|
/* we have to clear the sign bit, because negative zero exists.. and is also zero !*/
|
|
return ((*pA)&0x7FFFFFFF);
|
|
}
|
|
#define MTH_M_bDifferentZero(a) (MTH_M_bDifferentZeroOpt(a))
|
|
|
|
#else
|
|
/* sorry, but much faster like this on N64 (35% faster) - Oliv' - 26/02/1999 */
|
|
#define MTH_M_bDifferentZero( x ) \
|
|
MTH_M_bDifferent((x), MTH_C_ZERO )
|
|
|
|
#endif
|
|
|
|
/*#define MTH_M_bDifferentZero( x ) \
|
|
MTH_M_bDifferent((x), MTH_C_ZERO )*/
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bGreaterZero
|
|
DESCRIPTION : Test if a real is greater than zero
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a > 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#if defined(OPTIMIZED_FOR_PC_FLOATS_WITH_ASM)
|
|
#define MTH_M_bGreaterZero(x) (MTH_M_bGreaterZeroAsm(x))
|
|
#else
|
|
|
|
#define MTH_M_bGreaterZero(x) \
|
|
MTH_M_bGreater((x), MTH_C_ZERO)
|
|
#endif
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bLessZero
|
|
DESCRIPTION : Test if a real is less than zero
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a < 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#if defined(OPTIMIZED_FOR_PC_FLOATS_WITH_ASM)
|
|
#define MTH_M_bLessZero(x) (MTH_M_bLessZeroAsm(x))
|
|
#else
|
|
|
|
#define MTH_M_bLessZero(x) \
|
|
MTH_M_bLess((x), MTH_C_ZERO)
|
|
#endif
|
|
|
|
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bGreaterEqualZero
|
|
DESCRIPTION : Test if a real is greater or equal than zero
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a >= 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#if defined(OPTIMIZED_FOR_PC_FLOATS_WITH_ASM)
|
|
#define MTH_M_bGreaterEqualZero(x) (MTH_M_bGreaterEqualZeroAsm(x))
|
|
#else
|
|
|
|
#define MTH_M_bGreaterEqualZero(x) \
|
|
MTH_M_bGreaterEqual((x), MTH_C_ZERO)
|
|
#endif
|
|
|
|
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bLessEqualZero
|
|
DESCRIPTION : Test if a real is less or equal than zero
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : a <= 0.0 : Boolean
|
|
=======================================================================================*/
|
|
#if defined(OPTIMIZED_FOR_PC_FLOATS_WITH_ASM)
|
|
#define MTH_M_bLessEqualZero(x) (MTH_M_bLessEqualZeroAsm(x))
|
|
#else
|
|
|
|
#define MTH_M_bLessEqualZero(x) \
|
|
MTH_M_bLessEqual((x), MTH_C_ZERO)
|
|
#endif
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bInRangeEqual
|
|
DESCRIPTION : Test if a real is in range or equal of two other reals
|
|
INPUT : x, a, b : MTH_tdxReal
|
|
OUTPUT : x E [a,b] : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bInRangeEqual( x, a, b) \
|
|
( MTH_M_bGreaterEqual((x),(a)) && MTH_M_bLessEqual((x),(b)) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bInRange
|
|
DESCRIPTION : Test if a real is in range of two other reals
|
|
INPUT : x, a, b : MTH_tdxReal
|
|
OUTPUT : x E ]a,b[ : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bInRange( x, a, b) \
|
|
( MTH_M_bGreater((x),(a)) && MTH_M_bLess((x),(b)) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bInUnitEqual
|
|
DESCRIPTION : Test if a real is in range of [0,1]
|
|
INPUT : x, : MTH_tdxReal
|
|
OUTPUT : x E [0,1] : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bInUnitEqual( x ) \
|
|
( MTH_M_bGreaterEqual((x),MTH_C_ZERO) && MTH_M_bLessEqual((x),MTH_C_ONE))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bInUnit
|
|
DESCRIPTION : Test if a real is in range of ]0,1[
|
|
INPUT : x, : MTH_tdxReal
|
|
OUTPUT : x E ]0,1[ : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bInUnit( x ) \
|
|
( MTH_M_bGreater((x),MTH_C_ZERO) && MTH_M_bLess((x),MTH_C_ONE) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bEqualWithEpsilon
|
|
DESCRIPTION : Test if a real is near a other real
|
|
INPUT : a, b, eps : MTH_tdxReal
|
|
OUTPUT : |a-b|<eps : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bEqualWithEpsilon( A, B, EPS) \
|
|
(MTH_M_bLess( MTH_M_xAbs((A)-(B)), (EPS) ))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bDifferentWithEpsilon
|
|
DESCRIPTION : Test if a real is near different a other real
|
|
INPUT : a, b, eps : MTH_tdxReal
|
|
OUTPUT : |a-b|>eps : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bDifferentWithEpsilon( A, B, EPS ) \
|
|
(MTH_M_bGreater( MTH_M_xAbs((A)-(B)), (EPS) ))
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_bIsNullWithEpsilon
|
|
DESCRIPTION : Test if a real is near zero
|
|
INPUT : a, eps : MTH_tdxReal
|
|
OUTPUT : |a|<eps : Boolean
|
|
=======================================================================================*/
|
|
#define MTH_M_bIsNullWithEpsilon(A, EPS) \
|
|
(MTH_M_bLess( MTH_M_xAbs(A), (EPS) ))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* ##-###########################
|
|
## Polynomial operations
|
|
############################## */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xLinearInterpol
|
|
DESCRIPTION : Return linear interpolation
|
|
INPUT : a, b, t : MTH_tdxReal
|
|
OUTPUT : a + t*(b-a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xLinearInterpol(a, b, t) \
|
|
MTH_M_xAdd( (a), MTH_M_xMul((t), MTH_M_xSub( (b), (a) ) ) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xTrinomeDelta
|
|
DESCRIPTION : Return the delta of a trinome
|
|
INPUT : a, b, c : MTH_tdxReal
|
|
OUTPUT : b*b - 4*a*c : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xTrinomeDelta( a, b, c) \
|
|
( MTH_M_xSub ( MTH_M_xSqr ( (b) ), \
|
|
MTH_M_xMul ( MTH_C_4, MTH_M_xMul ( (a), (c) ) ) ) \
|
|
)
|
|
|
|
|
|
|
|
|
|
/* ##-################################
|
|
## Trigonometric Mathematics MACRO
|
|
################################### */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xSin
|
|
DESCRIPTION : Return the sinus of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : sin(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xSin( X ) \
|
|
sinf( X )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xSin( X ) \
|
|
(float) sin((double) (X) )
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xCos
|
|
DESCRIPTION : Return the cosinus of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : cos(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xCos( X ) \
|
|
cosf( X )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xCos( X ) \
|
|
(float) cos((double) (X) )
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xTan
|
|
DESCRIPTION : Return the tangent of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : tan(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xTan( X ) \
|
|
( (sinf(X)) / (cosf(X)) )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xTan( X ) \
|
|
(float) tan((double) (X) )
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xATan
|
|
DESCRIPTION : Return the Arc-tangent of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : Atan(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xATan( X ) \
|
|
atan( (X) )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xATan( X ) \
|
|
(float)atan(X)
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xACos
|
|
DESCRIPTION : Return the Arc-cosinus of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : Acos(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xACos( X ) \
|
|
acos( (X) )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xACos( X ) \
|
|
(float) acos((double) (X) )
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xASin
|
|
DESCRIPTION : Return the Arc-sinus of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : Asin(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xASin( X ) \
|
|
asin( (X) )
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xASin( X ) \
|
|
(float) asin((double) (X) )
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xCoTan
|
|
DESCRIPTION : Return the Co-tangent of a real number
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : CoTan(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#ifdef MTH_U64_DEV
|
|
#define MTH_M_xCoTan( X ) \
|
|
(float)( MTH_C_ONE / MTH_M_xTan( (X) ))
|
|
#else /* NOT MTH_U64_DEV */
|
|
#define MTH_M_xCoTan( X ) \
|
|
(float) (MTH_C_ONE / tan((double) (X) ))
|
|
#endif /* MTH_U64_DEV OR NOT */
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xDegToRad
|
|
DESCRIPTION : Return the conversion from degree to radian
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : rad(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xDegToRad( X ) \
|
|
(float) ( ( X ) *( MTH_C_PiBy180 ) )
|
|
|
|
/* ##M==================================================================================
|
|
NAME : MTH_M_xDegToRad
|
|
DESCRIPTION : Return the conversion from radian to degree
|
|
INPUT : a : MTH_tdxReal
|
|
OUTPUT : deg(a) : MTH_tdxReal
|
|
=======================================================================================*/
|
|
#define MTH_M_xRadToDeg( X ) \
|
|
(float) ( ( X ) *( MTH_C_180ByPi ) )
|
|
|
|
|
|
|
|
#endif /* MTH_FLT_H */
|
|
|
|
|
|
|