TInt CTestFloat_blr::remquo_remcheck_test()
{
// Create temporary variables in stack
char chParam[MAX_SIZE];
FLOAT input1;
FLOAT input2;
int iPart;
FLOAT expected_fPart;
FLOAT expected_iPart;
FLOAT max_ulp;
FLOAT gen_ulp;
// Read parameters
ReadStringParam ( chParam);
ReadFloatParam ( input1);
ReadFloatParam ( input2);
ReadFloatParam ( expected_fPart);
ReadFloatParam ( expected_iPart);
ReadFloatParam ( max_ulp);
//
TBuf<MAX_SIZE> buf;
TInt len = strlen(chParam);
for (TInt j =0; j<len;j++)
{
buf.Append(chParam[j]);
}
// Do some testing
FLOAT res = FUNC(remquo) (input1, input2, &iPart);
if( check_int(iPart, expected_iPart, max_ulp)
&&check_float(res, expected_fPart, max_ulp, gen_ulp)
)
{
INFO_PRINTF1(_L("Test passed."));
}
else
{
ERR_PRINTF1(_L("Test Failed."));
return KErrGeneral;
}
INFO_PRINTF1(_L("_________________________________________\n"));
INFO_PRINTF2(_L("TestCase : %S\n"), &buf);
INFO_PRINTF2(_L("Input Value 1 : %f\n"), input1 );
INFO_PRINTF2(_L("Input Value 2 : %f\n"), input1 );
INFO_PRINTF2(_L("Expected iPart : %f\n"), expected_fPart );
INFO_PRINTF2(_L("Expected iPart : %f\n"), expected_iPart );
INFO_PRINTF2(_L("Max ULP value : %f\n"), max_ulp );
INFO_PRINTF2(_L("Result fPart : %f\n"), res );
INFO_PRINTF2(_L("Result iPart : %d\n"), iPart );
INFO_PRINTF2(_L("Generated Ulp : %f\n"), gen_ulp );
INFO_PRINTF1(_L("_________________________________________\n"));
return KErrNone;
}
TInt CTestFloat_blr::lgamma_test()
{
// Create temporary variables in stack
char chParam[MAX_SIZE];
FLOAT input1;
FLOAT signgam_exp;
FLOAT expected;
FLOAT max_ulp;
FLOAT gen_ulp;
// Read parameters
ReadStringParam ( chParam);
ReadFloatParam ( input1);
ReadFloatParam ( expected);
ReadFloatParam ( signgam_exp);
ReadFloatParam ( max_ulp);
//
TBuf<MAX_SIZE> buf;
TInt len = strlen(chParam);
for (TInt j =0; j<len;j++)
{
buf.Append(chParam[j]);
}
// Do some testing
signgam = 0;
FLOAT res = FUNC(lgamma) (input1);
if( check_float(res, expected, max_ulp, gen_ulp) && signgam_exp==signgam)
{
INFO_PRINTF1(_L("Test passed."));
}
else
{
ERR_PRINTF1(_L("Test Failed."));
return KErrGeneral;
}
INFO_PRINTF1(_L("_________________________________________\n"));
INFO_PRINTF2(_L("TestCase : %S\n"), &buf);
INFO_PRINTF2(_L("Input Value : %f\n"), input1 );
INFO_PRINTF2(_L("Expected Res : %f\n"), expected );
INFO_PRINTF2(_L("Expected signagam : %f\n"), signgam_exp );
INFO_PRINTF2(_L("Max ULP value : %f\n"), max_ulp );
INFO_PRINTF2(_L("Result : %f\n"), res );
INFO_PRINTF2(_L("Obtained Signgam : %d\n"), signgam );
INFO_PRINTF2(_L("Generated Ulp : %f\n"), gen_ulp );
INFO_PRINTF1(_L("_________________________________________\n"));
return KErrNone;
}
TInt CTestFloat_blr::sinh_test()
{
char chParam[MAX_SIZE];
FLOAT input;
FLOAT expected;
FLOAT max_ulp;
FLOAT gen_ulp;
// Read parameters
ReadStringParam (chParam);
ReadFloatParam (input);
ReadFloatParam (expected);
ReadFloatParam (max_ulp);
//
TBuf<MAX_SIZE> buf;
TInt len = strlen(chParam);
for (TInt j =0; j<len;j++)
{
buf.Append(chParam[j]);
}
// Do some testing
FLOAT res = FUNC(sinh) (input);
if(check_longlong(res, expected, max_ulp, gen_ulp))
{
INFO_PRINTF1(_L("Test passed."));
}
else
{
ERR_PRINTF1(_L("Test Failed."));
return KErrGeneral;
}
INFO_PRINTF1(_L("_________________________________________\n"));
INFO_PRINTF2(_L("TestCase : %S\n"), &buf );
INFO_PRINTF2(_L("Input Value : %f\n"), input );
INFO_PRINTF2(_L("Expected Value : %f\n"), expected );
INFO_PRINTF2(_L("Max ULP value : %f\n"), max_ulp );
INFO_PRINTF2(_L("Result : %f\n"), res );
INFO_PRINTF2(_L("Generated Ulp : %f\n"), gen_ulp );
INFO_PRINTF1(_L("_________________________________________\n"));
return KErrNone;
}
bool STransition::ReadAngleParam( const char* name, bool required, float min, float max, const struct IItemParamsNode*const pParams, float*const pAngle ) const
{
float angleDegrees;
if (!ReadFloatParam(name, required, RAD2DEG(min), RAD2DEG(max), pParams, &angleDegrees))
return false;
*pAngle = DEG2RAD(angleDegrees);
return true;
}
bool STransition::ReadParams( ETransitionType _transitionType, const struct IItemParamsNode*const pParams )
{
transitionType = _transitionType;
animGraphSignal = pParams->GetAttribute("animGraphSignal");
CRY_ASSERT_TRACE(animGraphSignal.length() > 0, ("animGraphSignal not found or empty"));
if (!(animGraphSignal.length() > 0)) return false;
pseudoSpeed = 0.0f;
//if (!ReadFloatParam("pseudoSpeed", true, AISPEED_SLOW, AISPEED_SPRINT, pParams, &pseudoSpeed)) return false;
if (!ReadPseudoSpeedParam("pseudoSpeed", true, pParams, &pseudoSpeed)) return false;
stance = STANCE_NULL;
if (!ReadStanceParam("stance", true, pParams, &stance)) return false;
targetStance = STANCE_NULL;
ReadStanceParam("targetStance", false, pParams, &targetStance);
int iContext = 0; // default = don't care
ReadIntParam("context", false, 0, INT_MAX, pParams, &iContext);
context = (unsigned)iContext;
minDistance = 0.0f;
if (!ReadFloatParam("minDist", true, 0.0f, FLT_MAX, pParams, &minDistance)) return false;
desiredTravelAngle = 0.0f;
if (!ReadAngleParam("travelAngle", true, -gf_PI2, gf_PI2, pParams, &desiredTravelAngle)) return false;
travelAngleTolerance = FLT_MAX;
if (!ReadAngleParam("travelAngleTolerance", true, 0.0f, gf_PI2, pParams, &travelAngleTolerance)) return false;
if (transitionType == eTT_Start)
{
maxDistance = FLT_MAX;
prepareDistance = FLT_MAX;
prepareTravelAngleTolerance = FLT_MAX;
desiredArrivalAngle = 0.0f;
arrivalAngleTolerance = FLT_MAX;
}
else
{
maxDistance = minDistance;
if (!ReadFloatParam("maxDist", true, minDistance, FLT_MAX, pParams, &maxDistance)) return false;
const float maxMovementPerFrame = 7.5f/30.0f; // 7.5m/s at 30fps gives you 25cm per frame
minDistance -= maxMovementPerFrame/2;
maxDistance = minDistance + maxMovementPerFrame;
prepareDistance = maxDistance;
if (!ReadFloatParam("prepareDist", true, maxDistance, FLT_MAX, pParams, &prepareDistance)) return false;
prepareTravelAngleTolerance = FLT_MAX;
if (!ReadAngleParam("prepareTravelAngleTolerance", true, 0.0f, gf_PI2, pParams, &prepareTravelAngleTolerance)) return false;
}
if (transitionType == eTT_Stop)
{
desiredArrivalAngle = 0.0f;
bool hasDesiredArrivalAngle = ReadAngleParam("arrivalAngle", false, -gf_PI2, gf_PI2, pParams, &desiredArrivalAngle);
arrivalAngleTolerance = FLT_MAX;
bool hasArrivalAngleTolerance = ReadAngleParam("arrivalAngleTolerance", false, 0.0f, gf_PI2, pParams, &arrivalAngleTolerance);
CRY_ASSERT_MESSAGE(!hasDesiredArrivalAngle || hasArrivalAngleTolerance, "Transition has arrivalAngle but no arrivalAngleTolerance");
CRY_ASSERT_MESSAGE( hasDesiredArrivalAngle || !hasArrivalAngleTolerance, "Transition has arrivalAngleTolerance but no arrivalAngle");
}
else
{
desiredTargetTravelAngle = 0.0f;
bool hasDesiredTargetTravelAngle = ReadAngleParam("targetTravelAngle", false, -gf_PI2, gf_PI2, pParams, &desiredTargetTravelAngle);
targetTravelAngleTolerance = FLT_MAX;
bool hasTargetTravelAngleTolerance = ReadAngleParam("targetTravelAngleTolerance", false, 0.0f, gf_PI2, pParams, &targetTravelAngleTolerance);
CRY_ASSERT_MESSAGE(!hasDesiredTargetTravelAngle || hasTargetTravelAngleTolerance, "Transition has targetTravelAngle but no targetTravelAngleTolerance");
CRY_ASSERT_MESSAGE( hasDesiredTargetTravelAngle || !hasTargetTravelAngleTolerance, "Transition has targetTravelAngleTolerance but no targetTravelAngle");
if (transitionType == eTT_DirectionChange)
{
desiredJukeAngle = 0.0f;
if (!ReadAngleParam("jukeAngle", true, -gf_PI2, gf_PI2, pParams, &desiredJukeAngle)) return false;
jukeAngleTolerance = FLT_MAX;
if (!ReadAngleParam("jukeAngleTolerance", true, 0.0f, gf_PI2, pParams, &jukeAngleTolerance)) return false;
}
else // if (transitionType == eTT_Start)
{
desiredJukeAngle = 0.0f;
jukeAngleTolerance = FLT_MAX;
}
}
return true;
}
