I have to count the number of digits after the decimal. I found a code but it's not working for some numbers. like for 2.12 its giving output as 7 instead of 2 but for 2.125 its giving output as 3 which is correct.
#include<stdio.h>
int main()
{
float no =2.34;
int count =0;
while(no!=((int)no))
{
count++;
no=no*10;
}
printf("\t %d \n",count);
return 0;
}
Tell me if it's anyhow possible to find out the number of digits after the decimal point in C.
#include <stdio.h>
#include <string.h>
int main()
{
float no = 2.3948;
int i = 0;
int startCounting = 0;
int count = 0;
char c[500];
sprintf(c, "%g", no);
for(i = 0;i<strlen(c);i++)
{
if (startCounting == 1)
{
count ++;
}
if(c[i] == '.')
{
startCounting = 1;
}
}
printf("\nTotal Count: %d", count);
}
Binary floating-point is designed to approximate real-number arithmetic. It is not designed to record information about decimal digits. If you want to work with decimal arithmetic, you should use a format other than the float or double types of your compiler.
For float, your C implementation most likely uses the IEEE-754 basic 32-bit binary format, also called binary32. The number 2.34 cannot be represented in this format. In float no =2.34;, the source text 2.34 is a double constant, and the decimal “2.34” is converted to the nearest value representable in a double, which is 2.339999999999999857891452847979962825775146484375, if your C implementation uses the IEEE-754 binary64 format and uses round-to-nearest-ties-to-even, both of which are common. This double value is then used to initialize no, which is a float, so it is converted to the nearest value representable in the float format, which is 2.3399999141693115234375.
If your code correctly counted the number of decimal digits after the decimal point required to represent this number, it would print 22. One reason it does not is because the operation no*10 produces more rounding errors. In binary, ten is 10102, and multiplying by it increases the number of bits needed to represent result without rounding error. Since float has a fixed number of bits, it is not possible to use more bits. So the real-number result is rounded to fit. Each time your program executes no=no*10, it loses some information about the number.
Consider that both float no = 2.34; and float no = 2.3399999141693115234375; yield exactly the same result in no. Therefore, no difference between them can be detected from that value. So no software could tell whether the numeral with two digits after the decimal point or the numeral with 22 digits after the decimal point had been used to initialize no.
Therefore, no software can tell you how many digits that original numeral had, if all it has to use is the value in no.
It is possible to figure out the shortest decimal numeral that would produce a particular float value. Java and JavaScript provide this in their default formatting for floating-point numbers. Then one could count the digits in that numeral. However, this is useful only for situations where a floating-point result is known to be equal to the result of converting some numeral with a limited number of decimal digits to binary floating-point. If the floating-point result comes from calculations, we cannot expect it to be near a short decimal numeral. For example, if no came from other calculations and were just a little higher or lower, the float value would be one of the neighboring values, 2.340000152587890625 or 2.339999675750732421875, near decimal numerals “2.3400002” and “2.3399997”. Generally, when working with binary floating-point arithmetic, we should not expect to get simple decimal results.
Is it possible to count the number of digits after decimal point in C?
Yes.
For integers it's easy (always zero). For fixed point numbers you can use a lookup table with either the fractional part as index (smaller code, larger table) or the "bit number" of the lowest set bit as the index (larger code, smaller table). This includes both "big integer" and primitive types.
For floating point types; you have to figure out what you actually want. Options are:
the number of actual digits in the raw value. In this case use the "bit number of lowest set bit in significand, adjusted by exponent, as index into table" approach (with safeguards for infinities and NaNs).
the number of useful digits. In this case you have to analyze the source code to determine "worst case error", or write code that keeps track of error at run-time to determine "actual case error", for all things leading up to the value you have. Then you can use a similar "lowest set bit of significand adjusted by exponent and error, as index into table" approach.
the number of digits that would be used for a specific format specifier (e.g. in printf()). In this case start by using sprintf() to convert it into a string. For %f and similar, and %a and similar, count "digit chars after the decimal point (if there is one)" in the resulting string. For %e and similar, count "digits between decimal point (if there is one) and first non-digit char after decimal point", then check for an exponent and parse it separately, then combine both results by using subtraction (e.g. 1.23e-9 would be 2-(-9) = 11) then clamp the result to a non-negative number (e.g. 1.23e+9 would be 2-(+9) = -7 = no digits).
For big rational numbers (e.g. constructed from three big integers, as "numerator/divisor << exponent"); you have to figure out what you actually want. Options are:
the number of actual digits in the raw value. This is "very complex" (e.g. for a number like 1/3 the answer can be infinity).
the number of useful digits. In this case you probably have to analyze the source code to determine "worst case error" and use that to adjust "number of actual digits in raw value". Note that operations on big rational numbers typically don't have any error at all; but there will be error from conversions from values used to create/initialize the big rational numbers.
the number of digits that would be used if the value was printed. This depends on the code that prints it, but you can probably use a similar approach (convert to string, then parse the string) as floating point.
WARNING: Don't be misled by people in the comments. There are 2 issues:
converting decimal into floating point; which is imprecise and can create "un-intuitive" results if you're not aware of it; but is not technically relevant for the question you asked.
converting floating point back into decimal (and counting digits after the decimal point); which is (can be) precise. This is the only thing your question is asking for; and the answer is that it's entirely possible (and not necessarily hard).
Note that your original code does work correctly for some floating point values (e.g. does work correctly for the value 2.12 if you forgive rounding error - Eric's answer is right about that); and you only thought it wasn't working because of the unrelated "converting decimal into floating point" problem. However; your original code will not work correctly for values that are too large to fit in an int. To handle all values a float can have (e.g. including FLT_MAX) you'd need an integer type with around 150 bits, which doesn't exist as a primitive type in C, so you'd need to use some kind of "big integer" code/library or the method I described.
To be more specific; every "combination of bits" that can be stored in a float is either an infinity, a NaN, a zero, a "normal" that has a number of digits after the decimal point that can be determined exactly, or is a "subnormal" that has a number of digits after the decimal point that can be determined exactly; with the limit being the smallest magnitude non-zero value (approximately 1.4013e-45 assuming IEEE-754) which has the most digits after the decimal point that any float can have.
