guus/reman3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add rayman2 source files

Browse Source
This commit is contained in:
Guus Waals
2024-09-18 02:33:44 +08:00
parent bcc093f8ed
commit fb036c54fd
14339 changed files with 2596224 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

234
Rayman_X/cpa/public/MTH/Specif/SCA/SCA_sl.h Normal file
View File

@@ -0,0 +1,234 @@
/*----------------------------------------------------------------------------------*/
/* Filename : SCA_sl.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 15:58-------------------
* Conversion : OK (avec SCA_sl.h du 23.04.98 19:26 (18017))
* --------------------------------------------------*/
#ifndef _SLREAL_H_
#define _SLREAL_H_
/*----------------------------------------------------------------------------------*/
/*-----------------*/
/* Fixed coma case */
/*-----------------*/
/* 1.31.0 */
/*---------------------------------*/
/* Specific Values for fixed point */
/*---------------------------------*/
#define SCA_td_sl MTH_tdxReal
/*#define SCA_sl_C_slComaDecal 0*/
/*#define SCA_sl_C_slComaCoef 1*/
/*#define SCA_sl_C_dfMax 2147483648*/
/*#define SCA_sl_C_dfMin (-SCA_sl_C_dfMax)*/
/*#define SCA_sl_C_slMax (0x7FFFFFE0)*/
/*#define SCA_sl_C_slMin (0xEFFFFFE0)*/
/*#define SCA_sl_C_slError (0x7FFFFFFF)*/
/*#define SCA_sl_C_slNegMask (0x80000000)*/
/*#define SCA_sl_C_slPosMask (0x7FFFFFFF)*/
/*#define SCA_sl_C_slDecMask (0x00000000)*/
/*#define SCA_sl_C_slEntMask (0xFFFFFFFF)*/
/*--------------------------------------------------------*/
/* ---------------- Constants ---------------------------*/
/*--------------------------------------------------------*/
#define SCA_sl_C_ZERO MTH_C_ZERO
#define SCA_sl_C_ONE MTH_C_ONE
/*--------------------------------------------------------*/
/* Conversion functions */
/*--------------------------------------------------------*/
__inline SCA_td_sl SCA_sl_fn_slDouble2Real( double _dfValue )
{
return MTH_M_xDoubleToReal( _dfValue );
}
/*--------------------------------------------------------*/
__inline double SCA_sl_fn_Real2Double( SCA_td_sl _xValue )
{
return MTH_M_xRealToDouble( _xValue );
}
/*--------------------------------------------*/
/* Conversions : Macros definitions */
/*--------------------------------------------*/
#define SCA_sl_M_slDoubleToReal(_dfValue) MTH_M_xDoubleToReal(_dfValue)
#define SCA_sl_M_slFloatToReal(_fValue) MTH_M_xFloatToReal(_fValue)
#define SCA_sl_M_slIntToReal(_iValue) MTH_M_xLongToReal(_iValue) /*???*/
#define SCA_sl_M_RealToDouble(_xValue) MTH_M_xRealToDouble(_xValue)
#define SCA_sl_M_RealToFloat(_xValue) MTH_M_xrealToFloat(_xValue)
#define SCA_sl_M_RealToInt(_xValue) MTh_M_xRealToLong(_xValue) /*???*/
/*--------------------------------------------------------*/
/* Constantes */
/*--------------------------------------------------------*/
#define SCA_sl_C_slTwo MTH_C_2
/* ##CONSTANTE#--------------------------------------------------------------------------
Real Constantes declaration
---------------------------------------------------------------------------------------*/
#define SCA_sl_C_InfinitPlus MTH_C_InfinitPlus
#define SCA_sl_InfinitMinus MTH_C_InfinitMinus
#define SCA_sl_EpsilonPlus MTH_C_EpsilonPlus
#define SCA_sl_EpsilonMinus MTH_C_EpsilonMinus
#define SCA_sl_Pi MTH_C_Pi
#define SCA_sl_2Pi MTH_C_2Pi
#define SCA_sl_PiBy2 MTH_C_PiBy2
#define SCA_sl_PiBy4 MTH_C_PiBy4
#define SCA_sl_PiBy8 MTH_C_PiBy8
#define SCA_sl_PiBy180 MTH_C_PiBy180
#define SCA_sl_180ByPi MTH_C_180ByPi
#define SCA_sl_e MTH_C_e
#define SCA_sl_MinusONE MTH_C_MinusONE
#define SCA_sl_2 MTH_C_2
#define SCA_sl_3 MTH_C_3
#define SCA_sl_4 MTH_C_4
#define SCA_sl_5 MTH_C_5
#define SCA_sl_8 (double) 8.0
#define SCA_sl_Minus2 MTH_C_Minus2
#define SCA_sl_Minus3 MTH_C_Minus3
#define SCA_sl_Minus4 MTH_C_Minus4
#define SCA_sl_Minus5 MTH_C_Minus5
#define SCA_sl_Inv2 MTH_C_Inv2
#define SCA_sl_Inv3 MTH_C_Inv3
#define SCA_sl_Inv4 MTH_C_Inv4
#define SCA_sl_Inv5 MTH_C_Inv5
#define SCA_sl_MinusInv2 MTH_C_MinusInv2
#define SCA_sl_MinusInv3 MTH_C_MinusInv3
#define SCA_sl_MinusInv4 MTH_C_MinusInv4
#define SCA_sl_MinusInv5 MTH_C_MinusInv5
#define SCA_sl_Sqrt2 MTH_C_Sqrt2
#define SCA_sl_Sqrt3 MTH_C_Sqrt3
#define SCA_sl_Sqrt4 MTH_C_Sqrt4
#define SCA_sl_Sqrt5 MTH_C_Sqrt5
#define SCA_sl_MinusSqrt2 MTH_C_MinusSqrt2
#define SCA_sl_MinusSqrt3 MTH_C_MinusSqrt3
#define SCA_sl_MinusSqrt4 MTH_C_MinusSqrt4
#define SCA_sl_MinusSqrt5 MTH_C_MinusSqrt5
#define SCA_sl_InvSqrt2 MTH_C_InvSqrt2
#define SCA_sl_InvSqrt3 MTH_C_InvSqrt3
#define SCA_sl_InvSqrt4 MTH_C_InvSqrt4
#define SCA_sl_InvSqrt5 MTH_C_InvSqrt5
#define SCA_sl_MinusInvSqrt2 MTH_C_MinusInvSqrt2
#define SCA_sl_MinusInvSqrt3 MTH_C_MinusInvSqrt3
#define SCA_sl_MinusInvSqrt4 MTH_C_MinusInvSqrt4
#define SCA_sl_MinusInvSqrt5 MTH_C_MinusInvSqrt5
#define SCA_sl_MAX_UNSIGNED_CHAR MTH_C_MAX_UNSIGNED_CHAR
/*--------------------------------------------------------*/
/* Operations */
/*--------------------------------------------------------*/
/* Comparaisons */
#define SCA_sl_M_bIsNull(_xOp) MTH_M_bIsNull(_xOp)
#define SCA_sl_M_bEqualZero(_xOp) MTH_M_bEqualZero(_xOp)
#define SCA_sl_M_bIsNegative(_xOp) MTH_M_bLessZero(_xOp)
#define SCA_sl_M_bIsPositive(_xOp) MTH_M_bGreaterZero(_xOp)
#define SCA_sl_M_bGreater(_xOp1,_xOp2) MTH_M_bGreater(_xOp1,_xOp2)
#define SCA_sl_M_bLess(_xOp1,_xOp2) MTH_M_bLess_xOp1,_xOp2)
#define SCA_sl_M_bGreaterEqual(_xOp1,_xOp2) MTH_M_bGreaterEqual(_xOp1,_xOp2)
#define SCA_sl_M_bLessEqual(_xOp1,_xOp2) MTH_M_bLessEqual(_xOp1,_xOp2)
#define SCA_sl_M_bEqual(_xOp1,_xOp2) MTH_M_bEqual(_xOp1,_xOp2)
#define SCA_sl_M_bDifferent(_xOp1,_xOp2) MTH_M_bDifferent(_xOp1,_xOp2)
/* Operations */
#define SCA_sl_M_slNeg(_xOp) MTH_M_xNeg(_xOp)
#define SCA_sl_M_slAdd(_xOp1,_xOp2) MTH_M_xAdd(_xOp1,_xOp2)
#define SCA_sl_M_slSub(_xOp1,_xOp2) MTH_M_xsub(_xOp1,_xOp2)
#define SCA_sl_M_slMul(_xOp1,_xOp2) MTH_M_xMul(_xOp1,_xOp2)
#define SCA_sl_M_slDiv(_xOp1,_xOp2) MTH_M_xDiv(_xOp1,_xOp2)
#define SCA_sl_M_slAbs(_xOp) MTH_M_xAbs(_xOp)
#define SCA_sl_M_slNegAbs(_xOp) MTH_M_xNegAbs(_xOp)
#define SCA_sl_M_slInv(_xOp) MTH_M_xInv(_xOp)
#define SCA_sl_M_slSqr(_xOp) MTH_M_xSqr(_xOp,_xOp)
#define SCA_sl_M_slCub(_xOp) MTH_M_xMul(_xOp,MTH_M_xSqr(_xOp))
#define SCA_sl_M_slSqrt(_xOp) MTH_M_xSqrt(_xOp)
#define SCA_sl_M_slInvSqrt(_xOp) MTH_M_xInvSqrt(_xOp)
#define SCA_sl_M_slSin(_xOp) MTH_M_xSin(_xOp)
#define SCA_sl_M_slCos(_xOp) MTH_M_xSin(_xOp)
/*
#define sl_M_Tan(_xOp) (SCA_sl_fn_Tan(_xOp))
#define sl_M_ASin(_xOp) (SCA_sl_fn_ASin(_xOp))
#define sl_M_ACos(_xOp) (SCA_sl_fn_ACos(_xOp))
*/
/*
#define sl_M_Sin(_xOp) SCA_sl_M_slDoubleToReal(sin(sl_M_Real2Double(_xOp)))
#define sl_M_Cos(_xOp) SCA_sl_M_slDoubleToReal(cos(sl_M_Real2Double(_xOp)))
*/
#define SCA_sl_M_slTan(_xOp) MTH_M_xTan(_xOp)
#define SCA_sl_M_slASin(_xOp) MTH_M_xASin(_xOp)
#define SCA_sl_M_slACos(_xOp) MTH_M_xACos(_xOp)
/* ##-##############################
## Tools for MulMatrixMatrix 3D
################################# */
/* ##M==================================================================================
NAME : SCA_sl_M_slMulSubMul
DESCRIPTION : Return the subtraction of two multiplications
INPUT : a, b, c, d : SCA_td_sl
OUTPUT : a*b - c*d : SCA_td_sl
=======================================================================================*/
#define SCA_sl_M_slMulSubMul(a, b, c, d) MTH_M_xMulSubMul(a, b, c, d)
/* ##M==================================================================================
NAME : SCA_sl_M_slMulAddMulAddMul
DESCRIPTION : Return the adition of three multiplications
INPUT : a, b, c, d, e, f : SCA_td_sl
OUTPUT : a*b + c*d + e*f : SCA_td_sl
=======================================================================================*/
#define SCA_sl_M_slMulAddMulAddMul(a, b, c, d, e, f) MTH_M_xMulAddMulAddMul(a, b, c, d, e, f)
/* ##M==================================================================================
NAME : SCA_sl_M_slSqrAddSqrAddSqr
DESCRIPTION : Return the adition of three squares
INPUT : a, b, c : SCA_td_sl
OUTPUT : a*a + b*b + c*c : SCA_td_sl
=======================================================================================*/
#define SCA_sl_M_slSqrAddSqrAddSqr(a, b, c) MTH_M_xSqrAddSqrAddSqr(a, b, c)
/* ##M==================================================================================
NAME : SCA_sl_M_slMul3
DESCRIPTION : Return the multiplication of three real numbers
INPUT : a, b, c : SCA_td_sl
OUTPUT : a*b*c : SCA_td_sl
=======================================================================================*/
#define SCA_sl_M_slMul3(a, b, c) MTH_M_xMul3(a, b, c)
/* ##M==================================================================================
NAME : SCA_sl_M_slAdd3
DESCRIPTION : Return the addition of three real numbers
INPUT : a, b, c : SCA_td_sl
OUTPUT : a+b+c : SCA_td_sl
=======================================================================================*/
#define SCA_sl_M_slAdd3(a, b, c) MTH_M_xAdd3(a, b, c)
/*----------------------------------------------------------------------------------*/
#endif /* _SLREAL_H_ */

284
Rayman_X/cpa/public/MTH/Specif/SCA/SCA_sl12.h Normal file
View File

@@ -0,0 +1,284 @@
/*----------------------------------------------------------------------------------*/
/* Filename : SCA_sl12.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 17:52-------------------
* Conversion : OK (avec version 23.04.98 19:26 (20523))
* --------------------------------------------------*/
#ifndef _SCA_sl12_H_
#define _SCA_sl12_H_
/*----------------------------------------------------------------------------------*/
/*-----------------*/
/* Fixed coma case */
/*-----------------*/
/* 1.19.12 */
/*---------------------------------*/
/* Specific Values for Fixed point */
/*---------------------------------*/
#define SCA_td_sl12 MTH_tdxReal
/*#define SCA_sl12_C_sl12ComaDecal 12*/
/*#define SCA_sl12_C_sl12ComaCoef 4096*/
/*#define SCA_sl12_C_dfMax 524000.0*/
/*#define SCA_sl12_C_dfMin (-SCA_sl12_C_dfMax)*/
/*#define SCA_sl12_C_sl12Max (0x7FFFFFE0)*/
/*#define SCA_sl12_C_sl12Min (0xEFFFFFE0)*/
/*#define SCA_sl12_C_sl12ForceMinus (0x80000000)*/
/*#define SCA_sl12_C_sl12ForcePlus (0x7FFFFFFF)*/
/*#define SCA_sl12_C_sl12Error (0x7FFFFFFF)*/
/*#define SCA_sl12_C_sl12NegMask (0x80000000)*/
/*#define SCA_sl12_C_sl12PosMask (0x7FFFFFFF)*/
/*#define SCA_sl12_C_sl12DecMask (0x00000FFF)*/
/*#define SCA_sl12_C_sl12EntMask (0xFFFFF000)*/
/*--------------------------------------------------------*/
/* ---------------- Constants ---------------------------*/
/*--------------------------------------------------------*/
#define SCA_sl12_C_ZERO MTH_C_ZERO
#define SCA_sl12_C_ONE MTH_C_ONE
/*--------------------------------------------------------*/
/* Conversion functions */
/*--------------------------------------------------------*/
__inline SCA_td_sl12 SCA_sl12_fn_sl12Double2Real( double _dfValue )
{
return MTH_M_xDoubleToReal( _dfValue );
}
/*--------------------------------------------------------*/
__inline double SCA_sl12_fn_Real2Double( SCA_td_sl12 _xValue )
{
return MTH_M_xRealToDouble( _xValue );
}
/*--------------------------------------------*/
/* Conversions : Macros definitions */
/*--------------------------------------------*/
#define SCA_sl12_M_sl12DoubleToReal(_dfValue) MTH_M_xDoubleToReal(_dfValue)
#define SCA_sl12_M_sl12FloatToReal(_fValue) MTH_M_xFloatToReal(_fValue)
#define SCA_sl12_M_sl12IntToReal(_iValue) MTH_M_xLongToReal(_iValue) /*???*/
#define SCA_sl12_M_RealToDouble(_xValue) MTH_M_xRealToDouble(_xValue)
#define SCA_sl12_M_RealToFloat(_xValue) MTH_M_xrealToFloat(_xValue)
#define SCA_sl12_M_RealToInt(_xValue) MTh_M_xRealToLong(_xValue) /*???*/
/*--------------------------------------------------------*/
/* Constantes */
/*--------------------------------------------------------*/
#define SCA_sl12_C_sl12Two MTH_C_2
/* ##CONSTANTE#--------------------------------------------------------------------------
Real Constantes declaration
---------------------------------------------------------------------------------------*/
#define SCA_sl12_C_InfinitPlus MTH_C_InfinitPlus
#define SCA_sl12_InfinitMinus MTH_C_InfinitMinus
#define SCA_sl12_EpsilonPlus MTH_C_EpsilonPlus
#define SCA_sl12_EpsilonMinus MTH_C_EpsilonMinus
#define SCA_sl12_Pi MTH_C_Pi
#define SCA_sl12_2Pi MTH_C_2Pi
#define SCA_sl12_PiBy2 MTH_C_PiBy2
#define SCA_sl12_PiBy4 MTH_C_PiBy4
#define SCA_sl12_PiBy8 MTH_C_PiBy8
#define SCA_sl12_PiBy180 MTH_C_PiBy180
#define SCA_sl12_180ByPi MTH_C_180ByPi
#define SCA_sl12_e MTH_C_e
#define SCA_sl12_MinusONE MTH_C_MinusONE
#define SCA_sl12_2 MTH_C_2
#define SCA_sl12_3 MTH_C_3
#define SCA_sl12_4 MTH_C_4
#define SCA_sl12_5 MTH_C_5
#define SCA_sl12_8 (double) 8.0
#define SCA_sl12_Minus2 MTH_C_Minus2
#define SCA_sl12_Minus3 MTH_C_Minus3
#define SCA_sl12_Minus4 MTH_C_Minus4
#define SCA_sl12_Minus5 MTH_C_Minus5
#define SCA_sl12_Inv2 MTH_C_Inv2
#define SCA_sl12_Inv3 MTH_C_Inv3
#define SCA_sl12_Inv4 MTH_C_Inv4
#define SCA_sl12_Inv5 MTH_C_Inv5
#define SCA_sl12_MinusInv2 MTH_C_MinusInv2
#define SCA_sl12_MinusInv3 MTH_C_MinusInv3
#define SCA_sl12_MinusInv4 MTH_C_MinusInv4
#define SCA_sl12_MinusInv5 MTH_C_MinusInv5
#define SCA_sl12_Sqrt2 MTH_C_Sqrt2
#define SCA_sl12_Sqrt3 MTH_C_Sqrt3
#define SCA_sl12_Sqrt4 MTH_C_Sqrt4
#define SCA_sl12_Sqrt5 MTH_C_Sqrt5
#define SCA_sl12_MinusSqrt2 MTH_C_MinusSqrt2
#define SCA_sl12_MinusSqrt3 MTH_C_MinusSqrt3
#define SCA_sl12_MinusSqrt4 MTH_C_MinusSqrt4
#define SCA_sl12_MinusSqrt5 MTH_C_MinusSqrt5
#define SCA_sl12_InvSqrt2 MTH_C_InvSqrt2
#define SCA_sl12_InvSqrt3 MTH_C_InvSqrt3
#define SCA_sl12_InvSqrt4 MTH_C_InvSqrt4
#define SCA_sl12_InvSqrt5 MTH_C_InvSqrt5
#define SCA_sl12_MinusInvSqrt2 MTH_C_MinusInvSqrt2
#define SCA_sl12_MinusInvSqrt3 MTH_C_MinusInvSqrt3
#define SCA_sl12_MinusInvSqrt4 MTH_C_MinusInvSqrt4
#define SCA_sl12_MinusInvSqrt5 MTH_C_MinusInvSqrt5
#define SCA_sl12_MAX_UNSIGNED_CHAR MTH_C_MAX_UNSIGNED_CHAR
/*--------------------------------------------------------*/
/* Operations */
/*--------------------------------------------------------*/
/* Comparaisons */
#define SCA_sl12_M_bIsNull(_xOp) MTH_M_bIsNull(_xOp)
#define SCA_sl12_M_bEqualZero(_sl12Op) MTH_M_bEqualZero(_sl12Op)
#define SCA_sl12_M_bIsNegative(_xOp) MTH_M_bLessZero((_xOp)
#define SCA_sl12_M_bIsPositive(_xOp) MTH_M_bGreaterZero(_xOp)
#define SCA_sl12_M_bGreater(_xOp1,_xOp2) MTH_M_bGreater(_xOp1,_xOp2)
#define SCA_sl12_M_bLess(_xOp1,_xOp2) MTH_M_bLess_xOp1,_xOp2)
#define SCA_sl12_M_bGreaterEqual(_xOp1,_xOp2) MTH_M_bGreaterEqual(_xOp1,_xOp2)
#define SCA_sl12_M_bLessEqual(_xOp1,_xOp2) MTH_M_bLessEqual(_xOp1,_xOp2)
#define SCA_sl12_M_bEqual(_xOp1,_xOp2) MTH_M_bEqual(_xOp1,_xOp2)
#define SCA_sl12_M_bDifferent(_xOp1,_xOp2) MTH_M_bDifferent(_xOp1,_xOp2)
#define SCA_sl12_M_sl12Min(A,B) MTH_M_xMin(A,B)
#define SCA_sl12_M_sl12Max(A,B) MTH_M_xMax(A,B)
/* Operations */
#define SCA_sl12_M_sl12Neg(_xOp) MTH_M_xNeg(_xOp)
#define SCA_sl12_M_sl12Add(_xOp1,_xOp2) MTH_M_xAdd(_xOp1,_xOp2)
#define SCA_sl12_M_sl12Sub(_xOp1,_xOp2) MTH_M_xsub(_xOp1,_xOp2)
#define SCA_sl12_M_sl12Mul(_xOp1,_xOp2) MTH_M_xMul(_xOp1,_xOp2)
#define SCA_sl12_M_sl12Div(_xOp1,_xOp2) MTH_M_xDiv(_xOp1,_xOp2)
#define SCA_sl12_M_sl12Abs(_xOp) MTH_M_xAbs(_xOp)
#define SCA_sl12_M_sl12NegAbs(_xOp) MTH_M_xNegAbs(_xOp)
#define SCA_sl12_M_sl12Inv(_xOp) MTH_M_xInv(_xOp)
#define SCA_sl12_M_sl12Sqr(_xOp) MTH_M_xSqr(_xOp,_xOp)
#define SCA_sl12_M_sl12Cub(_xOp) MTH_M_xMul(_xOp,MTH_M_xSqr(_xOp))
#define SCA_sl12_M_sl12Sqrt(_xOp) MTH_M_xSqrt(_xOp)
#define SCA_sl12_M_sl12InvSqrt(_xOp) MTH_M_xInvSqrt(_xOp)
#define SCA_sl12_M_sl12Sin(_xOp) MTH_M_xSin(_xOp)
#define SCA_sl12_M_sl12Cos(_xOp) MTH_M_xSin(_xOp)
/*
#define sl12_M_Tan(_xOp) (SCA_sl12_fn_Tan(_xOp))
#define sl12_M_ASin(_xOp) (SCA_sl12_fn_ASin(_xOp))
#define sl12_M_ACos(_xOp) (SCA_sl12_fn_ACos(_xOp))
*/
/*
#define sl12_M_Sin(_xOp) SCA_sl12_M_sl12DoubleToReal(sin(sl12_M_Real2Double(_xOp)))
#define sl12_M_Cos(_xOp) SCA_sl12_M_sl12DoubleToReal(cos(sl12_M_Real2Double(_xOp)))
*/
#define SCA_sl12_M_sl12Tan(_xOp) MTH_M_xTan(_xOp)
#define SCA_sl12_M_sl12ASin(_xOp) MTH_M_xASin(_xOp)
#define SCA_sl12_M_sl12ACos(_xOp) MTH_M_xACos(_xOp)
/* ##-##############################
## Tools for MulMatrixMatrix 3D
################################# */
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12MulSubMul
DESCRIPTION : Return the subtraction of two multiplications
INPUT : a, b, c, d : SCA_td_sl12
OUTPUT : a*b - c*d : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12MulSubMul(a, b, c, d) MTH_M_xMulSubMul(a, b, c, d)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12MulAddMulAddMul
DESCRIPTION : Return the adition of three multiplications
INPUT : a, b, c, d, e, f : SCA_td_sl12
OUTPUT : a*b + c*d + e*f : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12MulAddMulAddMul(a, b, c, d, e, f) MTH_M_xMulAddMulAddMul(a, b, c, d, e, f)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12SqrAddSqrAddSqr
DESCRIPTION : Return the adition of three squares
INPUT : a, b, c : SCA_td_sl12
OUTPUT : a*a + b*b + c*c : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12SqrAddSqrAddSqr(a, b, c) MTH_M_xSqrAddSqrAddSqr(a, b, c)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12Mul3
DESCRIPTION : Return the multiplication of three real numbers
INPUT : a, b, c : SCA_td_sl12
OUTPUT : a*b*c : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12Mul3(a, b, c) MTH_M_xMul3(a, b, c)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12Add3
DESCRIPTION : Return the addition of three real numbers
INPUT : a, b, c : SCA_td_sl12
OUTPUT : a+b+c : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12Add3(a, b, c) MTH_M_xAdd3(a, b, c)
#define SCA_sl12_M_sl12ACos(_xOp) MTH_M_xACos(_xOp)
/* ##-##############################
## Tools for MulMatrixMatrix 3D
################################# */
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12MulSubMul
DESCRIPTION : Return the subtraction of two multiplications
INPUT : a, b, c, d : SCA_td_sl12
OUTPUT : a*b - c*d : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12MulSubMul(a, b, c, d) MTH_M_xMulSubMul(a, b, c, d)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12MulAddMulAddMul
DESCRIPTION : Return the adition of three multiplications
INPUT : a, b, c, d, e, f : SCA_td_sl12
OUTPUT : a*b + c*d + e*f : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12MulAddMulAddMul(a, b, c, d, e, f) MTH_M_xMulAddMulAddMul(a, b, c, d, e, f)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12SqrAddSqrAddSqr
DESCRIPTION : Return the adition of three squares
INPUT : a, b, c : SCA_td_sl12
OUTPUT : a*a + b*b + c*c : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12SqrAddSqrAddSqr(a, b, c) MTH_M_xSqrAddSqrAddSqr(a, b, c)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12Mul3
DESCRIPTION : Return the multiplication of three real numbers
INPUT : a, b, c : SCA_td_sl12
OUTPUT : a*b*c : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12Mul3(a, b, c) MTH_M_xMul3(a, b, c)
/* ##M==================================================================================
NAME : SCA_sl12_M_sl12Add3
DESCRIPTION : Return the addition of three real numbers
INPUT : a, b, c : SCA_td_sl12
OUTPUT : a+b+c : SCA_td_sl12
=======================================================================================*/
#define SCA_sl12_M_sl12Add3(a, b, c) MTH_M_xAdd3(a, b, c)
/*----------------------------------------------------------------------------------*/
#endif /* _SCA_sl12_H_ */

237
Rayman_X/cpa/public/MTH/Specif/SCA/SCA_sw.h Normal file
View File

@@ -0,0 +1,237 @@
/*----------------------------------------------------------------------------------*/
/* Filename : SCA_sw.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 17:45-------------------
* Conversion : OK (avec version 23.04.98 19:26 (18823))
* --------------------------------------------------*/
#ifndef _SCA_sw_H_
#define _SCA_sw_H_
/*----------------------------------------------------------------------------------*/
/* New */
/*-----------------*/
/* Fixed coma case */
/*-----------------*/
/* 1.15.0 */
/*---------------------------------*/
/* Specific Values for fixed point */
/*---------------------------------*/
#define SCA_td_sw MTH_tdxReal
/*#define SCA_sw_C_swComaDecal 0*/
/*#define SCA_sw_C_swComaCoef 1*/
/*#define SCA_sw_C_dfMax 32768*/
/*#define SCA_sw_C_dfMin (-SCA_sw_C_dfMax)*/
/*#define SCA_sw_C_swMax 32767*/
/*#define SCA_sw_C_swMin -32767*/
/*#define SCA_sw_C_swError -32768*/
/*#define SCA_sw_C_swNegMask (0x8000)*/
/*#define SCA_sw_C_swPosMask (0x7FFF)*/
/*#define SCA_sw_C_swDecMask (0x0000)*/
/*#define SCA_sw_C_swEntMask (0xFFFF)*/
/*--------------------------------------------------------*/
/* ---------------- Constants ---------------------------*/
/*--------------------------------------------------------*/
#define SCA_sw_C_ZERO MTH_C_ZERO
#define SCA_sw_C_ONE MTH_C_ONE
/*--------------------------------------------------------*/
/* Conversion functions */
/*--------------------------------------------------------*/
__inline SCA_td_sw SCA_sw_fn_swDouble2Real( double _dfValue )
{
return MTH_M_xDoubleToReal( _dfValue );
}
/*--------------------------------------------------------*/
__inline double SCA_sw_fn_Real2Double( SCA_td_sw _xValue )
{
return MTH_M_xRealToDouble( _xValue );
}
/*--------------------------------------------*/
/* Conversions : Macros definitions */
/*--------------------------------------------*/
#define SCA_sw_M_swDoubleToReal(_dfValue) MTH_M_xDoubleToReal(_dfValue)
#define SCA_sw_M_swFloatToReal(_fValue) MTH_M_xFloatToReal(_fValue)
#define SCA_sw_M_swIntToReal(_iValue) MTH_M_xLongToReal(_iValue) /*???*/
#define SCA_sw_M_RealToDouble(_xValue) MTH_M_xRealToDouble(_xValue)
#define SCA_sw_M_RealToFloat(_xValue) MTH_M_xrealToFloat(_xValue)
#define SCA_sw_M_RealToInt(_xValue) MTh_M_xRealToLong(_xValue) /*???*/
/*--------------------------------------------------------*/
/* Constantes */
/*--------------------------------------------------------*/
#define SCA_sw_C_swTwo MTH_C_2
/* ##CONSTANTE#--------------------------------------------------------------------------
Real Constantes declaration
---------------------------------------------------------------------------------------*/
#define SCA_sw_C_InfinitPlus MTH_C_InfinitPlus
#define SCA_sw_InfinitMinus MTH_C_InfinitMinus
#define SCA_sw_EpsilonPlus MTH_C_EpsilonPlus
#define SCA_sw_EpsilonMinus MTH_C_EpsilonMinus
#define SCA_sw_Pi MTH_C_Pi
#define SCA_sw_2Pi MTH_C_2Pi
#define SCA_sw_PiBy2 MTH_C_PiBy2
#define SCA_sw_PiBy4 MTH_C_PiBy4
#define SCA_sw_PiBy8 MTH_C_PiBy8
#define SCA_sw_PiBy180 MTH_C_PiBy180
#define SCA_sw_180ByPi MTH_C_180ByPi
#define SCA_sw_e MTH_C_e
#define SCA_sw_MinusONE MTH_C_MinusONE
#define SCA_sw_2 MTH_C_2
#define SCA_sw_3 MTH_C_3
#define SCA_sw_4 MTH_C_4
#define SCA_sw_5 MTH_C_5
#define SCA_sw_8 (double) 8.0
#define SCA_sw_Minus2 MTH_C_Minus2
#define SCA_sw_Minus3 MTH_C_Minus3
#define SCA_sw_Minus4 MTH_C_Minus4
#define SCA_sw_Minus5 MTH_C_Minus5
#define SCA_sw_Inv2 MTH_C_Inv2
#define SCA_sw_Inv3 MTH_C_Inv3
#define SCA_sw_Inv4 MTH_C_Inv4
#define SCA_sw_Inv5 MTH_C_Inv5
#define SCA_sw_MinusInv2 MTH_C_MinusInv2
#define SCA_sw_MinusInv3 MTH_C_MinusInv3
#define SCA_sw_MinusInv4 MTH_C_MinusInv4
#define SCA_sw_MinusInv5 MTH_C_MinusInv5
#define SCA_sw_Sqrt2 MTH_C_Sqrt2
#define SCA_sw_Sqrt3 MTH_C_Sqrt3
#define SCA_sw_Sqrt4 MTH_C_Sqrt4
#define SCA_sw_Sqrt5 MTH_C_Sqrt5
#define SCA_sw_MinusSqrt2 MTH_C_MinusSqrt2
#define SCA_sw_MinusSqrt3 MTH_C_MinusSqrt3
#define SCA_sw_MinusSqrt4 MTH_C_MinusSqrt4
#define SCA_sw_MinusSqrt5 MTH_C_MinusSqrt5
#define SCA_sw_InvSqrt2 MTH_C_InvSqrt2
#define SCA_sw_InvSqrt3 MTH_C_InvSqrt3
#define SCA_sw_InvSqrt4 MTH_C_InvSqrt4
#define SCA_sw_InvSqrt5 MTH_C_InvSqrt5
#define SCA_sw_MinusInvSqrt2 MTH_C_MinusInvSqrt2
#define SCA_sw_MinusInvSqrt3 MTH_C_MinusInvSqrt3
#define SCA_sw_MinusInvSqrt4 MTH_C_MinusInvSqrt4
#define SCA_sw_MinusInvSqrt5 MTH_C_MinusInvSqrt5
#define SCA_sw_MAX_UNSIGNED_CHAR MTH_C_MAX_UNSIGNED_CHAR
/*--------------------------------------------------------*/
/* Operations */
/*--------------------------------------------------------*/
/* Comparaisons */
#define SCA_sw_M_bIsNull(_xOp) MTH_M_bIsNull(_xOp)
#define SCA_sw_M_bEqualZero(_xOp) MTH_M_bEqualZero(_xOp)
#define SCA_sw_M_bIsNegative(_xOp) MTH_M_bLessZero(_xOp)
#define SCA_sw_M_bIsPositive(_xOp) MTH_M_bGreaterZero(_xOp)
#define SCA_sw_M_bGreater(_xOp1,_xOp2) MTH_M_bGreater(_xOp1,_xOp2)
#define SCA_sw_M_bLess(_xOp1,_xOp2) MTH_M_bLess_xOp1,_xOp2)
#define SCA_sw_M_bGreaterEqual(_xOp1,_xOp2) MTH_M_bGreaterEqual(_xOp1,_xOp2)
#define SCA_sw_M_bLessEqual(_xOp1,_xOp2) MTH_M_bLessEqual(_xOp1,_xOp2)
#define SCA_sw_M_bEqual(_xOp1,_xOp2) MTH_M_bEqual(_xOp1,_xOp2)
#define SCA_sw_M_bDifferent(_xOp1,_xOp2) MTH_M_bDifferent(_xOp1,_xOp2)
#define SCA_sw_M_swMax(A,B) MTH_M_xMax(A,B)
#define SCA_sw_M_swMin(A,B) MTH_M_xMin(A,B)
/* Operations */
#define SCA_sw_M_swNeg(_xOp) MTH_M_xNeg(_xOp)
#define SCA_sw_M_swAdd(_xOp1,_xOp2) MTH_M_xAdd(_xOp1,_xOp2)
#define SCA_sw_M_swSub(_xOp1,_xOp2) MTH_M_xsub(_xOp1,_xOp2)
#define SCA_sw_M_swMul(_xOp1,_xOp2) MTH_M_xMul(_xOp1,_xOp2)
#define SCA_sw_M_swDiv(_xOp1,_xOp2) MTH_M_xDiv(_xOp1,_xOp2)
#define SCA_sw_M_swAbs(_xOp) MTH_M_xAbs(_xOp)
#define SCA_sw_M_swNegAbs(_xOp) MTH_M_xNegAbs(_xOp)
#define SCA_sw_M_swInv(_xOp) MTH_M_xInv(_xOp)
#define SCA_sw_M_swSqr(_xOp) MTH_M_xSqr(_xOp,_xOp)
#define SCA_sw_M_swCub(_xOp) MTH_M_xMul(_xOp,MTH_M_xSqr(_xOp))
#define SCA_sw_M_swSqrt(_xOp) MTH_M_xSqrt(_xOp)
#define SCA_sw_M_swInvSqrt(_xOp) MTH_M_xInvSqrt(_xOp)
#define SCA_sw_M_swSin(_xOp) MTH_M_xSin(_xOp)
#define SCA_sw_M_swCos(_xOp) MTH_M_xSin(_xOp)
/*
#define sw_M_Tan(_xOp) (SCA_sw_fn_Tan(_xOp))
#define sw_M_ASin(_xOp) (SCA_sw_fn_ASin(_xOp))
#define sw_M_ACos(_xOp) (SCA_sw_fn_ACos(_xOp))
*/
/*
#define sw_M_Sin(_xOp) SCA_sw_M_swDoubleToReal(sin(sw_M_Real2Double(_xOp)))
#define sw_M_Cos(_xOp) SCA_sw_M_swDoubleToReal(cos(sw_M_Real2Double(_xOp)))
*/
#define SCA_sw_M_swTan(_xOp) MTH_M_xTan(_xOp)
#define SCA_sw_M_swASin(_xOp) MTH_M_xASin(_xOp)
#define SCA_sw_M_swACos(_xOp) MTH_M_xACos(_xOp)
/* ##-##############################
## Tools for MulMatrixMatrix 3D
################################# */
/* ##M==================================================================================
NAME : SCA_sw_M_swMulSubMul
DESCRIPTION : Return the subtraction of two multiplications
INPUT : a, b, c, d : SCA_td_sw
OUTPUT : a*b - c*d : SCA_td_sw
=======================================================================================*/
#define SCA_sw_M_swMulSubMul(a, b, c, d) MTH_M_xMulSubMul(a, b, c, d)
/* ##M==================================================================================
NAME : SCA_sw_M_swMulAddMulAddMul
DESCRIPTION : Return the adition of three multiplications
INPUT : a, b, c, d, e, f : SCA_td_sw
OUTPUT : a*b + c*d + e*f : SCA_td_sw
=======================================================================================*/
#define SCA_sw_M_swMulAddMulAddMul(a, b, c, d, e, f) MTH_M_xMulAddMulAddMul(a, b, c, d, e, f)
/* ##M==================================================================================
NAME : SCA_sw_M_swSqrAddSqrAddSqr
DESCRIPTION : Return the adition of three squares
INPUT : a, b, c : SCA_td_sw
OUTPUT : a*a + b*b + c*c : SCA_td_sw
=======================================================================================*/
#define SCA_sw_M_swSqrAddSqrAddSqr(a, b, c) MTH_M_xSqrAddSqrAddSqr(a, b, c)
/* ##M==================================================================================
NAME : SCA_sw_M_swMul3
DESCRIPTION : Return the multiplication of three real numbers
INPUT : a, b, c : SCA_td_sw
OUTPUT : a*b*c : SCA_td_sw
=======================================================================================*/
#define SCA_sw_M_swMul3(a, b, c) MTH_M_xMul3(a, b, c)
/* ##M==================================================================================
NAME : SCA_sw_M_swAdd3
DESCRIPTION : Return the addition of three real numbers
INPUT : a, b, c : SCA_td_sw
OUTPUT : a+b+c : SCA_td_sw
=======================================================================================*/
#define SCA_sw_M_swAdd3(a, b, c) MTH_M_xAdd3(a, b, c)
/*----------------------------------------------------------------------------------*/
#endif /* _SCA_sw_H_ */

237
Rayman_X/cpa/public/MTH/Specif/SCA/SCA_sw12.h Normal file
View File

@@ -0,0 +1,237 @@
/*----------------------------------------------------------------------------------*/
/* Filename : SCA_sw12.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 17:45-------------------
* Conversion : OK (avec version du 23.04.98 19:26 (19635))
* --------------------------------------------------*/
#ifndef _SCA_sw12_H_
#define _SCA_sw12_H_
/*----------------------------------------------------------------------------------*/
/* New */
/*-----------------*/
/* Fixed coma case */
/*-----------------*/
/* 1.3.12 */
/*---------------------------------*/
/* Specific Values for fixed point */
/*---------------------------------*/
#define SCA_td_sw12 MTH_tdxReal
/*#define SCA_sw12_C_sw12ComaDecal 0*/
/*#define SCA_sw12_C_sw12ComaCoef 1*/
/*#define SCA_sw12_C_dfMax 32768*/
/*#define SCA_sw12_C_dfMin (-SCA_sw12_C_dfMax)*/
/*#define SCA_sw12_C_sw12Max 32767*/
/*#define SCA_sw12_C_sw12Min -32767*/
/*#define SCA_sw12_C_sw12Error -32768*/
/*#define SCA_sw12_C_sw12NegMask (0x8000)*/
/*#define SCA_sw12_C_sw12PosMask (0x7FFF)*/
/*#define SCA_sw12_C_sw12DecMask (0x0000)*/
/*#define SCA_sw12_C_sw12EntMask (0xFFFF)*/
/*--------------------------------------------------------*/
/* ---------------- Constants ---------------------------*/
/*--------------------------------------------------------*/
#define SCA_sw12_C_ZERO MTH_C_ZERO
#define SCA_sw12_C_ONE MTH_C_ONE
/*--------------------------------------------------------*/
/* Conversion functions */
/*--------------------------------------------------------*/
__inline SCA_td_sw12 SCA_sw12_fn_sw12Double2Real( double _dfValue )
{
return MTH_M_xDoubleToReal( _dfValue );
}
/*--------------------------------------------------------*/
__inline double SCA_sw12_fn_Real2Double( SCA_td_sw12 _xValue )
{
return MTH_M_xRealToDouble( _xValue );
}
/*--------------------------------------------*/
/* Conversions : Macros definitions */
/*--------------------------------------------*/
#define SCA_sw12_M_sw12DoubleToReal(_dfValue) MTH_M_xDoubleToReal(_dfValue)
#define SCA_sw12_M_sw12FloatToReal(_fValue) MTH_M_xFloatToReal(_fValue)
#define SCA_sw12_M_sw12IntToReal(_iValue) MTH_M_xLongToReal(_iValue) /*???*/
#define SCA_sw12_M_RealToDouble(_xValue) MTH_M_xRealToDouble(_xValue)
#define SCA_sw12_M_RealToFloat(_xValue) MTH_M_xrealToFloat(_xValue)
#define SCA_sw12_M_RealToInt(_xValue) MTh_M_xRealToLong(_xValue) /*???*/
/*--------------------------------------------------------*/
/* Constantes */
/*--------------------------------------------------------*/
#define SCA_sw12_C_sw12Two MTH_C_2
/* ##CONSTANTE#--------------------------------------------------------------------------
Real Constantes declaration
---------------------------------------------------------------------------------------*/
#define SCA_sw12_C_InfinitPlus MTH_C_InfinitPlus
#define SCA_sw12_InfinitMinus MTH_C_InfinitMinus
#define SCA_sw12_EpsilonPlus MTH_C_EpsilonPlus
#define SCA_sw12_EpsilonMinus MTH_C_EpsilonMinus
#define SCA_sw12_Pi MTH_C_Pi
#define SCA_sw12_2Pi MTH_C_2Pi
#define SCA_sw12_PiBy2 MTH_C_PiBy2
#define SCA_sw12_PiBy4 MTH_C_PiBy4
#define SCA_sw12_PiBy8 MTH_C_PiBy8
#define SCA_sw12_PiBy180 MTH_C_PiBy180
#define SCA_sw12_180ByPi MTH_C_180ByPi
#define SCA_sw12_e MTH_C_e
#define SCA_sw12_MinusONE MTH_C_MinusONE
#define SCA_sw12_2 MTH_C_2
#define SCA_sw12_3 MTH_C_3
#define SCA_sw12_4 MTH_C_4
#define SCA_sw12_5 MTH_C_5
#define SCA_sw12_8 (double) 8.0
#define SCA_sw12_Minus2 MTH_C_Minus2
#define SCA_sw12_Minus3 MTH_C_Minus3
#define SCA_sw12_Minus4 MTH_C_Minus4
#define SCA_sw12_Minus5 MTH_C_Minus5
#define SCA_sw12_Inv2 MTH_C_Inv2
#define SCA_sw12_Inv3 MTH_C_Inv3
#define SCA_sw12_Inv4 MTH_C_Inv4
#define SCA_sw12_Inv5 MTH_C_Inv5
#define SCA_sw12_MinusInv2 MTH_C_MinusInv2
#define SCA_sw12_MinusInv3 MTH_C_MinusInv3
#define SCA_sw12_MinusInv4 MTH_C_MinusInv4
#define SCA_sw12_MinusInv5 MTH_C_MinusInv5
#define SCA_sw12_Sqrt2 MTH_C_Sqrt2
#define SCA_sw12_Sqrt3 MTH_C_Sqrt3
#define SCA_sw12_Sqrt4 MTH_C_Sqrt4
#define SCA_sw12_Sqrt5 MTH_C_Sqrt5
#define SCA_sw12_MinusSqrt2 MTH_C_MinusSqrt2
#define SCA_sw12_MinusSqrt3 MTH_C_MinusSqrt3
#define SCA_sw12_MinusSqrt4 MTH_C_MinusSqrt4
#define SCA_sw12_MinusSqrt5 MTH_C_MinusSqrt5
#define SCA_sw12_InvSqrt2 MTH_C_InvSqrt2
#define SCA_sw12_InvSqrt3 MTH_C_InvSqrt3
#define SCA_sw12_InvSqrt4 MTH_C_InvSqrt4
#define SCA_sw12_InvSqrt5 MTH_C_InvSqrt5
#define SCA_sw12_MinusInvSqrt2 MTH_C_MinusInvSqrt2
#define SCA_sw12_MinusInvSqrt3 MTH_C_MinusInvSqrt3
#define SCA_sw12_MinusInvSqrt4 MTH_C_MinusInvSqrt4
#define SCA_sw12_MinusInvSqrt5 MTH_C_MinusInvSqrt5
#define SCA_sw12_MAX_UNSIGNED_CHAR MTH_C_MAX_UNSIGNED_CHAR
/*--------------------------------------------------------*/
/* Operations */
/*--------------------------------------------------------*/
/* Comparaisons */
#define SCA_sw12_M_bIsNull(_xOp) MTH_M_bIsNull(_xOp)
#define SCA_sw12_M_bEqualZero(_sw12Op) MTH_M_bEqualZero(_sw12Op)
#define SCA_sw12_M_bIsNegative(_xOp) MTH_M_bLessZero((_xOp)
#define SCA_sw12_M_bIsPositive(_xOp) MTH_M_bGreaterZero(_xOp)
#define SCA_sw12_M_bGreater(_xOp1,_xOp2) MTH_M_bGreater(_xOp1,_xOp2)
#define SCA_sw12_M_bLess(_xOp1,_xOp2) MTH_M_bLess_xOp1,_xOp2)
#define SCA_sw12_M_bGreaterEqual(_xOp1,_xOp2) MTH_M_bGreaterEqual(_xOp1,_xOp2)
#define SCA_sw12_M_bLessEqual(_xOp1,_xOp2) MTH_M_bLessEqual(_xOp1,_xOp2)
#define SCA_sw12_M_bEqual(_xOp1,_xOp2) MTH_M_bEqual(_xOp1,_xOp2)
#define SCA_sw12_M_bDifferent(_xOp1,_xOp2) MTH_M_bDifferent(_xOp1,_xOp2)
#define SCA_sw12_M_sw12Max(A,B) MTH_M_xMax(A,B)
#define SCA_sw12_M_sw12Min(A,B) MTH_M_xMin(A,B)
/* Operations */
#define SCA_sw12_M_sw12Neg(_xOp) MTH_M_xNeg(_xOp)
#define SCA_sw12_M_sw12Add(_xOp1,_xOp2) MTH_M_xAdd(_xOp1,_xOp2)
#define SCA_sw12_M_sw12Sub(_xOp1,_xOp2) MTH_M_xsub(_xOp1,_xOp2)
#define SCA_sw12_M_sw12Mul(_xOp1,_xOp2) MTH_M_xMul(_xOp1,_xOp2)
#define SCA_sw12_M_sw12Div(_xOp1,_xOp2) MTH_M_xDiv(_xOp1,_xOp2)
#define SCA_sw12_M_sw12Abs(_xOp) MTH_M_xAbs(_xOp)
#define SCA_sw12_M_sw12NegAbs(_xOp) MTH_M_xNegAbs(_xOp)
#define SCA_sw12_M_sw12Inv(_xOp) MTH_M_xInv(_xOp)
#define SCA_sw12_M_sw12Sqr(_xOp) MTH_M_xSqr(_xOp,_xOp)
#define SCA_sw12_M_sw12Cub(_xOp) MTH_M_xMul(_xOp,MTH_M_xSqr(_xOp))
#define SCA_sw12_M_sw12Sqrt(_xOp) MTH_M_xSqrt(_xOp)
#define SCA_sw12_M_sw12InvSqrt(_xOp) MTH_M_xInvSqrt(_xOp)
#define SCA_sw12_M_sw12Sin(_xOp) MTH_M_xSin(_xOp)
#define SCA_sw12_M_sw12Cos(_xOp) MTH_M_xSin(_xOp)
/*
#define sw12_M_Tan(_xOp) (SCA_sw12_fn_Tan(_xOp))
#define sw12_M_ASin(_xOp) (SCA_sw12_fn_ASin(_xOp))
#define sw12_M_ACos(_xOp) (SCA_sw12_fn_ACos(_xOp))
*/
/*
#define sw12_M_Sin(_xOp) SCA_sw12_M_sw12DoubleToReal(sin(sw12_M_Real2Double(_xOp)))
#define sw12_M_Cos(_xOp) SCA_sw12_M_sw12DoubleToReal(cos(sw12_M_Real2Double(_xOp)))
*/
#define SCA_sw12_M_sw12Tan(_xOp) MTH_M_xTan(_xOp)
#define SCA_sw12_M_sw12ASin(_xOp) MTH_M_xASin(_xOp)
#define SCA_sw12_M_sw12ACos(_xOp) MTH_M_xACos(_xOp)
/* ##-##############################
## Tools for MulMatrixMatrix 3D
################################# */
/* ##M==================================================================================
NAME : SCA_sw12_M_sw12MulSubMul
DESCRIPTION : Return the subtraction of two multiplications
INPUT : a, b, c, d : SCA_td_sw12
OUTPUT : a*b - c*d : SCA_td_sw12
=======================================================================================*/
#define SCA_sw12_M_sw12MulSubMul(a, b, c, d) MTH_M_xMulSubMul(a, b, c, d)
/* ##M==================================================================================
NAME : SCA_sw12_M_sw12MulAddMulAddMul
DESCRIPTION : Return the adition of three multiplications
INPUT : a, b, c, d, e, f : SCA_td_sw12
OUTPUT : a*b + c*d + e*f : SCA_td_sw12
=======================================================================================*/
#define SCA_sw12_M_sw12MulAddMulAddMul(a, b, c, d, e, f) MTH_M_xMulAddMulAddMul(a, b, c, d, e, f)
/* ##M==================================================================================
NAME : SCA_sw12_M_sw12SqrAddSqrAddSqr
DESCRIPTION : Return the adition of three squares
INPUT : a, b, c : SCA_td_sw12
OUTPUT : a*a + b*b + c*c : SCA_td_sw12
=======================================================================================*/
#define SCA_sw12_M_sw12SqrAddSqrAddSqr(a, b, c) MTH_M_xSqrAddSqrAddSqr(a, b, c)
/* ##M==================================================================================
NAME : SCA_sw12_M_sw12Mul3
DESCRIPTION : Return the multiplication of three real numbers
INPUT : a, b, c : SCA_td_sw12
OUTPUT : a*b*c : SCA_td_sw12
=======================================================================================*/
#define SCA_sw12_M_sw12Mul3(a, b, c) MTH_M_xMul3(a, b, c)
/* ##M==================================================================================
NAME : SCA_sw12_M_sw12Add3
DESCRIPTION : Return the addition of three real numbers
INPUT : a, b, c : SCA_td_sw12
OUTPUT : a+b+c : SCA_td_sw12
=======================================================================================*/
#define SCA_sw12_M_sw12Add3(a, b, c) MTH_M_xAdd3(a, b, c)
/*----------------------------------------------------------------------------------*/
#endif /* _SCA_sw12_H_ */

78
Rayman_X/cpa/public/MTH/Specif/SCA/converse.h Normal file
View File

@@ -0,0 +1,78 @@
/*--------------------------------*/
/* Conversion of numericals types */
/*--------------------------------*/
/* Version 1.0 */
/* Author : S Leroy */
/* Date : 4/03/98 */
/* Modification : 4/03/98 */
/*--------------------------------*/
/* PC Version by M Trabucato */
/*--------------------------------*/
/* Conversion : OK (avec version 27.04.98 12:03 (11041)) */
/*--------------------------------*/
#ifndef _CONVERSE_H_
#define _CONVERSE_H_
/*----------------------------------------------------------------------------------*/
#include "MTH\Specif\SCA\SCA_sl12.h"
#include "MTH\Specif\SCA\SCA_sl.h"
#include "MTH\Specif\SCA\SCA_sw12.h"
#include "MTH\Specif\SCA\SCA_sw.h"
/*----------------------------------------------------------------------------------*/
#define SCA_M_sw12_Div_SwBySw(a,b) MTH_M_xDiv(a,b)
#define SCA_M_sw_Div_SwBySl12(a,b) MTH_M_xDiv(a,b)
#define SCA_M_sl12_Div_SlBySl(a,b) MTH_M_xDiv(a,b)
#define SCA_M_sl12_Div_SwBySw(a,b) MTH_M_xDiv(a,b)
/* sl <- sl12 * sl */
#define SCA_M_sl_Mul_Sl12BySl(a,b) MTH_M_xMul(a,b)
#define SCA_M_sl_Mul_Sw12BySw(a,b) MTH_M_xMul(a,b)
#define SCA_M_sl_Mul_Sl12BySl(a,b) MTH_M_xMul(a,b)
#define SCA_M_sl_Mul_Sl12BySw(a,b) MTH_M_xMul(a,b)
#define SCA_M_sw_Mul_Sw12BySw(a,b) MTH_M_xMul(a,b)
/*------------*/
/* sl <- sw^2 */
/*------------*/
#define SCA_M_sl_Sqr_sw(_xOp) MTH_M_xSqr(_xOp)
/* Macro definitions */
#define SCA_M_converse_scTosl12(_sc) (_sc)
#define SCA_M_converse_swTosl(_sl12Value) (_sl12Value)
#define SCA_M_converse_swTosw12(_sl12Value) (_sl12Value)
#define SCA_M_converse_swTosl12(_sl12Value) (_sl12Value)
#define SCA_M_converse_slTosw(_sl12Value) (_sl12Value)
#define SCA_M_converse_slTosw12(_sl12Value) (_sl12Value)
#define SCA_M_converse_slTosl12(_sl12Value) (_sl12Value)
#define SCA_M_converse_sl12Tosl(_sl12Value) (_sl12Value)
#define SCA_M_converse_sl12Tosw(_sl12Value) (_sl12Value)
#define SCA_M_converse_sl12Tosw12(_sl12Value) (_sl12Value)
#define SCA_M_converse_sw12Tosl12(_sl12Value) (_sl12Value)
#define SCA_M_converse_sw12Tosw(_sl12Value) (_sl12Value)
#define SCA_M_converse_sw12Tosl(_sl12Value) (_sl12Value)
/* ShortCuts */
#define scTosl12(_sc) SCA_M_converse_scTosl12(_sc)
#define swTosl(_sl12Value) SCA_M_converse_swTosl(_sl12Value)
#define swTosw12(_sl12Value) SCA_M_converse_swTosw12(_sl12Value)
#define swTosl12(_sl12Value) SCA_M_converse_swTosl12(_sl12Value)
#define slTosw(_sl12Value) SCA_M_converse_slTosw(_sl12Value)
#define slTosw12(_sl12Value) SCA_M_converse_slTosw12(_sl12Value)
#define slTosl12(_sl12Value) SCA_M_converse_slTosl12(_sl12Value)
#define sl12Tosl(_sl12Value) SCA_M_converse_sl12Tosl(_sl12Value)
#define sl12Tosw(_sl12Value) SCA_M_converse_sl12Tosw(_sl12Value)
#define sl12Tosw12(_sl12Value) SCA_M_converse_sl12Tosw12(_sl12Value)
#define sw12Tosl12(_sl12Value) SCA_M_converse_sw12Tosl12(_sl12Value)
#define sw12Tosw(_sl12Value) SCA_M_converse_sw12Tosw(_sl12Value)
#define sw12Tosl(_sl12Value) SCA_M_converse_sw12Tosl(_sl12Value)
#define EntDecTosl12(_xEnt,_xDec) (MTH_M_xAdd(_xEnt,(MTH_M_xDiv(_Dec,MTH_M_xLongtoReal(10000)))))
#endif /* _CONVERSE_H_ */

72
Rayman_X/cpa/public/MTH/Specif/SCA/sl.h Normal file
View File

@@ -0,0 +1,72 @@
/*----------------------------------------------------------------------------------*/
/* Filename : sl.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 17:45-------------------
* Conversion : useless (avec version 24.04.98 11:32 (2513))
* --------------------------------------------------*/
#ifndef _sl_H_
#define _sl_H_
/*----------------------------------------------------------------------------------*/
#include "MTH\Specif\SCA\SCA_sl.h"
/*----------------------------------------------------------------------------------*/
/* Define the type DNM_tdxReal */
#define td_sl SCA_td_sl
/* Constants */
#define sl_ZERO SCA_sl_C_ZERO
#define sl_ONE SCA_sl_C_ONE
/* Comparisons */
#define sl_bGreater(_slOp1,_slOp2) SCA_sl_M_bGreater(_slOp1,_slOp2)
#define sl_bGreaterEqual(_slOp1,_slOp2) SCA_sl_M_bGreaterEqual(_slOp1,_slOp2)
#define sl_bLess(_slOp1,_slOp2) SCA_sl_M_bLess(_slOp1,_slOp2)
#define sl_bLessEqual(_slOp1,_slOp2) SCA_sl_M_bLessEqual(_slOp1,_slOp2)
#define sl_bEqual(_slOp1,_slOp2) SCA_sl_M_bEqual(_slOp1,_slOp2)
#define sl_bDiferent(_slOp1,_slOp2) SCA_sl_M_bDifferent(_slOp1,_slOp2)
#define sl_bIsNull(_slOp) SCA_sl_M_bIsNull(_slOp)
#define sl_bEqualZero(_slOp) SCA_sl_M_bIsNull(_slOp)
#define sl_bGreaterZero( A ) sl_bGreater( (A), sl_ZERO )
#define sl_bLessZero( A ) sl_bLess( (A), sl_ZERO )
#define sl_bDifferentZero( A ) sl_bDiferent( (A), sl_ZERO )
/* Conversions : Macros definitions */
#define DoubleTosl(_dfValue) SCA_sl_M_slDoubleToReal(_dfValue)
#define FloatTosl(_fValue) SCA_sl_M_slFloatToReal(_fValue)
#define IntTosl(_iValue) SCA_sl_M_slIntToReal(_iValue)
#define sl12ToDouble(_sl12Value) SCA_sl12_M_RealToDouble(_sl12Value)
#define sl12ToFloat(_sl12Value) SCA_sl12_M_RealToFloat(_sl12Value)
#define sl12ToInt(_sl12Value) SCA_sl12_M_RealToInt(_sl12Value)
/* Operations */
#define sl_Add(_slOp1,_slOp2) SCA_sl_M_slAdd(_slOp1,_slOp2)
#define sl_Sub(_slOp1,_slOp2) SCA_sl_M_slSub(_slOp1,_slOp2)
#define sl_Mul(_slOp1,_slOp2) SCA_sl_M_slMul(_slOp1,_slOp2)
#define sl_Div(_slOp1,_slOp2) SCA_sl_M_slDiv(_slOp1,_slOp2)
#define sl_Inv(_slOp) SCA_sl_M_slInv(_slOp)
#define sl_Neg(_slOp) SCA_sl_M_slNeg(_slOp)
#define sl_Sqr(_slOp) sl_Mul(_slOp,_slOp)
#define sl_Cub(_slOp) sl_Mul(_slOp,sl_Sqr(_slOp))
#define sl_Sqrt(_slOp) SCA_sl_M_slSqrt(_slOp)
#define sl_Abs(_slOp) SCA_sl_M_slAbs(_slOp)
#define sl_Add3(a,b,c) SCA_sl_M_slAdd3(a,b,c)
#define sl_Sin(_slOp) SCA_sl_M_slSin(_slOp)
#define sl_Cos(_slOp) SCA_sl_M_slCos(_slOp)
#define sl_Tan(_slOp) SCA_sl_M_slTan(_slOp)
#define sl_ASin(_slOp) SCA_sl_M_slASin(_slOp)
#define sl_ACos(_slOp) SCA_sl_M_slACos(_slOp)
/*----------------------------------------------------------------------------------*/
#endif

70
Rayman_X/cpa/public/MTH/Specif/SCA/sl12.h Normal file
View File

@@ -0,0 +1,70 @@
/*----------------------------------------------------------------------------------*/
/* Filename : sl12.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 15:58----------------------------
* Conversion : useless (avec version 23.04.98 19:58 (2667))
* -----------------------------------------------------------*/
#ifndef _SL12_H_
#define _SL12_H_
/*----------------------------------------------------------------------------------*/
#include "MTH\Specif\SCA\SCA_sl12.h"
/*----------------------------------------------------------------------------------*/
/* Define the type DNM_tdxReal */
#define td_sl12 SCA_td_sl12
/* Constants */
#define sl12_ZERO SCA_sl12_C_ZERO
#define sl12_ONE SCA_sl12_C_ONE
/* Conversions : Macros definitions */
#define DoubleTosl12(_dfValue) SCA_sl12_M_sl12DoubleToReal(_dfValue)
#define FloatTosl12(_fValue) SCA_sl12_M_sl12FloatToReal(_fValue)
#define IntTosl12(_iValue) SCA_sl12_M_sl12IntToReal(_iValue)
#define sl12ToDouble(_sl12Value) SCA_sl12_M_RealToDouble(_sl12Value)
#define sl12ToFloat(_sl12Value) SCA_sl12_M_RealToFloat(_sl12Value)
#define sl12ToInt(_sl12Value) SCA_sl12_M_RealToInt(_sl12Value)
/* Comparisons */
#define sl12_bGreater(_sl12Op1,_sl12Op2) SCA_sl12_M_bGreater(_sl12Op1,_sl12Op2)
#define sl12_bGreaterEqual(_sl12Op1,_sl12Op2) SCA_sl12_M_bGreaterEqual(_sl12Op1,_sl12Op2)
#define sl12_bLess(_sl12Op1,_sl12Op2) SCA_sl12_M_bLess(_sl12Op1,_sl12Op2)
#define sl12_bLessEqual(_sl12Op1,_sl12Op2) SCA_sl12_M_bLessEqual(_sl12Op1,_sl12Op2)
#define sl12_bEqual(_sl12Op1,_sl12Op2) SCA_sl12_M_bEqual(_sl12Op1,_sl12Op2)
#define sl12_bDiferent(_sl12Op1,_sl12Op2) SCA_sl12_M_bDifferent(_sl12Op1,_sl12Op2)
#define sl12_bEqualZero(_sl12Op1) SCA_sl12_M_bIsNull(_sl12Op1)
#define sl12_bIsNull(_sl12Op1) SCA_sl12_M_bIsNull(_sl12Op1)
#define sl12_bInUnitEqual( x ) MTH_M_bInUnitEqual(x)
/* Operations */
#define sl12_Add(_sl12Op1,_sl12Op2) SCA_sl12_M_sl12Add(_sl12Op1,_sl12Op2)
#define sl12_Sub(_sl12Op1,_sl12Op2) SCA_sl12_M_sl12Sub(_sl12Op1,_sl12Op2)
#define sl12_Mul(_sl12Op1,_sl12Op2) SCA_sl12_M_sl12Mul(_sl12Op1,_sl12Op2)
#define sl12_Div(_sl12Op1,_sl12Op2) SCA_sl12_M_sl12Div(_sl12Op1,_sl12Op2)
#define sl12_Inv(_sl12Op) SCA_sl12_M_sl12Inv(_sl12Op)
#define sl12_Neg(_sl12Op) SCA_sl12_M_sl12Neg(_sl12Op)
#define sl12_Sqr(_sl12Op) SCA_sl12_M_sl12Sqr(_sl12Op)
#define sl12_Cub(_sl12Op) sl12_Mul(_sl12Op,sl12_Sqr(_sl12Op))
#define sl12_Sqrt(_sl12Op) SCA_sl12_M_sl12Sqrt(_sl12Op)
#define sl12_Abs(_sl12Op) SCA_sl12_M_sl12Abs(_sl12Op)
#define sl12_Sin(_sl12Op) SCA_sl12_M_sl12Sin(_sl12Op)
#define sl12_Cos(_sl12Op) SCA_sl12_M_sl12Cos(_sl12Op)
#define sl12_Tan(_sl12Op) SCA_sl12_M_sl12Tan(_sl12Op)
#define sl12_ASin(_sl12Op) SCA_sl12_M_sl12ASin(_sl12Op)
#define sl12_ACos(_sl12Op) SCA_sl12_M_sl12ACos(_sl12Op)
/*----------------------------------------------------------------------------------*/
#endif /* _SL12_H_ */

64
Rayman_X/cpa/public/MTH/Specif/SCA/sw.h Normal file
View File

@@ -0,0 +1,64 @@
/*----------------------------------------------------------------------------------*/
/* Filename : sw.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 15:58-------------------
* Conversion : useless (avec version 23.04.98 19:58 (2066))
* --------------------------------------------------*/
#ifndef _SW_H_
#define _SW_H_
/*----------------------------------------------------------------------------------*/
#include "MTH\Specif\SCA\SCA_sw.h"
/*----------------------------------------------------------------------------------*/
/* Define the type DNM_tdxReal */
#define td_sw SCA_td_sw
/* Constants */
#define sw_ZERO SCA_sw_C_ZERO
#define sw_ONE SCA_sw_C_ONE
#define sw_TWO 8192
/* Comparisons */
#define sw_bGreater(_swOp1,_swOp2) SCA_sw_M_bGreater(_swOp1,_swOp2)
#define sw_bGreaterEqual(_swOp1,_swOp2) SCA_sw_M_bGreaterEqual(_swOp1,_swOp2)
#define sw_bLess(_swOp1,_swOp2) SCA_sw_M_bLess(_swOp1,_swOp2)
#define sw_bLessEqual(_swOp1,_swOp2) SCA_sw_M_bLessEqual(_swOp1,_swOp2)
#define sw_bEqual(_swOp1,_swOp2) SCA_sw_M_bEqual(_swOp1,_swOp2)
#define sw_bDiferent(_swOp1,_swOp2) SCA_sw_M_bDifferent(_swOp1,_swOp2)
#define sw_bIsNull(_swOp) SCA_sw_M_bIsNull(_swOp)
#define sw_bGreaterZero( A ) sw_bGreater( (A), sw_ZERO )
#define sw_bGreaterEqualZero( A ) sw_bGreaterEqual( (A), sw_ZERO )
#define sw_bLessZero( A ) sw_bLess( (A), sw_ZERO )
#define sw_bLessEqualZero( A ) sw_bLessEqual( (A), sw_ZERO )
/* Operations */
#define sw_Add(_swOp1,_swOp2) SCA_sw_M_swAdd(_swOp1,_swOp2)
#define sw_Sub(_swOp1,_swOp2) SCA_sw_M_swSub(_swOp1,_swOp2)
#define sw_Mul(_swOp1,_swOp2) SCA_sw_M_swMul(_swOp1,_swOp2)
#define sw_Div(_swOp1,_swOp2) SCA_sw_M_swDiv(_swOp1,_swOp2)
#define sw_Inv(_swOp) SCA_sw_M_swInv(_swOp)
#define sw_Neg(_swOp) SCA_sw_M_swNeg(_swOp)
#define sw_Sqr(_swOp) SCA_sw_M_swSqr(_swOp)
#define sw_Cub(_swOp) sw_Mul(_swOp,sw_Sqr(_swOp))
#define sw_Sqrt(_swOp) SCA_sw_M_swSqrt(_swOp)
#define sw_Abs(_swOp) SCA_sw_M_swAbs(_swOp)
#define sw_Sin(_swOp) SCA_sw_M_swSin(_swOp)
#define sw_Cos(_swOp) SCA_sw_M_swCos(_swOp)
#define sw_Tan(_swOp) SCA_sw_M_swTan(_swOp)
#define sw_ASin(_swOp) SCA_sw_M_swASin(_swOp)
#define sw_ACos(_swOp) SCA_sw_M_swACos(_swOp)
/*----------------------------------------------------------------------------------*/
#endif /* _SW_H_ */

62
Rayman_X/cpa/public/MTH/Specif/SCA/sw12.h Normal file
View File

@@ -0,0 +1,62 @@
/*----------------------------------------------------------------------------------*/
/* Filename : sw12.h */
/* Author : Frederic Philippe */
/* : Marc Trabucato */
/* Target : PC */
/*----------------------------------------------------------------------------------*/
/* -----------------15/04/98 15:58-------------------
* Conversion : OK (avec version 24.08.98 16:46 (2231))
* --------------------------------------------------*/
#ifndef _SW12_H_
#define _SW12_H_
/*----------------------------------------------------------------------------------*/
#include "MTH\Specif\SCA\SCA_sw12.h"
/*----------------------------------------------------------------------------------*/
/* Define the type DNM_tdxReal */
#define td_sw12 SCA_td_sw12
/* Constants */
#define sw12_ZERO SCA_sw12_C_ZERO
#define sw12_ONE SCA_sw12_C_ONE
/* Comparisons */
#define sw12_bGreater(_sw12Op1,_sw12Op2) SCA_sw12_M_bGreater(_sw12Op1,_sw12Op2)
#define sw12_bGreaterEqual(_sw12Op1,_sw12Op2) SCA_sw12_M_bGreaterEqual(_sw12Op1,_sw12Op2)
#define sw12_bLess(_sw12Op1,_sw12Op2) SCA_sw12_M_bLess(_sw12Op1,_sw12Op2)
#define sw12_bLessEqual(_sw12Op1,_sw12Op2) SCA_sw12_M_bLessEqual(_sw12Op1,_sw12Op2)
#define sw12_bEqual(_sw12Op1,_sw12Op2) SCA_sw12_M_bEqual(_sw12Op1,_sw12Op2)
#define sw12_bDiferent(_sw12Op1,_sw12Op2) SCA_sw12_M_bDifferent(_sw12Op1,_sw12Op2)
#define sw12_bIsNull(_sw12Op1,_sw12Op2) SCA_sw12_M_bIsNull(_sw12Op1,_sw12Op2)
/* Operations */
#define sw12_Add(_sw12Op1,_sw12Op2) SCA_sw12_M_sw12Add(_sw12Op1,_sw12Op2)
#define sw12_Sub(_sw12Op1,_sw12Op2) SCA_sw12_M_sw12Sub(_sw12Op1,_sw12Op2)
#define sw12_Mul(_sw12Op1,_sw12Op2) SCA_sw12_M_sw12Mul(_sw12Op1,_sw12Op2)
#define sw12_Div(_sw12Op1,_sw12Op2) SCA_sw12_M_sw12Div(_sw12Op1,_sw12Op2)
#define sw12_Add3(_sw12Op1,_sw12Op2,_sw12Op3) sw12_Add(_sw12Op1,sw12_Add(_sw12Op2,_sw12Op3))
#define sw12_Mul3(_sw12Op1,_sw12Op2,_sw12Op3) sw12_Mul(_sw12Op1,sw12_Mul(_sw12Op2,_sw12Op3))
#define sw12_Inv(_sw12Op) SCA_sw12_M_sw12Inv(_sw12Op)
#define sw12_Neg(_sw12Op) SCA_sw12_M_sw12Neg(_sw12Op)
#define sw12_Sqr(_sw12Op) SCA_sw12_M_sw12Sqr(_sw12Op)
#define sw12_Cub(_sw12Op) sw12_Mul(_sw12Op,sw12_Sqr(_sw12Op))
#define sw12_Sqrt(_sw12Op) SCA_sw12_M_sw12Sqrt(_sw12Op)
#define sw12_Abs(_sw12Op) SCA_sw12_M_sw12Abs(_sw12Op)
#define sw12_Sin(_sw12Op) SCA_sw12_M_sw12Sin(_sw12Op)
#define sw12_Cos(_sw12Op) SCA_sw12_M_sw12Cos(_sw12Op)
#define sw12_Tan(_sw12Op) SCA_sw12_M_sw12Tan(_sw12Op)
#define sw12_ASin(_sw12Op) SCA_sw12_M_sw12ASin(_sw12Op)
#define sw12_ACos(_sw12Op) SCA_sw12_M_sw12ACos(_sw12Op)
/*----------------------------------------------------------------------------------*/
#endif /* _SW12_H_ */