C#超大数字运算

已于 2024-07-10 16:44:02 修改
阅读量3.8k 收藏 12
点赞数 1
分类专栏： Unity随记 文章标签： 超大数字 运算
于 2019-06-20 15:10:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwsx789/article/details/93041174
版权
本文介绍如何处理C#中超过long类型的超大数字运算。提供了两个类，分别用于整数和浮点数的大数运算，适用于需要进行大数运算的场景，如：111111111111111111111111111111111111*122222123123122222222221222221。这两个类经过修改，适配了.NET 3.5，方便在Unity中使用。
摘要由CSDN通过智能技术生成

这里记两个计算大数字运算的类（这是两个类是反编译，是之前用了.net4.0的一些特性，用.net3.5导入unity报错，就反编译改了下，贴在这里以后能用着也好找）。实际使用不推荐，推荐使用System.Numerics命名空间下的。
说说使用，当我们要运算的数值超过了double,long的时候，或者计算是string的数字的时候，例如：111111111111111111111111111111111111*122222123123122222222221222221
这么一个等式。

第一个类整数型

using System;

namespace Sqrt
{
  internal class ComputeStringInt
  {
    public string Body = "0";

    public static readonly ComputeStringInt Zero  = new ComputeStringInt("0");

    public int Length
    {
      get
      {
        if ((int) this.Body[0] == 43 || (int) this.Body[0] == 45)
          return this.Body.Length - 1;
        return this.Body.Length;
      }
    }

    public int this[int index]
    {
      get
      {
        if ((int) this.Body[0] == 43 || (int) this.Body[0] == 45)
          return (int) this.Body[index + 1] - 48;
        return (int) this.Body[index] - 48;
      }
    }

    public bool IsPositive
    {
      get
      {
        return (int) this.Body[0] != 45 || !(new ComputeStringInt(this.Body.Substring(1)) != (ComputeStringInt) 0L);
      }
    }

    public ComputeStringInt()
    {
    }

    public ComputeStringInt(string numStr)
    {
      if (string.IsNullOrEmpty(numStr))
        this.Body = "0";
      else
        this.Body = this.Trim(numStr);
    }

    public static implicit operator string(ComputeStringInt source)
    {
      return source.Body;
    }

    public static implicit operator ComputeStringInt(long real)
    {
      return new ComputeStringInt(real.ToString());
    }

    public static implicit operator ComputeStringInt(string real)
    {
      return new ComputeStringInt(real);
    }

    public static bool operator >(ComputeStringInt left, ComputeStringInt right)
    {
      if (left.IsPositive && !right.IsPositive && left.Absolute().Body != "0" && right.Absolute().Body != "0")
        return true;
      if (left.IsPositive && right.IsPositive)
      {
        if (left.Length > right.Length)
          return true;
        if (left.Length != right.Length)
          return false;
        for (int index = 0; index < left.Length; ++index)
        {
          if (left[index] > right[index])
            return true;
          if (left[index] < right[index])
            return false;
        }
      }
      else if (!left.IsPositive && !right.IsPositive)
      {
        if (left.Length < right.Length)
          return true;
        if (left.Length != right.Length)
          return false;
        for (int index = 0; index < left.Length; ++index)
        {
          if (left[index] < right[index])
            return true;
          if (left[index] > right[index])
            return false;
        }
      }
      else if (left.IsPositive && !right.IsPositive && (left.Absolute().Body == "0" && right.Absolute().Body != "0" || left.Absolute().Body != "0" && right.Absolute().Body == "0"))
        return true;
      return false;
    }

    public static bool operator <(ComputeStringInt left, ComputeStringInt right)
    {
      return right > left;
    }

    public static bool operator >=(ComputeStringInt left, ComputeStringInt right)
    {
      return left > right || left == right;
    }

    public static bool operator <=(ComputeStringInt left, ComputeStringInt right)
    {
      return left < right || left == right;
    }

    public static bool operator ==(ComputeStringInt left, ComputeStringInt right)
    {
      return !(left > right) && !(left < right);
    }

    public static bool operator !=(ComputeStringInt left, ComputeStringInt right)
    {
      return left > right || left < right;
    }

    public static bool operator >(ComputeStringInt left, object right)
    {
      return left > new ComputeStringInt(right.ToString());
    }

    public static bool operator >(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) > right;
    }

    public static bool operator <(ComputeStringInt left, object right)
    {
      return left < new ComputeStringInt(right.ToString());
    }

    public static bool operator <(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) < right;
    }

    public static bool operator >=(ComputeStringInt left, object right)
    {
      return left >= new ComputeStringInt(right.ToString());
    }

    public static bool operator >=(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) >= right;
    }

    public static bool operator <=(ComputeStringInt left, object right)
    {
      return left <= new ComputeStringInt(right.ToString());
    }

    public static bool operator <=(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) <= right;
    }

    public static bool operator ==(ComputeStringInt left, object right)
    {
      return left == new ComputeStringInt(right.ToString());
    }

    public static bool operator ==(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) == right;
    }

    public static bool operator !=(ComputeStringInt left, object right)
    {
      return left != new ComputeStringInt(right.ToString());
    }

    public static bool operator !=(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) != right;
    }

    public static ComputeStringInt operator +(ComputeStringInt left, ComputeStringInt right)
    {
      ComputeStringInt computeStringInt1 = new ComputeStringInt();
      if (left.IsPositive && right.IsPositive)
      {
        int length = right.Length;
        if (left.Length > right.Length)
          length = left.Length;
        int num1 = 0;
        for (int index = 0; index < length; ++index)
        {
          int num2 = index >= left.Length || index >= right.Length ? (index < left.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] + num1) : right[right.Length - 1 - index] + num1) : left[left.Length - 1 - index] + right[right.Length - 1 - index] + num1;
          num1 = num2 / 10;
          int num3;
          if (index == 0)
          {
            ComputeStringInt computeStringInt2 = computeStringInt1;
            num3 = num2 % 10;
            string str = num3.ToString();
            computeStringInt2.Body = str;
          }
          else
          {
            ComputeStringInt computeStringInt2 = computeStringInt1;
            string str1 = computeStringInt1.Body;
            int startIndex = 0;
            num3 = num2 % 10;
            string str2 = num3.ToString();
            string str3 = str1.Insert(startIndex, str2);
            computeStringInt2.Body = str3;
          }
        }
        computeStringInt1.Body = computeStringInt1.Body.Insert(0, num1.ToString());
      }
      else if (left.IsPositive && !right.IsPositive)
        computeStringInt1 = left - new ComputeStringInt((string) right.Absolute());
      else if (!left.IsPositive && right.IsPositive)
        computeStringInt1 = right - new ComputeStringInt((string) left.Absolute());
      else if (!left.IsPositive && !right.IsPositive)
        computeStringInt1 = left - new ComputeStringInt((string) right.Absolute());
      computeStringInt1.Trim();
      return computeStringInt1;
    }

    public static ComputeStringInt operator -(ComputeStringInt left, ComputeStringInt right)
    {
      ComputeStringInt computeStringInt = new ComputeStringInt();
      if (left == right)
        return new ComputeStringInt("0");
      if (left > ComputeStringInt.Zero && right == ComputeStringInt.Zero)
        return left;
      if (left == ComputeStringInt.Zero && right < ComputeStringInt.Zero)
        return new ComputeStringInt((string) right.Absolute());
      if (left == ComputeStringInt.Zero && right > ComputeStringInt.Zero)
        return new ComputeStringInt(right.Body.Insert(0, "-"));
      if (left > ComputeStringInt.Zero && right > ComputeStringInt.Zero)
      {
        if (left > right)
        {
          int num1 = 0;
          for (int index = 0; index < left.Length; ++index)
          {
            int num2 = index >= left.Length || index >= right.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] - num1) : left[left.Length - 1 - index] - right[right.Length - 1 - index] - num1;
            num1 = num2 / 10;
            if (num2 < 0)
            {
              num1 = 1;
              num2 = 10 + num2;
            }
            computeStringInt.Body = index != 0 ? computeStringInt.Body.Insert(0, num2.ToString()) : num2.ToString();
          }
        }
        else if (left < right)
        {
          computeStringInt = right - left;
          computeStringInt.Body = computeStringInt.Body.Insert(0, "-");
        }
      }
      else if (left < ComputeStringInt.Zero && right < ComputeStringInt.Zero)
        computeStringInt = new ComputeStringInt((string) right.Absolute()) - new ComputeStringInt((string) left.Absolute());
      else if (left > ComputeStringInt.Zero && right < ComputeStringInt.Zero)
        computeStringInt = left + new ComputeStringInt((string) right.Absolute());
      else if (left < ComputeStringInt.Zero && right > ComputeStringInt.Zero)
      {
        computeStringInt = new ComputeStringInt((string) left.Absolute()) + right;
        computeStringInt.Body = computeStringInt.Body.Insert(0, "-");
      }
      computeStringInt.Trim();
      return computeStringInt;
    }

    public static ComputeStringInt operator *(ComputeStringInt left, ComputeStringInt right)
    {
      ComputeStringInt computeStringInt = new ComputeStringInt();
      if (left == ComputeStringInt.Zero || right == ComputeStringInt.Zero)
        return ComputeStringInt.Zero;
      if (left.IsPositive && right.IsPositive)
      {
        for (int index1 = right.Length - 1; index1 >= 0; --index1)
        {
          int num1 = 0;
          string numStr = "";
          for (int index2 = left.Length - 1; index2 >= 0; --index2)
          {
            int num2 = right.Absolute()[index1] * left.Absolute()[index2] + num1;
            numStr = numStr.Insert(0, (num2 % 10).ToString());
            num1 = num2 / 10;
          }
          if ((uint) num1 > 0U)
            numStr = numStr.Insert(0, num1.ToString());
          for (int index2 = 0; index2 < right.Length - 1 - index1; ++index2)
            numStr += "0";
          computeStringInt += new ComputeStringInt(numStr);
        }
      }
      else if (!left.IsPositive && right.IsPositive || left.IsPositive && !right.IsPositive)
      {
        computeStringInt = new ComputeStringInt((string) left.Absolute()) * new ComputeStringInt((string) right.Absolute());
        computeStringInt.Body = computeStringInt.Body.Insert(0, "-");
      }
      else if (!left.IsPositive && !right.IsPositive)
        computeStringInt = new ComputeStringInt((string) left.Absolute()) * new ComputeStringInt((string) right.Absolute());
      computeStringInt.Trim();
      return computeStringInt;
    }

    public static ComputeStringInt operator /(ComputeStringInt left, ComputeStringInt right)
    {
      ComputeStringInt computeStringInt1 = new ComputeStringInt();
      if (right == ComputeStringInt.Zero)
        throw new Exception("除零错误！");
      if (left == ComputeStringInt.Zero)
        return ComputeStringInt.Zero;
      if (right == new ComputeStringInt("1"))
        return left;
      if (left.IsPositive && right.IsPositive)
      {
        if (left < right)
        {
          computeStringInt1 = ComputeStringInt.Zero;
        }
        else
        {
          string numStr = "";
          ComputeStringInt computeStringInt2 = new ComputeStringInt(left.Body.Substring(0, right.Length - 1));
          for (int index = right.Length - 1; index < left.Length; ++index)
          {
            computeStringInt2 = computeStringInt2 * new ComputeStringInt("10") + new ComputeStringInt(left[index].ToString());
            computeStringInt2.Trim();
            int num = 0;
            for (num = 0; num < 10; ++num)
            {
              ComputeStringInt computeStringInt3 = right * new ComputeStringInt(num.ToString());
              if (computeStringInt3 > computeStringInt2)
              {
                numStr +=  (num - 1);
                computeStringInt2 -= right * new ComputeStringInt((num - 1).ToString());
                break;
              }
              if (computeStringInt3 == computeStringInt2)
              {
                numStr += num;
                computeStringInt2 = ComputeStringInt.Zero;
                break;
              }
            }
            if (num == 10)
            {
              numStr +=(num - 1);
              computeStringInt2 -= right * new ComputeStringInt((num - 1).ToString());
            }
          }
          computeStringInt1 = new ComputeStringInt(numStr);
        }
      }
      else if (!left.IsPositive && right.IsPositive || left.IsPositive && !right.IsPositive)
      {
        computeStringInt1 = new ComputeStringInt((string) left.Absolute()) / new ComputeStringInt((string) right.Absolute());
        computeStringInt1.Body = computeStringInt1.Body.Insert(0, "-");
      }
      else if (!left.IsPositive && !right.IsPositive)
        computeStringInt1 = new ComputeStringInt((string) left.Absolute()) / new ComputeStringInt((string) right.Absolute());
      computeStringInt1.Trim();
      return computeStringInt1;
    }

    public static ComputeStringInt operator %(ComputeStringInt left, ComputeStringInt right)
    {
      ComputeStringInt computeStringInt1 = new ComputeStringInt();
      ComputeStringInt computeStringInt2 = left - left / right * right;
      computeStringInt2.Trim();
      return computeStringInt2;
    }

    public static ComputeStringInt operator +(ComputeStringInt left, object right)
    {
      return left + new ComputeStringInt(right.ToString());
    }

    public static ComputeStringInt operator +(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) + right;
    }

    public static ComputeStringInt operator -(ComputeStringInt left, object right)
    {
      return left - new ComputeStringInt(right.ToString());
    }

    public static ComputeStringInt operator -(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) - right;
    }

    public static ComputeStringInt operator *(ComputeStringInt left, object right)
    {
      return left * new ComputeStringInt(right.ToString());
    }

    public static ComputeStringInt operator *(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) * right;
    }

    public static ComputeStringInt operator /(ComputeStringInt left, object right)
    {
      return left / new ComputeStringInt(right.ToString());
    }

    public static ComputeStringInt operator /(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) / right;
    }

    public static ComputeStringInt operator %(ComputeStringInt left, object right)
    {
      return left % new ComputeStringInt(right.ToString());
    }

    public static ComputeStringInt operator %(object left, ComputeStringInt right)
    {
      return new ComputeStringInt(left.ToString()) % right;
    }

    public ComputeStringInt Absolute()
    {
      if ((int) this.Body[0] == 43 || (int) this.Body[0] == 45)
        return new ComputeStringInt(this.Body.Substring(1));
      return this;
    }

    public void Trim()
    {
      this.Body = this.Trim(this.Body);
    }

    public string Trim(string numStr)
    {
      string str1 = numStr.Trim();
      if ((int) str1[0] == 43)
        str1 = str1.Substring(1);
      string str2 = str1;
      if ((int) str1[0] == 45)
        str2 = str1.Substring(1);
      int index = 0;
      while (index < str2.Length && (int) str2[index] == 48)
        ++index;
      if (index == str2.Length)
        return "0";
      bool flag = true;
      if ((int) str1[0] == 45)
        flag = false;
      int startIndex = 0;
      while (startIndex < str2.Length && (int) str2[startIndex] == 48)
        ++startIndex;
      string str3 = str2.Substring(startIndex);
      if (!flag)
        str3 = str3.Insert(0, "-");
      return str3;
    }

    public override string ToString()
    {
      return this.Body;
    }

    public ComputeStringFloat ToComputeStringFloat()
    {
      return new ComputeStringFloat(this.Body);
    }

    public override bool Equals(object obj)
    {
      return base.Equals(obj);
    }

    public override int GetHashCode()
    {
      return base.GetHashCode();
    }
  }
}

第二类浮点类型

sing System.Text.RegularExpressions;

namespace Sqrt
{
    internal class ComputeStringFloat : ComputeStringInt
    {
        public static int DividResaultPrecision = 50;
        private long DotIndex = 0;
        private string BodyNoDotNoSignal = "0";

        public string IntPart
        {
            get
            {
                if (this.DotIndex <= 0L)
                    return "0";
                return this.BodyNoDotNoSignal.Substring(0, (int)this.DotIndex);
            }
        }

        public string FloatPart
        {
            get
            {
                if (this.DotIndex == (long)this.BodyNoDotNoSignal.Length)
                    return "0";
                if (this.DotIndex == 0L)
                    return this.BodyNoDotNoSignal;
                if (this.DotIndex >= 0L)
                    return this.BodyNoDotNoSignal.Substring((int)this.DotIndex);
                string str = this.BodyNoDotNoSignal;
                for (int index = 0; (long)index < -this.DotIndex; ++index)
                    str = str.Insert(0, "0");
                return str;
            }
        }

        public int IntPartLength
        {
            get
            {
                return this.IntPart.Length;
            }
        }

        public int FloatPartLength
        {
            get
            {
                if (this.FloatPart.Length == 1 && (int)this.FloatPart[0] == 48)
                    return 0;
                return this.FloatPart.Length;
            }
        }

        public ComputeStringFloat()
        {
            this.DotIndex = 1L;
            this.Body = "0";
            this.BodyNoDotNoSignal = "0";
        }

        public ComputeStringFloat(string body)
        {
            if (string.IsNullOrEmpty(body))
                this.Body = "0";
            else
                this.Body = this.Trim(body);
            Match match = Regex.Match(this.Body, "[1-9]");
            int num = this.Body.IndexOf('.');
            this.DotIndex = num < 0 ? (long)(this.Body.Length - match.Index) : (num <= match.Index ? (long)(num - match.Index + 1) : (long)(num - match.Index));
            this.BodyNoDotNoSignal = this.Body.Substring(match.Index);
            int startIndex = this.BodyNoDotNoSignal.IndexOf('.');
            if (startIndex >= 0)
                this.BodyNoDotNoSignal = this.BodyNoDotNoSignal.Remove(startIndex, 1);
            this.BodyNoDotNoSignal = base.Trim(this.BodyNoDotNoSignal);
        }

        public static implicit operator string(ComputeStringFloat source)
        {
            return source.Body;
        }

        public static implicit operator ComputeStringFloat(long real)
        {
            return new ComputeStringFloat(real.ToString());
        }

        public static implicit operator ComputeStringFloat(string real)
        {
            return new ComputeStringFloat(real);
        }

        public static bool operator >(ComputeStringFloat left, ComputeStringFloat right)
        {
            if (left.IsPositive && right.IsPositive)
            {
                if (new ComputeStringInt(left.IntPart) > new ComputeStringInt(right.IntPart))
                    return true;
                int length1 = left.FloatPart.Length;
                int length2 = right.FloatPart.Length;
                string floatPart1 = left.FloatPart;
                string floatPart2 = right.FloatPart;
                if (length1 > length2)
                {
                    for (int index = length2; index < length1; ++index)
                        floatPart2 += "0";
                }
                else if (length1 < length2)
                {
                    for (int index = length1; index < length2; ++index)
                        floatPart1 += "0";
                }
                return new ComputeStringInt(floatPart1) > new ComputeStringInt(floatPart2);
            }
            return left.IsPositive && !right.IsPositive || (left.IsPositive || !right.IsPositive) && (!left.IsPositive && !right.IsPositive && new ComputeStringFloat((string)right.Absolute()) > new ComputeStringFloat((string)left.Absolute()));
        }

        public static bool operator <(ComputeStringFloat left, ComputeStringFloat right)
        {
            return right > left;
        }

        public static bool operator ==(ComputeStringFloat left, ComputeStringFloat right)
        {
            return !(left > right) && !(left < right);
        }

        public static bool operator !=(ComputeStringFloat left, ComputeStringFloat right)
        {
            return left > right || left < right;
        }

        public static bool operator >=(ComputeStringFloat left, ComputeStringFloat right)
        {
            return left < right || left == right;
        }

        public static bool operator <=(ComputeStringFloat left, ComputeStringFloat right)
        {
            return left > right || left == right;
        }

        public static bool operator >(ComputeStringFloat left, object right)
        {
            return left > new ComputeStringFloat(right.ToString());
        }

        public static bool operator >(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) > right;
        }

        public static bool operator <(ComputeStringFloat left, object right)
        {
            return left < new ComputeStringFloat(right.ToString());
        }

        public static bool operator <(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) < right;
        }

        public static bool operator ==(ComputeStringFloat left, object right)
        {
            return left == new ComputeStringFloat(right.ToString());
        }

        public static bool operator ==(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) == right;
        }

        public static bool operator !=(ComputeStringFloat left, object right)
        {
            return left != new ComputeStringFloat(right.ToString());
        }

        public static bool operator !=(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) != right;
        }

        public static bool operator >=(ComputeStringFloat left, object right)
        {
            return left >= new ComputeStringFloat(right.ToString());
        }

        public static bool operator >=(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) >= right;
        }

        public static bool operator <=(ComputeStringFloat left, object right)
        {
            return left <= new ComputeStringFloat(right.ToString());
        }

        public static bool operator <=(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) <= right;
        }

        public static ComputeStringFloat operator +(ComputeStringFloat left, ComputeStringFloat right)
        {
            if (left == (ComputeStringFloat)0L)
                return right;
            if (right == (ComputeStringFloat)0L)
                return left;
            string numStr1 = left.Body;
            int startIndex1 = numStr1.IndexOf('.');
            if (startIndex1 >= 0)
                numStr1 = numStr1.Remove(startIndex1, 1);
            string numStr2 = right.Body;
            int startIndex2 = numStr2.IndexOf('.');
            if (startIndex2 >= 0)
                numStr2 = numStr2.Remove(startIndex2, 1);
            int length1 = left.FloatPart.Length;
            if (right.FloatPart.Length > length1)
            {
                length1 = right.FloatPart.Length;
                if (left.FloatPart == "0")
                {
                    for (int length2 = left.FloatPart.Length; length2 <= length1; ++length2)
                        numStr1 += "0";
                }
                else
                {
                    for (int length2 = left.FloatPart.Length; length2 < length1; ++length2)
                        numStr1 += "0";
                }
            }
            else if (right.FloatPart == "0")
            {
                for (int length2 = right.FloatPart.Length; length2 <= length1; ++length2)
                    numStr2 += "0";
            }
            else
            {
                for (int length2 = right.FloatPart.Length; length2 < length1; ++length2)
                    numStr2 += "0";
            }
            ComputeStringInt computeStringInt = new ComputeStringInt(numStr1) + new ComputeStringInt(numStr2);
            if (computeStringInt.Length == length1)
                return (ComputeStringFloat)computeStringInt.Body.Insert(computeStringInt.Body.Length - length1, "0.");
            if (computeStringInt.Length >= length1)
                return (ComputeStringFloat)computeStringInt.Body.Insert(computeStringInt.Body.Length - length1, ".");
            string str = (string)computeStringInt.Absolute();
            for (int length2 = str.Length; length2 < length1; ++length2)
                str = "0" + str;
            if (computeStringInt.IsPositive)
                return (ComputeStringFloat)str.Insert(0, "0.");
            return (ComputeStringFloat)str.Insert(0, "-0.");
        }

        public static ComputeStringFloat operator -(ComputeStringFloat left, ComputeStringFloat right)
        {
            if (right == (ComputeStringFloat)0L)
                return left;
            if (right.IsPositive)
                return left + (ComputeStringFloat)right.Absolute().Body.Insert(0, "-");
            return left + right.Absolute();
        }

        public static ComputeStringFloat operator *(ComputeStringFloat left, ComputeStringFloat right)
        {
            string numStr1 = left.Body;
            int startIndex1 = numStr1.IndexOf('.');
            if (startIndex1 >= 0)
                numStr1 = numStr1.Remove(startIndex1, 1);
            string numStr2 = right.Body;
            int startIndex2 = numStr2.IndexOf('.');
            if (startIndex2 >= 0)
                numStr2 = numStr2.Remove(startIndex2, 1);
            int floatPartLength1 = left.FloatPartLength;
            if (right.FloatPartLength > floatPartLength1)
            {
                floatPartLength1 = right.FloatPartLength;
                for (int floatPartLength2 = left.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
                    numStr1 += "0";
            }
            else if (right.FloatPartLength < floatPartLength1)
            {
                for (int floatPartLength2 = right.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
                    numStr2 += "0";
            }
            ComputeStringInt computeStringInt = new ComputeStringInt(numStr1) * new ComputeStringInt(numStr2);
            int num = floatPartLength1 + floatPartLength1;
            if (computeStringInt.Length == num)
                return (ComputeStringFloat)computeStringInt.Body.Insert(computeStringInt.Body.Length - num, "0.");
            if (computeStringInt.Length >= num)
                return (ComputeStringFloat)computeStringInt.Body.Insert(computeStringInt.Body.Length - num, ".");
            string str = (string)computeStringInt.Absolute();
            for (int length = str.Length; length < num; ++length)
                str = "0" + str;
            if (computeStringInt.IsPositive)
                return (ComputeStringFloat)str.Insert(0, "0.");
            return (ComputeStringFloat)str.Insert(0, "-0.");
        }

        public static ComputeStringFloat operator /(ComputeStringFloat left, ComputeStringFloat right)
        {
            string numStr1 = left.Body;
            int startIndex1 = numStr1.IndexOf('.');
            if (startIndex1 >= 0)
                numStr1 = numStr1.Remove(startIndex1, 1);
            string numStr2 = right.Body;
            int startIndex2 = numStr2.IndexOf('.');
            if (startIndex2 >= 0)
                numStr2 = numStr2.Remove(startIndex2, 1);
            int floatPartLength1 = left.FloatPartLength;
            if (right.FloatPartLength > floatPartLength1)
            {
                int floatPartLength2 = right.FloatPartLength;
                for (int floatPartLength3 = left.FloatPartLength; floatPartLength3 < floatPartLength2; ++floatPartLength3)
                    numStr1 += "0";
            }
            else if (right.FloatPartLength < floatPartLength1)
            {
                for (int floatPartLength2 = right.FloatPartLength; floatPartLength2 < floatPartLength1; ++floatPartLength2)
                    numStr2 += "0";
            }
            for (int index = 0; index < ComputeStringFloat.DividResaultPrecision; ++index)
                numStr1 += "0";
            ComputeStringInt computeStringInt = new ComputeStringInt(numStr1) / new ComputeStringInt(numStr2);
            int num = ComputeStringFloat.DividResaultPrecision;
            if (computeStringInt.Length == num)
                return (ComputeStringFloat)computeStringInt.Body.Insert(computeStringInt.Body.Length - num, "0.");
            if (computeStringInt.Length >= num)
                return (ComputeStringFloat)computeStringInt.Body.Insert(computeStringInt.Body.Length - num, ".");
            string str = (string)computeStringInt.Absolute();
            for (int length = str.Length; length < num; ++length)
                str = "0" + str;
            if (computeStringInt.IsPositive)
                return (ComputeStringFloat)str.Insert(0, "0.");
            return (ComputeStringFloat)str.Insert(0, "-0.");
        }

        public static ComputeStringFloat operator +(ComputeStringFloat left, object right)
        {
            return left + new ComputeStringFloat(right.ToString());
        }

        public static ComputeStringFloat operator +(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) + right;
        }

        public static ComputeStringFloat operator -(ComputeStringFloat left, object right)
        {
            return left - new ComputeStringFloat(right.ToString());
        }

        public static ComputeStringFloat operator -(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) - right;
        }

        public static ComputeStringFloat operator *(ComputeStringFloat left, object right)
        {
            return left * new ComputeStringFloat(right.ToString());
        }

        public static ComputeStringFloat operator *(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) * right;
        }

        public static ComputeStringFloat operator /(ComputeStringFloat left, object right)
        {
            return left / new ComputeStringFloat(right.ToString());
        }

        public static ComputeStringFloat operator /(object left, ComputeStringFloat right)
        {
            return new ComputeStringFloat(left.ToString()) / right;
        }

        public ComputeStringFloat Absolute()
        {
            if ((int)this.Body[0] == 43 || (int)this.Body[0] == 45)
                return new ComputeStringFloat(this.Body.Substring(1));
            return this;
        }

        public new string Trim(string numStr)
        {
            string str1 = numStr.Trim();
            if ((int)str1[0] == 43)
                str1 = str1.Substring(1);
            int num = str1.IndexOf('.');
            if (num >= 0)
            {
                for (int length = str1.Length - 1; length >= num; --length)
                {
                    if ((int)str1[length] != 48)
                    {
                        str1 = (int)str1[length] != 46 ? str1.Substring(0, length + 1) : str1.Substring(0, length);
                        break;
                    }
                }
            }
            bool flag = false;
            string str2 = str1;
            string str3 = "";
            char ch;
            for (int index = 0; index < str2.Length; ++index)
            {
                if (flag)
                {
                    string str4 = str3;
                    ch = str2[index];
                    string str5 = ch.ToString();
                    str3 = str4 + str5;
                }
                else if ((int)str2[index] == 45)
                {
                    string str4 = str3;
                    ch = str2[index];
                    string str5 = ch.ToString();
                    str3 = str4 + str5;
                }
                else if ((int)str2[index] == 48)
                {
                    if (index + 1 < str2.Length && (int)str2[index + 1] == 46 || index + 1 >= str2.Length)
                    {
                        string str4 = str3;
                        ch = str2[index];
                        string str5 = ch.ToString();
                        str3 = str4 + str5;
                        flag = true;
                    }
                }
                else
                {
                    string str4 = str3;
                    ch = str2[index];
                    string str5 = ch.ToString();
                    str3 = str4 + str5;
                    flag = true;
                }
            }
            if (str3.Length == 2 && (int)str3[0] == 45 && (int)str3[1] == 48)
                str3 = "0";
            return str3;
        }

        public override string ToString()
        {
            return this.Body;
        }

        public ComputeStringInt ToComputeStringInt()
        {
            string numStr = this.IntPart;
            if (!this.IsPositive)
                numStr = numStr.Insert(0, "-");
            return new ComputeStringInt(numStr);
        }

        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}

用法和注意事项：

    private string s1 = "-1";
    private string s2 = "1111111111111222.2222";

    private ComputeStringInt c1 = "2";
    private ComputeStringFloat c2 = "2.3";
    // Use this for initialization
    void Test()
    {
        //注意类型
        Debug.Log(new ComputeStringFloat(s1) / 3);
        ComputeStringFloat.DividResaultPrecision = 3;//浮点的精度 注意是全局的
        Debug.Log((ComputeStringFloat)s2 / 3);
        Debug.Log(c1 / s1);

        Debug.Log(c1 * c2.IntPart);
        // Debug.LogError(c1 * (ComputeStringInt)c2); //注意不能这么用，因为.的ASCII码为46，由于字符数字转换为数字要减去48，那么参与运算的就是2（-2）3，所以结果是错误的！


    }
漩子
关注
专栏目录
C# 4.0 大数的运算,BigInteger
weixin_33736048的博客
10-19 287
前段时间，有个同事说 “30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000...
C#大整数类（BigInteger）
04-06
用C#编写的大整数类，可生成大素数，用于RSA加密，注释非常详细
C# 存储超大的数字
菜刀居士的专栏
05-11 2569
static void Main(string[] args)         {             //存储超大的数字             System.Numerics.BigInteger numA = System.Numerics.BigInteger.Parse("9999999999999999999999999999999999999");            
C# 大数计算
ftfmatlab的博客
10-13 266
本文用数组进位的思想解决次问题，同时重写了简单的四则运算。有时候long类型长度不够用时该如何解决呢？
C# 大数运算
欲望如海水，越喝越渴。
03-08 2052
我想法就是用string去替换int，然后做加减乘除。 于是我开始百度之旅。。。 参考链接：腾讯游戏学院 参考链接：CSDN 是不是感觉很对，这2个链接解决了问题，然而我测试了下，除了除法其他都没有问题。 100/1 = 商1100余数0， 100/2=商550余数0，60000/10000 = 商0余数60000 你们可以测试下，反正我测试是这样（因为我一开始很信任源代码的，后来使用出...
C#实现大数字的运算
weixin_30709635的博客
10-19 418
1、添加引用：System.Numerics.dll 2、添加命名空间：using System.Numerics; 3、实例： 　　3.1判断一个数字是不是质数　 static void Main(string[] args) { Console.WriteLine("请输入一个很大的数字："); s...
C#实现大数字运算的实例代码
09-04
在C#编程语言中，处理大数字运算时，标准的数据类型如int或long可能不足以应对超过其最大值的计算需求。在这种情况下，C#引入了`BigInteger`类，该类位于`System.Numerics`命名空间中，允许进行任意大小的整数运算。...
基本的C#数字运算示例
03-16
摘要:C#源码,算法相关,数字运算,计算器　基本的C#数字运算示例，执行两个数的加法、减法运算，返回相加、相减后的结果，实例化类对象，定义一个死循环，以便循环输入数据，记录运算符号，以运算符号为条件进行判断，...
C#四则运算
07-28
在C#中实现四则运算是一项基础但至关重要的任务，这通常涉及到解析用户输入的字符串形式的运算式子，并进行计算。在本教程中，我们将深入探讨如何在C#中处理四则运算，包括加法、减法、乘法和除法。 首先，我们需要...
C#设计的大数四则运算计算器
11-23
本文将深入探讨如何使用C#实现大数四则运算。 首先，我们要了解大数在计算机中的表示方式。由于常规的整型数据类型如int和long在处理非常大的数字时会受到限制，因此我们需要自定义一种数据结构来存储和操作大数。...
C#实现大数的加减乘运算
10-21
C#实现大数的加减乘运算。包含完整的asp.net项目，可以实现任意两个不限长度的正数的加、减、乘法运算。
C#大数类实现
12-03
编写一个C#窗体应用程序，对于输入的正整数n，然后计算1!+2!+3!+…+n!的值并输出。（可以创建大整数类）
C#大数计算
10-20
ADD,SUM,MUL,DIV Console.WriteLine("和：" + BigInteger.Add(num1, num2)); Console.WriteLine("差：" + BigInteger.Subtract(num1, num2)); Console.WriteLine("积：" + BigInteger.Multiply(num1, num2)); Console.WriteLine("商：" + BigInteger.Divide(num1, num2));
C#大数相乘
02-11
自己写的一个实现大数相乘的算法，其原理是乘法的进位用字符串来存储输出。欢迎交流
C# BigInteger 处理超大整型数字
森大科技的博客
05-07 914
GPS平台、网站建设、软件开发、系统运维，找森大网络科技！ http://cnsendnet.taobao.com 来自森大科技官方博客 http://www.cnsendblog.com/index.php/?p=612 微软官方说明： https://docs.microsoft.com/zh-cn/dotnet/api/system.numerics.biginteger?redirecte...
c#大数运算
luanshf的专栏
03-29 2862
//************************************************************************************// BigInteger Class Version 1.03//// Copyright (c) 2002 Chew Keong TAN// All rights reserved.//// Permission is he
C#实现大数相加
ddry47579的博客
05-14 378
在C#中，我们经常需要表示整数。但是，c#的基本数据类型中，最大的long也只能表示-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807之间的数。 如果我们需要表示更大的数，就需要用到一定的算法来完成。 这次，我给大家分享一下C##的大数运算之加法。 代码只考虑了正数的整数加法。 1 using System; 2...
C#实现大数据运算：加减乘除全攻略
本文将深入探讨如何在C#环境中进行高效的超大数据运算，包括加法、减法、乘法等操作。我们将通过分析提供的代码片段来理解其工作原理，并讨论相关的优化策略。 首先，代码定义了一个名为`Comput`的类，用于执行...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值