In the C code, if the input value is very large and include fraction expression,
for example 3.141592 or 6350.29318. And want to display those values exactly.
How can you deal those values?
Now, I'm thinking, I use value shift and divide integer part and decimal part.
3.141592 = 3 + 0.141592
6350.29318 = 6350 + 0.29318
In the C language
First, multiply big or large number
6350.29318 * E14 = 635029318000000000
and divide that value 6350 & 29318
and check the decimal point, i.e., 5
Second, use the sprintf(...) function
such as "sprintf(SzTestResult, "%d.%0*d", lInteger, nDecimalPoint, lDecimal);"
And my question is, if there is or are the C language exporter(s), how he or they deal(s) this issue?
#include
#define SHIFT_SIZE_MAX (14)
#define NUMBER_SHIFT(X) ((X)*pow(10, (SHIFT_SIZE_MAX)))
// ------------------------------------------------------------------------------
// NumberFraction
// Input
// dInputNumber: Real Number, ABC.DEF
// *plNaturalNumber: Value of Natural Numner, ABC
// *plDecimalNumber: Value of Decimal Number, DEF
// *pnDecimalPoint: Value of Decimal Point, 3
// Return
// Success: 0
// Fail: NOT 0
// ------------------------------------------------------------------------------
int NumberFraction(
double dInputNumber,
unsigned long *plNaturalNumber,
unsigned long *plDecimalNumber,
int *pnDecimalPoint)
{
int nReturnType = 0;
// Input Value
//double dInputNumber = 6350.29318;
// Return Value
unsigned long lNaturalNumber = 0;
unsigned long lDecimalNumber = 0;
double dDecimalNumberT = 0;
//int nDecimalPoint = 0;
double dShiftedValue = dInputNumber * pow(10, SHIFT_SIZE_MAX);
// Count Deciaml Number
int nCount = 0;
int nDecimalNumber = 0;
double dInputValue = dShiftedValue;
// Check Input Value
if (plNaturalNumber == NULL)
{
return nReturnType = 2;
}
if (plNaturalNumber == NULL)
{
return nReturnType = 3;
}
if (pnDecimalPoint == NULL)
{
return nReturnType = 4;
}
for(nCount=0; nCount
{
double dVal = 0;
double dFraction = 0;
dInputValue = dInputValue / 10.;
dFraction = modf(dInputValue, &dVal);
if (dFraction == 0.0)
{
continue;
}
else
{
break;
}
}
nDecimalNumber = SHIFT_SIZE_MAX - nCount;
lNaturalNumber = (unsigned long)(dShiftedValue / pow(10, SHIFT_SIZE_MAX));
dDecimalNumberT = dShiftedValue - (lNaturalNumber * pow(10, SHIFT_SIZE_MAX));
lDecimalNumber = (unsigned long)(dDecimalNumberT / pow(10, nCount));
// Set Return Value
*plNaturalNumber = lNaturalNumber;
*plDecimalNumber = lDecimalNumber;
*pnDecimalPoint = nDecimalNumber;
return nReturnType;
}
// ------------------------------------------------------------------------------
// NumberFraction2String
// Input
// dInputNumber: Real Number, ABC.DEF
// pOutputString: "ABC.DEF"
// nOutputStringSize: SHOULD 32 bytes or more
// Return
// Success: 0
// Fail: NOT 0
// ------------------------------------------------------------------------------
int NumberFraction2String(
double dInputNumber,
char* pOutputString,
int nOutputStringSize)
{
int nReturnType = 0;
char SzTestResult[32] = {0x00, };
char SzZeroString[16] = {0x00, };
char SzDecimalNumber[16] = {0x00, };
int nMaxZeroNumber = 0;
int i = 0;
unsigned long lInteger = 0;
unsigned long lDecimal = 0;
int nDecimalPoint = 0;
// Check Input Value
if (pOutputString == NULL)
{
nReturnType = 2;
}
// memset
memset(pOutputString, 0x00, nOutputStringSize*sizeof(char));
// Convert: InputNumber Fraction, NatualNumber + DecimalNumber
nReturnType = NumberFraction(dInputNumber, &lInteger, &lDecimal, &nDecimalPoint);
if (nReturnType == 0)
{
int nStringSize = 0;
#if 0 // OLD Method
sprintf(SzDecimalNumber, "%d", lDecimal);
nMaxZeroNumber = nDecimalPoint - strlen(SzDecimalNumber);
for (i=0; i
{
SzZeroString[i] = '0';
}
sprintf(SzTestResult, "%d.%s%d", lInteger, SzZeroString, lDecimal);
#else // NEW Method
sprintf(SzTestResult, "%d.%0*d", lInteger, nDecimalPoint, lDecimal);
#endif //
nStringSize = strlen(SzTestResult);
if (nOutputStringSize+1 >= nStringSize)
{
memcpy(pOutputString, SzTestResult, nStringSize*sizeof(char));
}
}
else
{
// error
nReturnType = nReturnType + 10;
}
return nReturnType;
}
// Test Code
//double dTest = 3280.8399;
//double dTest = 0.0000000009842;
double dTest = 1.01660469088;
char SzOutputBuffer[32] = {0x00, };
int nOutputBufferSize = 32;
NumberFraction2String(dTest, SzOutputBuffer, nOutputBufferSize);
Posts
