1

Is there a way to return the amount of decimal places a float currently has?

For example:

getPrecision(42.123f); // returns 3
getPrecision(42.123456f); // returns 6
getPrecision(42.01f); // returns 2
getPrecision(42.0f); // returns 0
Alex
  • 462
  • 1
  • 7
  • 19
AlexG
  • 5,649
  • 6
  • 26
  • 43
  • 3
    Basically, no. Why do you think you need it? – wilx Jun 24 '20 at 22:59
  • 4
    No, because [floating-point values are imprecise representations](https://stackoverflow.com/questions/588004/). When you write a value like `42.123456`, it could actually be stored more like `42.12345505` instead. And `42.01` could be more like `42.00999832`, etc. – Remy Lebeau Jun 24 '20 at 23:04
  • 3
    Its possible to get the number of significand places of base2 digits a float has though – Sebastian Hoffmann Jun 24 '20 at 23:06
  • @SebastianHoffmann That would actually be the solution I'm looking for. – AlexG Jun 24 '20 at 23:10
  • Also it should be noted that there is no requirement for how floating point numbers are represented, so even getting the number of significand places of base2 digits a float has is going to be implementation specific at best – shay Jun 24 '20 at 23:13
  • In common implementations, supporting IEEE 754, the part that contains the decimal places, the mantissa, is a fixed size. Thus a floating point will always have a fixed number of decimals. You can always round a number to a specific number of decimals; or output to a fixed number of decimal places. However, most platforms will have a fixed size of decimal places. The decimal point location will be based on the exponent field, also a fixed size. – Thomas Matthews Jun 25 '20 at 02:33

2 Answers2

7

Is there a way to return the amount of decimal places a float currently has?

getPrecision(42.123f); // returns 3

Your understanding of "the amount of decimal places a float currently has" is flawed. Floating point representations have finite precision and cannot represent all rational numbers. Most commonly, they are represented in a binary format and many decimal base numbers that appear simple to you are not representable.

Assuming the most common IEEE-754 binary 32 bit representation, 42.123 is not a representable number. When you write 42.123f, the compiler will use the closest representable number instead. In this case, that happens to be 42.1230010986328125 which is very close to 42.123 but isn't quite exact. You may notice that the number that you get does not have "3 decimal places". There is no way to write such function getPrecision that would output 3 for 42.123f, and the accurate result for all other potential values unless the floating point representation can precisely represent all of those values.

If getting the output 16 that matches the actually represented value is what you're looking for, then the answer is: Yes, such function could be written, but how would it be useful?

A representation where counting decimal places makes sense is text. You can count the number of charecters between '.' and 'f' given the string "42.123f".

eerorika
  • 232,697
  • 12
  • 197
  • 326
2

No, because that is often meaningless.

You see, floating-point numbers use base-2 fractions, not base-10. For example, the base-2 fraction 0.01 is 1/4, i.e. one-quarter of a unit.

There are base-10 values which are simply not representible by a (finite-sized) floating-point number - even with few base-10 digits. Take 0.2, or 1/5; what is its base-2 fractional representation? It's infinitely long. Just like 1/7 has an infinitely-long base-10 representation. Thus, the floating-point value you'll get when you write 0.2f has a value that's not equal to 0.2; and whatever "decimal places" value you obtain from it will not really regard 0.2.

Remy Lebeau
  • 555,201
  • 31
  • 458
  • 770
einpoklum
  • 118,144
  • 57
  • 340
  • 684