toFixed returns a string, and you are comparing the two resulting strings. Lexically, the 1 in 12 comes before the 7 so 12 < 7. I guess you want to compare something like: (Math.round(parseFloat(acVal)*100)/100) which rounds to two decimals
Yes, you should use the f suffix. Reasons include: Performance. When you write float foo(float x) { return x*3.14; }, you force the compiler to emit code that converts x to double, then does the multiplication, then converts the result back to single. If you add the f suffix, then both conversions are eliminated. On … Read more
Just for the record: import Numeric formatFloatN floatNum numOfDecimals = showFFloat (Just numOfDecimals) floatNum “”
The only thing I’d add to Eric’s response is an explanation; I feel that knowledge of why code works is better than knowing what code works. The explanation is this: let’s say you want a number between 2.5 and 4.5. The range is 2.0 (4.5 – 2.5). NextDouble only returns a number between 0 and … Read more
First off, in most languages an undecorated constant like “1.55” is treated as a double precision value. However, 1.55 is not exactly representable as double precision value, because it doesn’t have a terminating representation in binary. This causes many curious behaviors, but one effect is that when you type 1.55, you don’t actually get the … Read more
You are doing this fine. The problem is with the inaccuracy of floating point numbers. Why are floating point numbers so inaccurate? If you wish to display this number then use: heights[i].toFixed(2); Note that toFixed() returns a string and you will have to convert back to a float (parseFloat()) if you want to perform more … Read more
I am going to assume IEEE 754 binary floating point arithmetic, with float 32 bit and double 64 bit. In general, there is no advantage to doing the calculation in double, and in some cases it may make things worse through doing two rounding steps. Conversion from float to double is exact. For the infinite, … Read more
C++ imposes very few restrictions on the behavior of float and other floating-point types. This can lead to possible inconsistencies in the results, both between compilers, and between runtime/compile-time evaluation by the same compiler. Here is the tl;dr on it: At runtime In constant expressions Floating-point errors, like division by zero UB, but compilers may … Read more