Is there a 128 or 256 bit double class in .net?

问题:

I have an application that I want to be able to use large numbers and very precise numbers. For this, I needed a precision interpretation and IntX only works for integers.

Is there a class in .net framework or even third party(preferably free) that would do this?

Is there another way to do this?

回答1:

Maybe the Decimal type would work for you?

回答2:

You can use the freely available, arbitrary precision, BigDecimal from java.math, which is part of the J# redistributable package from Microsoft and is a managed .NET library.

Place a reference to vjslib in your project and you can something like this:

using java.math;

public void main() 
{
    BigDecimal big = new BigDecimal("1234567890123456789011223344556677889900.0000009876543210000987654321");
    big.add(new BigDecimal(1.0));
    Debug.Print(big);
}

Will print the following to the debug console:

1234567890123456789011223344556677889901.0000009876543210000987654321

Note that, as already mentioned, .NET 2010 contains a BigInteger class which, as a matter of fact, was already available in earlier versions, but only as internal class (i.e., you'd need some reflection to get it to work).

回答3:

The F# library has some really big number types as well if you're okay with using that...

回答4:

If Decimal doesn't work for you, try implementing (or grabbing code from somewhere) Rational arithmetic using large integers. That will provide the precision you need.

回答5:

I've been searching for a solution for this for a long time, and today came across this library:

Quadruple Precision Double in C#

Signed 128-bit floating point data type library, with 64 effective bits of precision (vs. 53 for Doubles) and a 64 bit exponent (vs. 11 for Doubles). Quads have greater precision and far greater range than Doubles and are especially useful when dealing with very large or very small values, such as those in probabilistic models. As of version 2.0, all Quad arithmetic is checked (underflowing to 0, overflowing to +/- infinity), has special PositiveInfinity, NegativeInfinity, and NaN values, and follows the same rules as .Net Double arithmetic and comparison operators (e.g. 1/0 == PositiveInfinity, 0 * PositiveInfinity == NaN, NaN != NaN), making it a convenient drop-in replacement for Doubles in existing code.

回答6:

Use decimal for this if possible.

回答7:

Decimal is a 128-bit (16 byte) value type that is used for highly precise calculations. It is a floating point type that is represented internally as base 10 instead of base 2 (i.e. binary). If you need to be highly precise, you should use Decimal - but the drawback is that Decimal is about 20 times slower than using floats.

回答8:

Shameless plug: QPFloat emulates the IEEE standard to full precision.

回答9:

Decimal is 128 bits if that would work.