//////////
//
// Function: INT()
// Takes a value and returns the INT(n) of that value.
//
//////
// Version 0.58
// Last update:
// Apr.02.2015
//////
// Change log:
// Apr.02.2015 - Refactoring
// Jul.13.2014 - Initial creation
//////
// Parameters:
// p1 -- Numeric or floating point
//
//////
// Returns:
// INT(n) of the value in p1
//////
void function_int(SReturnsParams* rpar)
{
SVariable* varNumber = rpar->ip[0];
f64 fValue;
u32 errorNum;
bool error;
SVariable* result;
//////////
// Parameter 1 must be numeric
//////
rpar->rp[0] = NULL;
if (!iVariable_isValid(varNumber) || !iVariable_isTypeNumeric(varNumber))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber), false);
return;
}
//////////
// Based on its type, process it accordingly
//////
if (iVariable_isTypeFloatingPoint(varNumber))
{
fValue = iiVariable_getAs_f64(varNumber, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber), false);
return;
}
// Convert to S64
result = iVariable_create(_VAR_TYPE_S64, NULL, true);
if (result)
*(s64*)result->value.data_s8 = (s64)fValue;
} else {
// Copy whatever it already is
result = iVariable_copy(varNumber, false);
}
//////////
// Are we good?
//////
if (!result)
{
iError_report(cgcInternalError, false);
return;
}
//////////
// Return our converted result
//////
rpar->rp[0] = result;
}
// Common numeric functions used for EXP(), LOG(), LOG10(), PI(), SQRT(), CEILING(), FLOOR(), DTOR(), RTOD(), ...
void ifunction_numbers_common(SReturnsParams* rpar, SVariable* varNumber1, SVariable* varNumber2, SVariable* varNumber3, u32 tnFunctionType, const u32 tnResultType, bool tlSameInputType, bool tlNoEmptyParam)
{
f64 lfResult, lfValue1, lfValue2, lfValue3;
u32 errorNum;
bool error;
SVariable* result;
//////////
// If varNumber1 is provided, must also be numeric
//////
rpar->rp[0] = NULL;
if (varNumber1)
{
//////////
// Must be numeric
//////
if (!iVariable_isValid(varNumber1) || !iVariable_isTypeNumeric(varNumber1))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Convert to f64
//////
lfValue1 = iiVariable_getAs_f64(varNumber1, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Check empty param
//////
if (tlNoEmptyParam && lfValue1 == 0.0)
{
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO, iVariable_get_relatedComp(varNumber1), false);
return;
}
} else {
lfValue1 = 0.0;
}
//////////
// If varNumber2 is provided, must also be numeric
//////
if (varNumber2)
{
//////////
// Must be numeric
//////
if (!iVariable_isValid(varNumber2) || !iVariable_isTypeNumeric(varNumber2))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber2), false);
return;
}
//////////
// Convert to f64
//////
lfValue2 = iiVariable_getAs_f64(varNumber2, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber2), false);
return;
}
//////////
// Check empty param
//////
if (tlNoEmptyParam && lfValue2 == 0.0)
{
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO, iVariable_get_relatedComp(varNumber2), false);
return;
}
} else {
lfValue2 = 0.0;
}
//////////
// If varNumber3 is provided, must also be numeric
//////
if (varNumber3)
{
//////////
// Must be numeric
//////
if (!iVariable_isValid(varNumber3) || !iVariable_isTypeNumeric(varNumber3))
{
iError_report_byNumber(_ERROR_PARAMETER_IS_INCORRECT, iVariable_get_relatedComp(varNumber3), false);
return;
}
//////////
// Convert to f64
//////
lfValue3 = iiVariable_getAs_f64(varNumber3, false, &error, &errorNum);
if (error)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber3), false);
return;
}
//////////
// Check empty param
//////
if (tlNoEmptyParam && lfValue3 == 0.0)
{
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO, iVariable_get_relatedComp(varNumber3), false);
return;
}
} else {
lfValue3 = 0.0;
}
//////////
// Compute numeric function
//////
switch (tnFunctionType)
{
// SQRT()
case _FP_COMMON_SQRT:
//////////
// Verify p1 >= 0
//////
if (lfValue1 < 0.0)
{
// Oops!
iError_report_byNumber(_ERROR_CANNOT_BE_NEGATIVE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute sqrt
//////
lfResult = sqrt(lfValue1);
break;
// EXP()
case _FP_COMMON_EXP:
lfResult = exp(lfValue1);
break;
// PI()
case _FP_COMMON_PI:
lfResult = _MATH_PI;
break;
// LOG()
// LOG10()
case _FP_COMMON_LOG:
case _FP_COMMON_LOG10:
//////////
// Verify p1 > 0
//////
if (lfValue1 <= 0.0)
{
// Oops!
iError_report_byNumber(_ERROR_CANNOT_BE_ZERO_OR_NEGATIVE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute
//////
if (tnFunctionType == _FP_COMMON_LOG) lfResult = log(lfValue1);
else lfResult = log10(lfValue1);
break;
// CEILING()
case _FP_COMMON_CEILING:
lfResult = ceil(lfValue1);
break;
// FLOOR()
case _FP_COMMON_FLOOR:
lfResult = floor(lfValue1);
break;
// DTOR()
case _FP_COMMON_DTOR:
lfResult = lfValue1 * _MATH_PI180;
break;
// RTOD()
case _FP_COMMON_RTOD:
lfResult = lfValue1 * _MATH_180PI;
break;
// COS()
case _FP_COMMON_COS:
lfResult = cos(lfValue1);
break;
// SIN()
case _FP_COMMON_SIN:
lfResult = sin(lfValue1);
break;
// ABS()
case _FP_COMMON_ABS:
lfResult = abs(lfValue1);
break;
// ACOS()
// ASIN()
case _FP_COMMON_ACOS:
case _FP_COMMON_ASIN:
//////////
// Verify p1 > 0
//////
if (lfValue1 < -1 || lfValue1 > 1)
{
// Oops!
iError_report_byNumber(_ERROR_OUT_OF_RANGE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute
//////
if (tnFunctionType == _FP_COMMON_ACOS) lfResult = acos(lfValue1);
else lfResult = asin(lfValue1);
break;
// ATAN()
case _FP_COMMON_ATAN:
//////////
// Verify p1 > 0
//////
if (lfValue1 < -_MATH_PI2 || lfValue1 > _MATH_PI2)
{
// Oops!
iError_report_byNumber(_ERROR_OUT_OF_RANGE, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Compute
//////
lfResult = atan(lfValue1);
break;
// ATN2()
case _FP_COMMON_ATN2:
lfResult = atan2(lfValue1, lfValue2);
break;
// TAN()
case _FP_COMMON_TAN:
lfResult = tan(lfValue1);
break;
// MOD()
case _FP_COMMON_MOD:
//////////
// Verify divisor not 0
//////
if (lfValue2 == 0.0)
{
// Oops!
iError_report_byNumber(_ERROR_DIVISION_BY_ZERO, iVariable_get_relatedComp(varNumber2), false);
return;
}
//////////
// Compute
//////
lfResult = fmod(lfValue1, abs(lfValue2));
if (lfValue2 < 0 && lfResult != 0.0) // Mar.14.2015
lfResult += lfValue2;
break;
// FV()
case _FP_COMMON_FV:
//////////
// Future value
//////
lfResult = (pow((1 + lfValue2), lfValue3) - 1) / lfValue2 * lfValue1;
break;
// PV()
case _FP_COMMON_PV:
//////////
// Present value
//////
lfResult = lfValue1 * ((1 - pow((1 + lfValue2), -lfValue3)) / lfValue2);
break;
// PAYMENT()
case _FP_COMMON_PAYMENT:
//////////
// Payment
//////
lfValue1 = (lfValue1 * pow(lfValue2 + 1, lfValue3) * lfValue2) / (pow(lfValue2 + 1, lfValue3) - 1);
break;
default:
// Programmer error... this is an internal function and we should never get here
iError_report_byNumber(_ERROR_INTERNAL_ERROR, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Create output variable
//////
if (tlSameInputType) result = iVariable_create(varNumber1->varType, NULL, true);
else result = iVariable_create(tnResultType, NULL, true);
if (!result)
{
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber1), false);
return;
}
//////////
// Set the value
//////
if (!iVariable_setNumeric_toNumericType(result, NULL, &lfResult, NULL, NULL, NULL, NULL))
iError_report_byNumber(errorNum, iVariable_get_relatedComp(varNumber1), false);
//////////
// return(result)
//////
rpar->rp[0] = result;
}
