Owen wrote:
> Hi all,
> Wondering if someone can help me with this:
>
> when i'm in Visual Studio 2005 I get a wierd addition error when
> adding
> 0.1+0.2 (both as doubles)
>
> the result that comes back is 0.30000000000000004 not 0.3 as
> expected. Any ideas what's causing this or what's wrong?

"Owen" <Owen@discussions.microsoft.com> wrote in message
news:433D0159-BBA9-4B70-9390-41B955D0D875@microsoft.com...
> Hi all,
> Wondering if someone can help me with this:
>
> when i'm in Visual Studio 2005 I get a wierd addition error when adding
> 0.1+0.2 (both as doubles)
>
> the result that comes back is 0.30000000000000004 not 0.3 as expected.
> Any
> ideas what's causing this or what's wrong?
>
> A few results:
> 0.1+0.2 0.30000000000000004 double
> 0.1+0.2+0.1+0.2 0.60000000000000009 double
> 0.1+0.3 0.4 double
> 0.2+0.3 0.5 double
>
>
>

Owen wrote:
> Ok that explains why it's happening. but why is it different for 2003 and
> 2005? the unit tests used to pass in 2003, but now fail.

Cowboy - MVP (Gregory A. Beamer) wrote:
> Somewhere in your code, you are using floats, not doubles.

>
> Try the following in a console app (C#):
>
> static void Main(string[] args)
> {
> double a = 0.1;
> double b = 0.2;
> double c = a + b;
> double d = 0.1 + 0.2;
> float e = 0.1f;
> float f = 0.2f;
> double g = e + f;
>
>
> Console.WriteLine("a={0}", a);
> Console.WriteLine("b={0}", b);
> Console.WriteLine("c={0}", c);

> Console.WriteLine("d={0}", d);

> Console.WriteLine("e={0}", e);
> Console.WriteLine("f={0}", f);
> Console.WriteLine("g={0}", g);

> Console.Read();
> }

Owen <Owen@discussions.microsoft.com> wrote:
> Ok that explains why it's happening. but why is it different for 2003 and
> 2005? the unit tests used to pass in 2003, but now fail. And it's only for
> these numbers ie if i change it to (double)0.1+(double)0.3 i get 0.4 and this
> passes an nunit.Assert.AreEqual test.

Owen wrote:
> Ok that explains why it's happening. but why is it different for 2003
> and 2005? the unit tests used to pass in 2003, but now fail. And it's
> only for these numbers ie if i change it to (double)0.1+(double)0.3 i
> get 0.4 and this passes an nunit.Assert.AreEqual test.

Michael D. Ober wrote:
> Has anyone actually tested Decimal vs. Double. The reason I ask is
> that both data types are implemented in the x87 FPU hardware (built
> into the 80486 and later) and have about the same clock cycle
> requirements.

wrote in message news:%23mbsIJVqGHA.3484@TK2MSFTNGP04.phx.gbl...
> Michael D. Ober wrote:
> > Has anyone actually tested Decimal vs. Double. The reason I ask is
> > that both data types are implemented in the x87 FPU hardware (built
> > into the 80486 and later) and have about the same clock cycle
> > requirements.
>
> The decimal type is not implemented by the x87 FPU 0 or at least not
> directly.
>
> The .NET System.Decimal type is a wrapper around the OLE VAR_DECIMAL type
> and is implemented by ole32.dll (IIRC). Whether the decimal support
library
> makes use of the x87 decimal type I do not know. If it does, it'd have to
> be doing format conversion, because the x87 decimal stores the mantissa as
> BCD (decimal digit per nibble), while the .NET decimal type stores the
> mantissa as a 96-bit unsigned binary integer. My guess would be that it
> doesn't make use of the x87 decimal type at all.
>
> -cd
>
>
>

wrote in message news:eWlNR30pGHA.4760@TK2MSFTNGP05.phx.gbl...
> Owen wrote:
> > Hi all,
> > Wondering if someone can help me with this:
> >
> > when i'm in Visual Studio 2005 I get a wierd addition error when
> > adding
> > 0.1+0.2 (both as doubles)
> >
> > the result that comes back is 0.30000000000000004 not 0.3 as
> > expected. Any ideas what's causing this or what's wrong?
>
> Your expectations are wrong.
>
> The numbers 0.1 and 0.2 do not have exact representations in binary
floating
> point - which is what .NET uses for floats and doubles. Consequently,
when
> you add a number very close to 0.1 to a number very close to 0.2, the best
> you can hope for is a number very close to 0.3. Four double, which you're
> apparently using here, you can expect about 17 digits of accuracy.
>
> When comparing floating point numbers for "equality", you should always
> compare for equality wiithin some small range, e.g. instead of x == y, use
> Math.Abs(x-y) < 0.0000000001.
>
> When displaying floating point numbers, you should always specify how many
> digits after the decimal point, according to your needs.
>
> If you need to be able to add 0.1 to 0.2 and get exactly 0.3 (e.g. you're
> doing financial calculations), then you should use the System.Decimal type
> instead. It is a decimal floating point number and can represent negative
> powers of 10 (e.g. 0.1) exactly. Be aware though - decimal is orders of
> magnitude slower than double, so unless you really need absolute decimal
> accuracy, you're probably better off using double.
>
> You should also take a look at the paper at the following url. It goes
into
> the details of working with binary floating point numbers in great detail.
>
> http://docs.sun.com/source/806-3568/ncg_goldberg.html
>
> -cd
>
>