I&#39;ve read about the difference between double precision and single precision. However, in most cases, `float` and `double` seem to be interchangeable, i.e. using one or the other does not seem to affect the results. Is this really the case? When are floats and doubles interchangeable? What are the differences between them?

What is the difference between float and double?

Why do comparisons of NaN values behave differently from all other values?
That is, all comparisons with the operators ==, &lt;=, &gt;=, &lt;, &gt; where one or both values is NaN returns false, contrary to the behaviour of all other values.

I suppose this simplifies numerical computations in some way, but I couldn&#39;t find an explicitly stated reason, not even in the &lt;a href=&quot;http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF&quot;&gt;Lecture Notes on the Status of IEEE 754&lt;/a&gt; by Kahan which discusses other design decisions in detail.

This deviant behavior is causing trouble when doing simple data processing. For example, when sorting a list of records w.r.t. some real-valued field in a C program I need to write extra code to handle NaN as the maximal element, otherwise the sort algorithm could become confused.

**Edit:**
The answers so far all argue that it is meaningless to compare NaNs.

I agree, but that doesn&#39;t mean that the correct answer is false,
rather it would be a Not-a-Boolean (NaB), which fortunately doesn&#39;t exist.

So the choice of returning true or false for comparisons is in my view arbitrary,
and for general data processing it would be advantageous if it obeyed the usual laws
(reflexivity of ==, trichotomy of &lt;, ==, &gt;),
lest data structures which rely on these laws become confused.

So I&#39;m asking for some concrete advantage of breaking these laws, not just philosophical reasoning.

**Edit 2:**
I think I understand now why making NaN maximal would be a bad idea, it would mess up the computation of upper limits.

NaN != NaN might be desirable to avoid detecting convergence in a loop such as

    while (x != oldX) {
        oldX = x;
        x = better_approximation(x);
    }

which however should better be written by comparing the absolute difference with a small limit.
So IMHO this is a relatively weak argument for breaking reflexivity at NaN.


What is the rationale for all comparisons returning false for IEEE754 NaN values?

It is well-known that NaNs propagate in arithmetic, but I couldn&#39;t find any demonstrations, so I wrote a small test:

    #include &lt;limits&gt;
    #include &lt;cstdio&gt;

    int main(int argc, char* argv[]) {
        float qNaN = std::numeric_limits&lt;float&gt;::quiet_NaN();

        float neg = -qNaN;

        float sub1 = 6.0f - qNaN;
        float sub2 = qNaN - 6.0f;
        float sub3 = qNaN - qNaN;

        float add1 = 6.0f + qNaN;
        float add2 = qNaN + qNaN;

        float div1 = 6.0f / qNaN;
        float div2 = qNaN / 6.0f;
        float div3 = qNaN / qNaN;

        float mul1 = 6.0f * qNaN;
        float mul2 = qNaN * qNaN;

        printf(
            &quot;neg: %f\nsub: %f %f %f\nadd: %f %f\ndiv: %f %f %f\nmul: %f %f\n&quot;,
            neg, sub1,sub2,sub3, add1,add2, div1,div2,div3, mul1,mul2
        );

        return 0;
    }

The example ([running live here](http://ideone.com/FjphJj)) produces basically what I would expect (the negative is a little weird, but it kind of makes sense):

    neg: -nan
    sub: nan nan nan
    add: nan nan
    div: nan nan nan
    mul: nan nan

MSVC 2015 produces something similar. However, Intel C++ 15 produces:

    neg: -nan(ind)
    sub: nan nan 0.000000
    add: nan nan
    div: nan nan nan
    mul: nan nan

Specifically, `qNaN - qNaN == 0.0`.

This... can&#39;t be right, right? What do the relevant standards (ISO C, ISO C++, IEEE 754) say about this, and why is there a difference in behavior between the compilers?


Why does NaN - NaN == 0.0 with the Intel C++ Compiler?

What is the biggest &quot;no-floating&quot; integer that can be stored in an IEEE 754 double type without losing precision ?

biggest integer that can be stored in a double

The float data type is a single-precision 32-bit IEEE 754 floating point and the double data type is a double-precision 64-bit IEEE 754 floating point.

What does it mean? And when should I use float instead of double or vice-versa?


Float and double datatype in Java

For clarity, if I&#39;m using a language that implements IEE 754 floats and I declare:

    float f0 = 0.f;
    float f1 = 1.f;

...and then print them back out, I&#39;ll get 0.0000 and 1.0000 - exactly.

But IEEE 754 isn&#39;t capable of representing all the numbers along the real line. Close to zero, the &#39;gaps&#39; are small; as you get further away, the gaps get larger.

So, my question is: **for an IEEE 754 float, which is the first (closest to zero) integer which cannot be exactly represented?** I&#39;m only really concerned with 32-bit floats for now, although I&#39;ll be interested to hear the answer for 64-bit if someone gives it!

I thought this would be as simple as calculating 2&lt;sup&gt;bits_of_mantissa&lt;/sup&gt; and adding 1, where _bits\_of\_mantissa_ is how many bits the standard exposes. I did this for 32-bit floats on my machine (MSVC++, Win64), and it seemed fine, though.

Which is the first integer that an IEEE 754 float is incapable of representing exactly?

I know that most decimals don&#39;t have an exact floating point representation (https://stackoverflow.com/questions/588004).

But I don&#39;t see why `4*0.1` is printed nicely as `0.4`, but `3*0.1` isn&#39;t, when
both values actually have ugly decimal representations:

    &gt;&gt;&gt; 3*0.1
    0.30000000000000004
    &gt;&gt;&gt; 4*0.1
    0.4
    &gt;&gt;&gt; from decimal import Decimal
    &gt;&gt;&gt; Decimal(3*0.1)
    Decimal(&#39;0.3000000000000000444089209850062616169452667236328125&#39;)
    &gt;&gt;&gt; Decimal(4*0.1)
    Decimal(&#39;0.40000000000000002220446049250313080847263336181640625&#39;)

Why does the floating-point value of 4*0.1 look nice in Python 3 but 3*0.1 doesn&#39;t?

No, this is not another _&quot;Why is (1/3.0)*3 != 1&quot;_ question.

I&#39;ve been reading about floating-points a lot lately; specifically, how the **same calculation might give different results** on different architectures or optimization settings.

This is a problem for video games which store replays, or are [peer-to-peer networked][1] (as opposed to server-client), which rely on all clients generating exactly the same results every time they run the program - a small discrepancy in one floating-point calculation can lead to a drastically different game-state on different machines (or even [on the same machine!][2])

This happens even amongst processors that &quot;follow&quot; [IEEE-754][3], primarily because some processors (namely x86) use [double extended precision][4].  That is, they use 80-bit registers to do all the calculations, then truncate to 64- or 32-bits, leading to different rounding results than machines which use 64- or 32- bits for the calculations.

I&#39;ve seen several solutions to this problem online, but all for C++, not C#:

 * Disable double extended-precision mode (so that all `double` calculations use IEEE-754 64-bits) using [`_controlfp_s`][5] (Windows), `_FPU_SETCW` (Linux?), or [`fpsetprec`][6] (BSD).
 * Always run the same compiler with the same optimization settings, and require all users to have the same CPU architecture (no cross-platform play).  Because my &quot;compiler&quot; is actually the JIT, which **may optimize differently every time the program is run**, I don&#39;t think this is possible.
 * Use fixed-point arithmetic, and avoid `float` and `double` altogether. `decimal` would work for this purpose, but would be much slower, and none of the `System.Math` library functions support it.

---

So, **is this even a problem in C#?**  What if I only intend to support Windows (not Mono)?

If it is, **is there any way to force my program to run at normal double-precision?**

If not, **are there any libraries that would help** keep floating-point calculations consistent?
 


  [1]: https://gamedev.stackexchange.com/questions/15192/rts-game-protocol
  [2]: http://www.parashift.com/c%2B%2B-faq-lite/newbie.html#faq-29.18
  [3]: http://en.wikipedia.org/wiki/IEEE_754-2008
  [4]: http://en.wikipedia.org/wiki/Extended_precision
  [5]: http://msdn.microsoft.com/en-us/library/c9676k6h.aspx
  [6]: http://www.gsp.com/cgi-bin/man.cgi?section=3&amp;topic=fpsetprec

Is floating-point math consistent in C#? Can it be?

The relevant IEEE standard defines a numeric constant NaN (not a number) and prescribes that NaN should compare as not equal to itself. Why is that?

All the languages I&#39;m familiar with implement this rule. But it often causes significant problems, for example unexpected behavior when NaN is stored in a container, when NaN is in the data that is being sorted, etc. Not to mention, the vast majority of programmers expect any object to be equal to itself (before they learn about NaN), so surprising them adds to the bugs and confusion.

IEEE standards are well thought out, so I am sure there is a good reason why NaN comparing as equal to itself would be bad. I just can&#39;t figure out what it is.

Edit: please refer to https://stackoverflow.com/questions/1565164/what-is-the-rationale-for-all-comparisons-returning-false-for-ieee754-nan-values as the authoritative answer.

Why is NaN not equal to NaN?

I have read about floating-point and I understand that NaN could result from operations. But I can&#39;t understand what these are concepts exactly. What is the difference between them? 

Which one can be produced during C++ programming? As a programmer, could I write a program that causes an sNaN?

What is the difference between quiet NaN and signaling NaN?

Is it possible to get division by 0 (or infinity) in the following example? 

&lt;!-- language: java --&gt;

    public double calculation(double a, double b)
    {
         if (a == b)
         {
             return 0;
         }
         else
         {
             return 2 / (a - b);
         }
    }

In normal cases it will not, of course. But what if `a` and `b` are very close, can `(a-b)` result in being `0` due to precision of the calculation?

Note that this question is for Java, but I think it will apply to most programming languages.


Is it possible to get 0 by subtracting two unequal floating point numbers?

PHP is famous for its type-juggling. I must admit it puzzles me, and I&#39;m having a hard time to find out basic logical/fundamental things in comparisons.

For example: If `$a &gt; $b` is true and `$b &gt; $c` is true, must it mean that `$a &gt; $c` is *always* true too?

Following basic logic, I would say *yes* however I&#39;m that puzzled I do not really trust PHP in this. Maybe someone can provide an example where this is not the case?

Also I&#39;m wondering with the strict lesser-than and strict greater-than operators (as their meaning is described as strictly which I only knew in the past from the equality comparisons) if it makes any difference if left and right operands are swapped with strictly unequal values:

    # Precondition:
    if ($a === $b) {
        throw new Exception(
           &#39;Both are strictly equal - can not compare strictly for greater or smaller&#39;
        );
    }

    ($a &gt; $b) !== ($b &gt; $a)

For most of all type comparison combinations these [greater / lesser comparison operators](http://php.net/language.operators.comparison) are not documented, so reading the manual was not really helpful in this case.


Type-juggling and (strict) greater/lesser-than comparisons in PHP

The [isnormal() reference page][1] says:

&gt; Determines if the given floating point number arg is normal, i.e. is
&gt; neither zero, subnormal, infinite, nor NaN.

It&#39;s clear what a number being zero, infinite or NaN means. But it also says subnormal. When is a number subnormal?


  [1]: https://en.cppreference.com/w/cpp/numeric/math/isnormal


What is a subnormal floating point number?

```python
&gt;&gt;&gt; (float(&#39;inf&#39;)+0j)*1
(inf+nanj)
```
Why? This caused a nasty bug in my code.

Why isn&#39;t `1` the multiplicative identity, giving `(inf + 0j)`?

Why does (inf + 0j)*1 evaluate to inf + nanj?

I know a little bit about how floating-point numbers are represented, but not enough, I&#39;m afraid.

The general question is: 

&gt; For a given precision (for my purposes, the number of accurate decimal places in base 10), what range of numbers can be represented for 16-, 32- and 64-bit IEEE-754 systems?

Specifically, I&#39;m only interested in the range of 16-bit and 32-bit numbers accurate to +/-0.5 (the ones place) or +/- 0.0005 (the thousandths place).

What range of numbers can be represented in a 16-, 32- and 64-bit IEEE-754 systems?

See this code:

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    var jsonString = &#39;{&quot;id&quot;:714341252076979033,&quot;type&quot;:&quot;FUZZY&quot;}&#39;;
    var jsonParsed = JSON.parse(jsonString);
    console.log(jsonString, jsonParsed);

&lt;!-- end snippet --&gt;

When I see my console in Firefox 3.5, the value of `jsonParsed` is the number rounded:

    Object id=714341252076979100 type=FUZZY

Tried different values, the same outcome (number rounded).

I also don&#39;t get its rounding rules. 714341252076979136 is rounded to 714341252076979200, whereas 714341252076979135 is rounded to 714341252076979100.

Why is this happening?

Large numbers erroneously rounded in JavaScript

Running a quick experiment related to [Is double Multiplication Broken in .NET?][1] and reading a couple of articles on C# string formatting, I thought that this:

    {
        double i = 10 * 0.69;
        Console.WriteLine(i);
        Console.WriteLine(String.Format(&quot;  {0:F20}&quot;, i));
        Console.WriteLine(String.Format(&quot;+ {0:F20}&quot;, 6.9 - i));
        Console.WriteLine(String.Format(&quot;= {0:F20}&quot;, 6.9));
    }


Would be the C# equivalent of this C code:

    {
        double i = 10 * 0.69;
        
        printf ( &quot;%f\n&quot;, i );
        printf ( &quot;  %.20f\n&quot;, i );
        printf ( &quot;+ %.20f\n&quot;, 6.9 - i );
        printf ( &quot;= %.20f\n&quot;, 6.9 );
    }

However the C# produces the output:

    6.9
      6.90000000000000000000
    + 0.00000000000000088818
    = 6.90000000000000000000

*despite i showing up equal to the value 6.89999999999999946709 (rather than 6.9) in the debugger.*

compared with C which shows the precision requested by the format:

    6.900000                          
      6.89999999999999946709          
    + 0.00000000000000088818          
    = 6.90000000000000035527          

What&#39;s going on?

( Microsoft .NET Framework Version 3.51 SP1 / Visual Studio C# 2008 Express Edition )


----------

I have a background in numerical computing and experience implementing interval arithmetic - a technique for estimating errors due to the limits of precision in complicated numerical systems - on various platforms. To get the bounty, don&#39;t try and explain about the storage precision - in this case it&#39;s a difference of one ULP of a 64 bit double. 

To get the bounty, I want to know how (or whether) .Net can format a double to the requested precision as visible in the C code. 


  [1]: https://stackoverflow.com/questions/1420752/is-double-multiplication-broken-in-net

Formatting doubles for output in C#

My question is whether all integer values are guaranteed to have a perfect double representation. 

Consider the following code sample that prints &quot;Same&quot;:

    // Example program
    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    int main()
    {
      int a = 3;
      int b = 4;
      double d_a(a);
      double d_b(b);
      
      double int_sum = a + b;
      double d_sum = d_a + d_b;
      
      if (double(int_sum) == d_sum)
      {
          std::cout &lt;&lt; &quot;Same&quot; &lt;&lt; std::endl;
      }
    }

Is this guaranteed to be true for any architecture, any compiler, any values of `a` and `b`? Will any integer `i` converted to `double`, always be represented as `i.0000000000000` and not, for example, as `i.000000000001`?

I tried it for some other numbers and it always was true, but was unable to find anything about whether this is coincidence or by design.


Note: This is different from [this question][1] (aside from the language) since I am adding the two integers. 


  [1]: https://stackoverflow.com/questions/12629087/is-floatinteger-integer-guaranteed-to-be-equal-in-c

Are all integer values perfectly represented as doubles?

I was reading about floating-point NaN values in the Java Language Specification (I&#39;m boring). A 32-bit `float` has this bit format:

	seee eeee emmm mmmm mmmm mmmm mmmm mmmm

`s` is the sign bit, `e` are the exponent bits, and `m` are the mantissa bits. A NaN value is encoded as an exponent of all 1s, and the mantissa bits are not all 0 (which would be +/- infinity). This means that there are lots of different possible NaN values (having different `s` and `m` bit values).

On this, [JLS &#167;4.2.3](https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.2.3) says:

&gt;IEEE 754 allows multiple distinct NaN values for each of its single and double floating-point formats. While each hardware architecture returns a particular bit pattern for NaN when a new NaN is generated, a programmer can also create NaNs with different bit patterns to encode, for example, retrospective diagnostic information.

The text in the JLS seems to imply that the result of, for example, `0.0/0.0`, has a hardware-dependent bit pattern, and depending on whether that expression was computed as a compile time constant, the hardware it is dependent on might be the hardware the Java program was compiled on or the hardware the program was run on. This all seems *very* flaky if true.

I ran the following test:

	System.out.println(Integer.toHexString(Float.floatToRawIntBits(0.0f/0.0f)));
	System.out.println(Integer.toHexString(Float.floatToRawIntBits(Float.NaN)));
	System.out.println(Long.toHexString(Double.doubleToRawLongBits(0.0d/0.0d)));
	System.out.println(Long.toHexString(Double.doubleToRawLongBits(Double.NaN)));

The output on my machine is:

	7fc00000
	7fc00000
	7ff8000000000000
	7ff8000000000000

The output shows nothing out of the expected. The exponent bits are all 1. The upper bit of the mantissa is also 1, which for NaNs apparently indicates a &quot;quiet NaN&quot; as opposed to a &quot;signalling NaN&quot; (https://en.wikipedia.org/wiki/NaN#Floating_point). The sign bit and the rest of the mantissa bits are 0. The output also shows that there was no difference between the NaNs generated on my machine and the constant NaNs from the Float and Double classes.

My question is, **is that output guaranteed in Java, regardless of the CPU of the compiler or VM**, or is it all genuinely unpredictable? The JLS is mysterious about this.

If that output is guaranteed for `0.0/0.0`, are there any arithmetic ways of producing NaNs that do have other (possibly hardware-dependent?) bit patterns? (I know `intBitsToFloat`/`longBitsToDouble` can encode other NaNs, but I&#39;d like to know if other values can occur from normal arithmetic.)

-----

A followup point: I&#39;ve noticed that [Float.NaN](https://docs.oracle.com/javase/8/docs/api/java/lang/Float.html#NaN) and [Double.NaN](https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#NaN) specify their exact bit pattern, but in the source ([Float](http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/tip/src/share/classes/java/lang/Float.java), [Double](http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/tip/src/share/classes/java/lang/Double.java)) they are generated by `0.0/0.0`. If the result of that division is really dependent on the hardware of the compiler, it seems like there is a flaw there in either the spec or the implementation.

Are the bit patterns of NaNs really hardware-dependent?

I&#39;ve recently read up quite a bit on IEEE 754 and the x87 architecture.  I was thinking of using NaN as a &quot;missing value&quot; in some numeric calculation code I&#39;m working on, and I was hoping that using *signaling* NaN would allow me to catch a floating point exception in the cases where I don&#39;t want to proceed with &quot;missing values.&quot;  Conversely, I would use *quiet* NaN to allow the &quot;missing value&quot; to propagate through a computation.  However, signaling NaNs don&#39;t work as I thought they would based on the (very limited) documentation that exists on them.

Here is a summary of what I know (all of this using x87 and VC++):

 - _EM_INVALID (the IEEE &quot;invalid&quot; exception) controls the behavior of the x87 when encountering NaNs
 -  If _EM_INVALID is masked (the exception is disabled), no exception is generated and operations can return quiet NaN.  An operation involving signaling NaN will **not** cause an exception to be thrown, but will be converted to quiet NaN.
 -  If _EM_INVALID is unmasked (exception enabled), an invalid operation (e.g., sqrt(-1)) causes an invalid exception to be thrown.
 -  The x87 **never** generates signaling NaN.
 -  If _EM_INVALID is unmasked, **any** use of a signaling NaN (even initializing a variable with it) causes an invalid exception to be thrown.

The Standard Library provides a way to access the NaN values:

    std::numeric_limits&lt;double&gt;::signaling_NaN();

and

    std::numeric_limits&lt;double&gt;::quiet_NaN();

The problem is that I see no use whatsoever for the signaling NaN.  If _EM_INVALID is masked it behaves exactly the same as quiet NaN.  Since no NaN is comparable to any other NaN, there is no logical difference.

If _EM_INVALID is *not* masked (exception is enabled), then one cannot even initialize a variable with a signaling NaN:
`double dVal = std::numeric_limits&lt;double&gt;::signaling_NaN();` because this throws an exception (the signaling NaN value is loaded into an x87 register to store it to the memory address).

You may think the following as I did:

 1. Mask _EM_INVALID.
 2. Initialize the variable with signaling NaN.
 3. Unmask_EM_INVALID.

However, step 2 causes the signaling NaN to be converted to a quiet NaN, so subsequent uses of it will **not** cause exceptions to be thrown!  So WTF?!

Is there any utility or purpose whatsoever to a signaling NaN?  I understand one of the original intents was to initialize memory with it so that use of an unitialized floating point value could be caught.

Can someone tell me if I am missing something here?


----------
**EDIT:**

To further illustrate what I had hoped to do, here is an example:

Consider performing mathematical operations on a vector of data (doubles).  For some operations, I want to allow the vector to contain a &quot;missing value&quot; (pretend this corresponds to a spreadsheet column, for example, in which some of the cells do not have a value, but their existence is significant).  For some operations, I do *not* want to allow the vector to contain a &quot;missing value.&quot;  Perhaps I want to take a different course of action if a &quot;missing value&quot; is present in the set -- perhaps performing a different operation (thus this is not an invalid state to be in).

This original code would look something like this:

    const double MISSING_VALUE = 1.3579246e123;
    using std::vector;

    vector&lt;double&gt; missingAllowed(1000000, MISSING_VALUE);
    vector&lt;double&gt; missingNotAllowed(1000000, MISSING_VALUE);

    // ... populate missingAllowed and missingNotAllowed with (user) data...

    for (vector&lt;double&gt;::iterator it = missingAllowed.begin(); it != missingAllowed.end(); ++it) {
        if (*it != MISSING_VALUE) *it = sqrt(*it); // sqrt() could be any operation
    }

    for (vector&lt;double&gt;::iterator it = missingNotAllowed.begin(); it != missingNotAllowed.end(); ++it) {
        if (*it != MISSING_VALUE) *it = sqrt(*it);
        else *it = 0;
    }

Note that the check for the &quot;missing value&quot; must be performed **every loop iteration**.  While I understand in most cases, the `sqrt` function (or any other mathematical operation) will likely overshadow this check, there are cases where the operation is minimal (perhaps just an addition) and the check is costly.  Not to mention the fact that the &quot;missing value&quot; takes a legal input value out of play and could cause bugs if a calculation legitimately arrives at that value (unlikely though it may be).  Also to be technically correct, the user input data should be checked against that value and an appropriate course of action should be taken.  I find this solution inelegant and less-than-optimal performance-wise.  This is performance-critical code, and we definitely do not have the luxury of parallel data structures or data element objects of some sort.

The NaN version would look like this:

    using std::vector;

    vector&lt;double&gt; missingAllowed(1000000, std::numeric_limits&lt;double&gt;::quiet_NaN());
    vector&lt;double&gt; missingNotAllowed(1000000, std::numeric_limits&lt;double&gt;::signaling_NaN());

    // ... populate missingAllowed and missingNotAllowed with (user) data...

    for (vector&lt;double&gt;::iterator it = missingAllowed.begin(); it != missingAllowed.end(); ++it) {
        *it = sqrt(*it); // if *it == QNaN then sqrt(*it) == QNaN
    }

    for (vector&lt;double&gt;::iterator it = missingNotAllowed.begin(); it != missingNotAllowed.end(); ++it) {
        try {
            *it = sqrt(*it);
        } catch (FPInvalidException&amp;) { // assuming _seh_translator set up
            *it = 0;
        }
    }

Now the explicit check is eliminated and performance should be improved.  I think this would all work if I could initialize the vector without touching the FPU registers...

Furthermore, I would imagine any self-respecting `sqrt` implementation checks for NaN and returns NaN immediately.

Usefulness of signaling NaN?

It seems that the IEEE 754 standard defines 16,777,214 32-bit floating point values as NaNs, or 0.4% of all possible values.

I wonder what is the rationale for reserving so many useful values, while only 2 ones essentially needed: one for signaling and one for quiet NaN.

Sorry if this question is trivial, I couldn&#39;t find any explanation on the internet.

Why does IEEE 754 reserve so many NaN values?

What&#39;s the difference between [`Double.MIN_NORMAL`][1] (introduced in Java 1.6) and [`Double.MIN_VALUE`][2]?

  [1]: http://download.oracle.com/javase/6/docs/api/java/lang/Double.html#MIN_NORMAL
  [2]: http://download.oracle.com/javase/6/docs/api/java/lang/Double.html#MIN_VALUE

Difference between Java&#39;s `Double.MIN_NORMAL` and `Double.MIN_VALUE`?

I found a rather strange but working square root approximation for `float`s; I really don&#39;t get it. Can someone explain me why this code works?

    float sqrt(float f)
    {
        const int result = 0x1fbb4000 + (*(int*)&amp;f &gt;&gt; 1);
        return *(float*)&amp;result;   
    }

I&#39;ve test it a bit and [it outputs values off of `std::sqrt()` by about 1 to 3%](http://coliru.stacked-crooked.com/a/568f0bd0fcf2838f). I know of the Quake III&#39;s [fast inverse square root](https://en.wikipedia.org/wiki/Fast_inverse_square_root) and I guess it&#39;s something similar here (without the newton iteration) but I&#39;d really appreciate an explanation of _how it works_.

(nota: I&#39;ve tagged it both [tag:c] and [tag:c++] since it&#39;s both valid-ish (see comments) C and C++ code)

How does this float square root approximation work?

From what I have read, a value of data type double has an approximate precision of 15 decimal places.  However, when I use a number whose decimal representation repeats, such as 1.0/7.0, I find that the variable holds the value of 0.14285714285714285 - which is 17 places (via the debugger).

I would like to know why it is represented as 17 places internally, and why a precision of 15 is always written at ~15?

Double precision - decimal places

ECMAScript 6&#39;s `Number.MAX_SAFE_INTEGER` supposedly represents the maximum numerical value JavaScript can store before issues arise with floating point precision. However it&#39;s a requirement that the number 1 added to this value must also be representable as a `Number`.

&gt; ### `Number.MAX_SAFE_INTEGER`
&gt;
&gt; *NOTE The value of `Number.MAX_SAFE_INTEGER` is the largest integer `n` such that `n` and `n + 1` are both exactly representable as a `Number` value.*
&gt;
&gt; The value of `Number.MAX_SAFE_INTEGER` is `9007199254740991 (2^53−1)`.
&gt;
&gt; – [ECMAScript Language Specification][1]

The JavaScript consoles of Chrome, Firefox, Opera and IE11 can all safely perform calculations with the number 9,007,199,254,740,992. Some tests:

&lt;!-- language: lang-js --&gt;

    // Valid
    Math.pow(2, 53)                         // 9007199254740992
    9007199254740991 + 1                    // 9007199254740992
    9007199254740992 - 1                    // 9007199254740991
    9007199254740992 / 2                    // 4503599627370496
    4503599627370496 * 2                    // 9007199254740992
    parseInt(&#39;20000000000000&#39;, 16)          // 9007199254740992
    parseInt(&#39;80000000000&#39;, 32)             // 9007199254740992
    9007199254740992 - 9007199254740992     // 0
    9007199254740992 == 9007199254740991    // false
    9007199254740992 == 9007199254740992    // true

    // Erroneous
    9007199254740992 + 1                    // 9007199254740992
    9007199254740993 + &quot;&quot;                   // &quot;9007199254740992&quot;
    9007199254740992 == 9007199254740993    // true

Why is it a requirement that `n + 1` must also be representable as a `Number`? Why does failing this make the value *unsafe*?

  [1]: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer

All Ieee 754 Solutions on Gang of Coders

Total of 25 Ieee 754 Solutions