public static LongFloat operator *(LongFloat a, LongFloat b)
        {
            int len = a._digits.Count + b._digits.Count;

            int[] zeros = new int[len];
            Array.Clear(zeros, 0, len);

            LongFloat res = new LongFloat
            {
                _sign     = a._sign * b._sign,
                _exponent = a._exponent + b._exponent,
                _digits   = new List <int>(zeros)
            };

            int na = a._digits.Count >= ValueDigits ? ValueDigits / 2 : a._digits.Count;
            int nb = b._digits.Count >= ValueDigits ? ValueDigits / 2 : b._digits.Count;

            for (int i = 0; i < na; i++)
            {
                for (int j = 0; j < nb; j++)
                {
                    res._digits[i + j + 1] += a._digits[i] * b._digits[j];
                }
            }

            for (int i = len - 1; i > 0; i--)
            {
                res._digits[i - 1] += res._digits[i] / 10;
                res._digits[i]     %= 10;
            }

            if (ValueDigits > 0)
            {
                res.Truncate();
            }

            res.RemoveZeroes();

            return(res);
        }
        public static LongFloat operator -(LongFloat a, LongFloat b)
        {
            if (a._sign == 1 && b._sign == 1)
            {
                bool cmp = a > b;

                int exp1 = cmp ? a._exponent : b._exponent;
                int exp2 = cmp ? b._exponent : a._exponent;
                int exp  = Math.Max(exp1, exp2);

                List <int> d1 = ListDeepCopy(cmp ? a._digits : b._digits);
                List <int> d2 = ListDeepCopy(cmp ? b._digits : a._digits);

                while (exp1 != exp)
                {
                    d1.Insert(0, 0);
                    exp1++;
                }

                while (exp2 != exp)
                {
                    d2.Insert(0, 0);
                    exp2++;
                }

                int size = Math.Max(d1.Count, d2.Count);

                while (d1.Count != size)
                {
                    d1.Add(0);
                }

                while (d2.Count != size)
                {
                    d2.Add(0);
                }

                int len = 1 + size;

                int[] zeros = new int[len];
                Array.Clear(zeros, 0, len);

                LongFloat res = new LongFloat
                {
                    _sign   = cmp ? 1 : -1,
                    _digits = new List <int>(zeros)
                };

                for (int i = 0; i < size; i++)
                {
                    res._digits[i + 1] = d1[i] - d2[i];
                }

                for (int i = len - 1; i > 0; i--)
                {
                    if (res._digits[i] < 0)
                    {
                        res._digits[i] += 10;
                        res._digits[i - 1]--;
                    }
                }

                res._exponent = exp + 1;
                res.RemoveZeroes();

                return(res);
            }

            if (a._sign == -1 && b._sign == -1)
            {
                return((-b) - (-a));
            }

            return(a + (-b));
        }
        public static LongFloat operator +(LongFloat a, LongFloat b)
        {
            if (a._sign == b._sign)
            {
                int exp1 = a._exponent;
                int exp2 = b._exponent;
                int exp  = Math.Max(exp1, exp2);

                List <int> d1 = new List <int>(a._digits);
                List <int> d2 = new List <int>(b._digits);

                while (exp1 != exp)
                {
                    d1.Insert(0, 0);
                    exp1++;
                }

                while (exp2 != exp)
                {
                    d2.Insert(0, 0);
                    exp2++;
                }

                int size = Math.Max(d1.Count, d2.Count);

                while (d1.Count != size)
                {
                    d1.Add(0);
                }

                while (d2.Count != size)
                {
                    d2.Add(0);
                }

                int   len   = 1 + size;
                int[] zeros = new int[len];
                Array.Clear(zeros, 0, len);

                LongFloat res = new LongFloat
                {
                    _digits = new List <int>(zeros),
                    _sign   = a._sign
                };

                for (int i = 0; i < size; i++)
                {
                    res._digits[i + 1] = d1[i] + d2[i];
                }

                for (int i = len - 1; i > 0; i--)
                {
                    res._digits[i - 1] += res._digits[i] / 10;
                    res._digits[i]     %= 10;
                }

                res._exponent = exp + 1;
                res.RemoveZeroes();

                return(res);
            }

            if (a._sign == -1)
            {
                return(b - (-a));
            }

            return(a - (-b));
        }