Incredibly huge and incredibly small numbers (not just integers) in C#

Question

In C#, I need to work with very large (and very small) numbers, for which decimal and double are not accurate enough and BigInteger is not able to store a number's fractions.

I'd like to have the numbers to have as long components i.e. the characteristic and the mantissa, as memory (and preferably hard drive) space will allow.

Does someone have a class or is there a system type for a really big number.

I need to be able to add, subtract, divide, modulus, square, square-root, sin, cos, tan (and their inversions) and multiply the number. Pretty much the complete functionality of a standard Decimal/Double (in case I've missed any).

Infinity needn't be represented, but it would be a plus*!

An example of a very small number is:

0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

and examples of very large numbers are:

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

and

-1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

I'd prefer ToString() to return the number in the form described above. Scientific notation is acceptable, but by no means preferred.

Four most important requirements are:

1. the accuracy of the number
2. At least, basic maths operations can be applied; multiply, division, addition and subtraction
3. The number must only be limited by the size of spare memory and harddrive.
4. Number must output as a string equivalent in the form Characteristic, decimal point and then mantissa e.g. 100.23, 100 or 0.000000054
5. There should be support for reccurance in the mantissa

BigInteger is not an acceptable answer.

*If infinity is implimented, then I need only implement it as far as possible e.g. (infinity / infinity = 1), (0 / infinity = 0), etc.

Answer 1

Use BigInteger. It represents an arbitrarily large signed integer.

Answer 2

It doesn't fulfill the spec, but I would use BigInteger for integers and decimal for decimals.

BigInteger (in theory) has no upper or lower bounds.

Decimal is precise up to 28 significant figures

Answer 3

You may want to take a look at the BigRational class, which may be found on CodePlex.

It represents numbers as a ratio of two BigIntegers.

The ToString method doesn't meet your requirement as it formats the number as a ratio (numerator/denominator). But, since the source code is there, you can go wild implementing IFormattable.

Answer 4

You're asking for 2 things here that aren't currently possible in the same domain without losing some precision in your numbers. One thing is the infinity. And the other thing deals with the numerics. For example, unless you draw a line somewhere or you include some kind of pattern matching that tends towards a cutoff at a certain number, you cannot implement an "infinity".

But since you're going with really large numbers, and extremely precise small numbers, and since there is no known numeric data type that can support both, I recommend implementing your own. Just replicate the functionality of the numeric structures you already have and combine them to your needs.

My general idea is creating your own numeric data type that uses something like BigInteger for the integers and something like Decimals for the extremely precise numbers. Or you should also take a look at BigRational as they have some functionality for basic adding, subtracting, etc and they also have Numerator and Denominator properties.

The reason I'm going with Decimals over something else like Doubles is that Decimal types are fixed point and Doubles are floating point. Floating points are the reason why 0.1 + 0.2 = 0.30000000000000004, for example. But only consider this if you're completely implementing your own system.

tl;dr: Create your own class combining BigInteger and BigRational.

Answer 5

For my learning purposes I created class that can manage large number of digits, use it if you want. This class has some issues and I don't guarantee that it works 100% (but i test it for many scenarios and for all it was ok). Also division operator has performance issues (try to decrease divPrecision for more speed) and I don't have time right now to learn about division algorithms. I am certain there is more sophisticated (and probably much better) way to make such class but it is what I built in couple of hours based on your idea.

using System;
using System.Linq;
using System.Numerics;

namespace RealNumber
{
    class RealNum
    {
        private BigInteger m = 0;
        private int w = 0;

        private static int divPrecision = 100000;
        private static char[] trimStartChar = { '0', '-' };
        private static char[] trimEndChars = { '.', ',' };

        public RealNum()
        {

        }

        public RealNum(BigInteger _m, int _w = 0 )
        {
            w = _w;
            m = _m;

            miniW();
        }

        public RealNum(string number)
        {
            number = number.Trim();

            System.Text.RegularExpressions.Regex textValidator = new System.Text.RegularExpressions.Regex(@"^-?[0-9]+([,.][0-9]+)?$");

            if (!textValidator.IsMatch(number))
            {
                throw new FormatException();
            }

            bool minSig = number.Contains('-');

            number = number.TrimStart(trimStartChar);
            if (number.Contains('.') || number.Contains(','))
            {
                number = number.TrimEnd(trimStartChar);
                number = number.TrimEnd(trimEndChars);
            }

            if (string.IsNullOrEmpty(number))
            {
                return;
            }

            char[] splitChars = { '.', ',' };

            string[] idnum = number.Split(splitChars, StringSplitOptions.None);
            if (string.IsNullOrEmpty(idnum[0]))
                idnum[0] = "0";

            if(idnum.Length==1)
            {
                m = BigInteger.Parse(idnum[0]);
            }
            else
            {
                w = idnum[1].Length;
                m = BigInteger.Parse(idnum[0]) * BigInteger.Pow(10, idnum[1].Length) + BigInteger.Parse(idnum[1]);
            }

            if (minSig)
                m = -m;

            miniW();

        }

        private void miniW()
        {
            while( m % (new BigInteger(10)) == 0 && m > 0 )
            {
                m = m / 10;
                w--;
            }
        }


        public override string ToString()
        {
            string num = m.ToString();

            if (w > 0)
            {

                if(num.Length - w <= 0)
                {
                    string zeros = new string('0', -num.Length + w + 1);
                    num = zeros + num;
                }

                num = num.Insert(num.Length - w, ".");
            }
            else if(w < 0)
            {
                string zeros = new string('0', -w);
                num = num + zeros;
            }

            return num;
        }


        public static RealNum operator+ (RealNum a, RealNum b)
        {

            int wSub = a.w - b.w;

            if(wSub<0)
            {
                wSub = -wSub;
                a = System.Threading.Interlocked.Exchange(ref b, a);
            }

            return new RealNum(a.m + b.m * BigInteger.Pow(10, wSub), a.w);

        }

        public static RealNum operator -(RealNum a, RealNum b)
        {
            int wSub = a.w - b.w;

            if (wSub < 0)
            {
                wSub = -wSub;
                a = System.Threading.Interlocked.Exchange(ref b, a);
                return new RealNum(b.m * BigInteger.Pow(10, wSub) - a.m, a.w);
            }

            return new RealNum(a.m - b.m * BigInteger.Pow(10, wSub), a.w);

        }

        public static RealNum operator *(RealNum a, RealNum b) => 
            new RealNum(a.m * b.m, a.w+b.w);

        public static RealNum operator /(RealNum a, RealNum b)
        {

            int precision = RealNum.divPrecision;
            if (precision <= b.w)
                precision = b.w+10;
            int aSubSup = 0;
            int aSub;
            if (a.w < 0)
            {
                aSubSup = -a.w;
                aSub = precision;
            }
            else
            {
                aSub = precision - a.w;
            }

            BigInteger am = a.m * BigInteger.Pow(10, aSubSup) * BigInteger.Pow(10, aSub);

            return new RealNum(am/b.m, precision-b.w);

        }

    }
}