初涉大数运算（下）

#include "Calculate.h"//此处为《初涉大数运算（上）》中头文件

#pragma region 初始化

Calculate::LargeDecimal::LargeDecimal()
{
  this->Integer.push_back(0);
  this->Decimal.push_back(0);
  this->bIsNegative = false;
  this->lPoint = -1;
}

Calculate::LargeDecimal::LargeDecimal(int iNumber)
{
  this->Decimal.push_back(0);
  this->lPoint = -1;
  if(iNumber < 0)
  {
    this->bIsNegative = true;
    iNumber = 0 - iNumber;
  }
  else
  {
    this->bIsNegative = false;
    if(!iNumber)
    {
      this->Integer.push_back(0);
    }
  }
  while(iNumber)
  {
    this->Integer.insert(this->Integer.begin(), iNumber % 10000);
    iNumber /= 10000;
  }
}

Calculate::LargeDecimal::LargeDecimal(long lNumber)
{
  this->Decimal.push_back(0);
  this->lPoint = -1;
  if(lNumber < 0)
  {
    this->bIsNegative = true;
    lNumber = 0 - lNumber;
  }
  else
  {
    this->bIsNegative = false;
    if(!lNumber)
    {
      this->Integer.push_back(0);
    }
  }
  while(lNumber)
  {
    this->Integer.insert(this->Integer.begin(), (lNumber % 10000));
    lNumber /= 10000;
  }
}

Calculate::LargeDecimal::LargeDecimal(float fNumber)
{
  String ^ strNumber = fNumber.ToString();
  int iE = strNumber->IndexOf('E');
  if(iE != -1)
  {
    strNumber = strNumber->Remove(iE);
  }
  long lTemp;
  String ^ strTemp;
  if(strNumber[0] == '-')
  {
    this->bIsNegative = true;
    strNumber = strNumber->Remove(0, 1);
  }
  else
  {
    this->bIsNegative = false;
  }
  while(strNumber->Length > 1)
  {
    if(strNumber[0] == '0')
    {
      if(strNumber[1] == '.')
      {
        break;
      }
      else
      {
        strNumber = strNumber->Remove(0, 1);
      }
    }
    else
    {
      break;
    }
  }
  this->lPoint = strNumber->IndexOf('.');
  String ^ strInteger = strNumber;
  String ^ strDecimal = strNumber;
  if(this->lPoint != -1)
  {
    strInteger = strInteger->Remove(this->lPoint);
    strDecimal = strDecimal->Remove(0, this->lPoint + 1);
  }
  while(strInteger->Length % 4)
  {
    strInteger = strInteger->Insert(0, "0");
  }
  while(strInteger->Length)
  {
    strTemp = String::Copy(strInteger);
    if(strInteger->Length == 4)
    {
      strInteger = strInteger->Remove(0);
    }
    else
    {
      strTemp = strTemp->Remove(4);
      strInteger = strInteger->Remove(0, 4);
    }
    lTemp = System::Convert::ToInt32(strTemp);
    this->Integer.push_back(lTemp);
  }
  while(strDecimal->Length % 4)
  {
    strDecimal += "0";
  }
  while(strDecimal->Length)
  {
    strTemp = String::Copy(strDecimal);
    if(strDecimal->Length == 4)
    {
      strDecimal = strDecimal->Remove(0);
    }
    else
    {
      strTemp = strTemp->Remove(4);
      strDecimal = strDecimal->Remove(0, 4);
    }
    lTemp = System::Convert::ToInt32(strTemp);
    this->Decimal.push_back(lTemp);
  }
}

Calculate::LargeDecimal::LargeDecimal(double dNumber)
{
  String ^ strNumber = dNumber.ToString();
  int iE = strNumber->IndexOf('E');
  if(iE != -1)
  {
    strNumber = strNumber->Remove(iE);
  }
  long lTemp;
  String ^ strTemp;
  if(strNumber[0] == '-')
  {
    this->bIsNegative = true;
    strNumber = strNumber->Remove(0, 1);
  }
  else
  {
    this->bIsNegative = false;
  }
  while(strNumber->Length > 1)
  {
    if(strNumber[0] == '0')
    {
      if(strNumber[1] == '.')
      {
        break;
      }
      else
      {
        strNumber = strNumber->Remove(0, 1);
      }
    }
    else
    {
      break;
    }
  }
  this->lPoint = strNumber->IndexOf('.');
  String ^ strInteger = strNumber;
  String ^ strDecimal = strNumber;
  if(this->lPoint != -1)
  {
    strInteger = strInteger->Remove(this->lPoint);
    strDecimal = strDecimal->Remove(0, this->lPoint + 1);
  }
  while(strInteger->Length % 4)
  {
    strInteger = strInteger->Insert(0, "0");
  }
  while(strInteger->Length)
  {
    strTemp = String::Copy(strInteger);
    if(strInteger->Length == 4)
    {
      strInteger = strInteger->Remove(0);
    }
    else
    {
      strTemp = strTemp->Remove(4);
      strInteger = strInteger->Remove(0, 4);
    }
    lTemp = System::Convert::ToInt32(strTemp);
    this->Integer.push_back(lTemp);
  }
  while(strDecimal->Length % 4)
  {
    strDecimal += "0";
  }
  while(strDecimal->Length)
  {
    strTemp = String::Copy(strDecimal);
    if(strDecimal->Length == 4)
    {
      strDecimal = strDecimal->Remove(0);
    }
    else
    {
      strTemp = strTemp->Remove(4);
      strDecimal = strDecimal->Remove(0, 4);
    }
    lTemp = System::Convert::ToInt32(strTemp);
    this->Decimal.push_back(lTemp);
  }
}

Calculate::LargeDecimal::LargeDecimal(String ^ strNumber)
{
  long lTemp;
  String ^ strTemp;
  if(strNumber[0] == '-')
  {
    this->bIsNegative = true;
    strNumber = strNumber->Remove(0, 1);
  }
  else
  {
    this->bIsNegative = false;
  }
  while(strNumber->Length > 1)
  {
    if(strNumber[0] == '0')
    {
      if(strNumber[1] == '.')
      {
        break;
      }
      else
      {
        strNumber = strNumber->Remove(0, 1);
      }
    }
    else
    {
      break;
    }
  }
  this->lPoint = strNumber->IndexOf('.');
  String ^ strInteger = strNumber;
  String ^ strDecimal = strNumber;
  if(this->lPoint != -1)
  {
    strInteger = strInteger->Remove(this->lPoint);
    strDecimal = strDecimal->Remove(0, this->lPoint + 1);
  }
  while(strInteger->Length % 4)
  {
    strInteger = strInteger->Insert(0, "0");
  }
  while(strInteger->Length)
  {
    strTemp = String::Copy(strInteger);
    if(strInteger->Length == 4)
    {
      strInteger = strInteger->Remove(0);
    }
    else
    {
      strTemp = strTemp->Remove(4);
      strInteger = strInteger->Remove(0, 4);
    }
    lTemp = System::Convert::ToInt32(strTemp);
    this->Integer.push_back(lTemp);
  }
  if(this->lPoint != -1)
  {
    while(strDecimal->Length % 4)
    {
      strDecimal += "0";
    }
    while(strDecimal->Length)
    {
      strTemp = String::Copy(strDecimal);
      if(strDecimal->Length == 4)
      {
        strDecimal = strDecimal->Remove(0);
      }
      else
      {
        strTemp = strTemp->Remove(4);
        strDecimal = strDecimal->Remove(0, 4);
      }
      lTemp = System::Convert::ToInt32(strTemp);
      this->Decimal.push_back(lTemp);
    }
  }
  else
  {
    this->Decimal.push_back(0);
  }
}

#pragma endregion

#pragma region 数学函数

Calculate::LargeDecimal Calculate::LargeDecimal::Abs()
{
  Calculate::LargeDecimal Data;
  Data = * this;
  Data.bIsNegative = false;
  return Data;
}

Calculate::LargeDecimal Calculate::LargeDecimal::Random()
{
  return Calculate::LargeDecimal(System::Random::Random().NextDouble());;
}

#pragma endregion

#pragma region 转换类型

String ^ Calculate::LargeDecimal::ToString()
{
  String ^ strNumber = "";
  String ^ strTemp;
  Calculate::LargeDecimal Data;
  Data = * this;
  while(!Data.Integer.empty())
  {
    strTemp = Data.Integer.back().ToString();
    while(strTemp->Length < 4)
    {
      strTemp = strTemp->Insert(0, "0");
    }
    strNumber = strNumber->Insert(0, strTemp);
    Data.Integer.pop_back();
  }
  while((strNumber->Length - 1) > 0)
  {
    if(strNumber[0] == '0')
    {
      strNumber = strNumber->Remove(0, 1);
    }
    else
    {
      break;
    }
  }
  if(Data.lPoint != -1)
  {
    strNumber += ".";
    while(!Data.Decimal.empty())
    {
      strTemp = Data.Decimal.back().ToString();
      while(strTemp->Length < 4)
      {
        strTemp = strTemp->Insert(0, "0");
      }
      strNumber = strNumber->Insert(this->lPoint + 1, strTemp);
      Data.Decimal.pop_back();
    }
    strNumber = strNumber->TrimEnd('0');
  }
  if(bIsNegative)
  {
    strNumber = strNumber->Insert(0, "-");
  }
  return strNumber;
}

Calculate::LargeDecimal Calculate::LargeDecimal::ToInteger()
{
  Calculate::LargeDecimal Data;
  Data = * this;
  Data.Decimal.resize(1);
  Data.Decimal[0] = 0;
  Data.lPoint = -1;
  return Data;
}

Calculate::LargeDecimal Calculate::LargeDecimal::ToDecimal()
{
  Calculate::LargeDecimal Data;
  Data = * this;
  Data.Integer.resize(1);
  Data.Integer[0] = 0;
  return Data;
}

#pragma endregion

#pragma region 加法运算

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(Calculate::LargeDecimal & ldSecond) const
{
  Calculate::LargeDecimal DataLeft;
  Calculate::LargeDecimal DataRight;
  DataLeft = * this;
  DataRight = ldSecond;
  switch(DataLeft.bIsNegative)
  {
  case true:
    {
      switch(DataRight.bIsNegative)
      {
      case true://--
        {
          return -((- DataLeft) + (- DataRight));
          break;
        }
      case false://-+
        {
          return DataRight - (- DataLeft);
          break;
        }
      };
      break;
    }
  case false:
    {
      switch(DataRight.bIsNegative)
      {
      case true://+-
        {
          return DataLeft - (- DataRight);
          break;
        }
      case false://++
        {
          Calculate::LargeDecimal ldResult;
          int iFirst, iSecond, iCarry;
          int iSize;
          int i, j;
          iSize = DataLeft.Decimal.size() < DataRight.Decimal.size() ? DataRight.Decimal.size() : DataLeft.Decimal.size();
          ldResult.Decimal.resize(iSize);
          iSize = DataLeft.Decimal.size() > DataRight.Decimal.size() ? DataRight.Decimal.size() : DataLeft.Decimal.size();
          for(i = iSize - 1, iCarry = 0; i >= 0; i --)
          {
            iFirst = (int)DataLeft.Decimal[i];
            iSecond = (int)DataRight.Decimal[i];
            iFirst = iFirst + iSecond + iCarry;
            ldResult.Decimal[i] = iFirst % 10000;
            iCarry = iFirst / 10000;
          }
          for(i = iSize; i < (int)DataLeft.Decimal.size(); i ++)
          {
            ldResult.Decimal[i] = DataLeft.Decimal[i];
          }
          for(i = iSize; i < (int)DataRight.Decimal.size(); i ++)
          {
            ldResult.Decimal[i] = DataRight.Decimal[i];
          }
          iSize = DataLeft.Integer.size() < DataRight.Integer.size() ? DataRight.Integer.size() : DataLeft.Integer.size();
          ldResult.Integer.resize(iSize);
          for(i = DataLeft.Integer.size() - 1, j = DataRight.Integer.size() - 1; i >= 0 || j >= 0;)
          {
            if(i != -1 && j != -1)
            {
              iFirst = DataLeft.Integer[i];
              iSecond = DataRight.Integer[j];
              i --;
              j --;
            }
            else if(i != -1)
            {
              iFirst = DataLeft.Integer[i];
              iSecond = 0;
              i --;
            }
            else if(j != -1)
            {
              iFirst = 0;
              iSecond = DataRight.Integer[j];
              j --;
            }
            if(i == -1 && j == -1)
            {
              iFirst = iFirst + iSecond + iCarry;
              ldResult.Integer[0] = iFirst % 10000;
              iCarry = iFirst / 10000;
              if(iCarry)
              {
                ldResult.Integer.insert(ldResult.Integer.begin(), iCarry);//最高进位
              }
            }
            else
            {
              iFirst = iFirst + iSecond + iCarry;
              ldResult.Integer[(i > j ? i : j) + 1] = iFirst % 10000;
              iCarry = iFirst / 10000;
            }
          }
          while(ldResult.Decimal.size() > 1)//消除小数点最后的零
          {
            if(!ldResult.Decimal.back())
            {
              ldResult.Decimal.pop_back();
            }
            else
            {
              break;
            }
          }
          if(ldResult.Decimal.back())
          {
            ldResult.lPoint = (ldResult.Integer.size() - 1) * 4;//小数点基本位数为其“整数部分”（节数 - 1） * 4
            if(ldResult.Integer[0] / 1000)//最高位节为四位数
            {
              ldResult.lPoint += 4;
            }
            else if(ldResult.Integer[0] / 100)
            {
              ldResult.lPoint += 3;
            }
            else if(ldResult.Integer[0] / 10)
            {
              ldResult.lPoint += 2;
            }
            else
            {
              ldResult.lPoint += 1;
            }
          }
          else
          {
            ldResult.lPoint = -1;
          }
          return ldResult;
          break;
        }
      };
      break;
    }
  }
  return 0;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(int iNumber) const
{
  return * this + Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(long lNumber) const
{
  return * this + Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(float fNumber) const
{
  return * this + Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(double dNumber) const
{
  return * this + Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(String ^ strNumber) const
{
  return * this + Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 减法运算

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(Calculate::LargeDecimal & ldSecond) const
{
  Calculate::LargeDecimal DataLeft;
  Calculate::LargeDecimal DataRight;
  DataLeft = * this;
  DataRight = ldSecond;
  switch(DataLeft.bIsNegative)
  {
  case true:
    {
      switch(DataRight.bIsNegative)
      {
      case true://--
        {
          return (- DataRight) - (- DataLeft);
          break;
        }
      case false://-+
        {
          return - ((- DataLeft) + DataRight);
          break;
        }
      };
      break;
    }
  case false:
    {
      switch(DataRight.bIsNegative)
      {
      case true://+-
        {
          return DataLeft + (- DataRight);
          break;
        }
      case false://++
        {
          Calculate::LargeDecimal ldResult;
          if(DataLeft < DataRight)
          {
            ldResult = DataLeft;
            DataLeft = DataRight;
            DataRight = ldResult;
            ldResult.bIsNegative = true;
          }
          else if(DataLeft == DataRight)//两数相等返回 0，该处 0 为 LargeDecimal::LargeDecimal(0);
          {
            return 0;
          }
          long lFirst, lSecond;
          int iSize;
          int i, j;
          int iFirstSize = DataLeft.Decimal.size();
          int iSecondSize = DataRight.Decimal.size();
          iSize = iFirstSize > iSecondSize ? iFirstSize : iSecondSize;
          ldResult.Decimal.resize(iSize);
          for(i = iSize - 1; i >= 0; i --)
          {
            if(i < iFirstSize && i < iSecondSize)
            {
              lFirst = DataLeft.Decimal[i];
              lSecond = DataRight.Decimal[i];
            }
            else if(i < iFirstSize)
            {
              lFirst = DataLeft.Decimal[i];
              lSecond = 0;
            }
            else if(i < iSecondSize)
            {
              lFirst = 0;
              lSecond = DataRight.Decimal[i];
            }
            if(lFirst < lSecond)
            {
              lFirst += 10000;
              if(i > 0)
              {
                DataLeft.Decimal[i - 1] --;
              }
              else
              {
                DataLeft.Integer[0] --;
              }
            }
            lFirst = lFirst - lSecond;
            ldResult.Decimal[i] = lFirst;
          }
          iFirstSize = DataLeft.Integer.size();
          iSecondSize = DataRight.Integer.size();
          iSize = iFirstSize > iSecondSize ? iFirstSize : iSecondSize;
          ldResult.Integer.resize(iSize);
          for(i = iFirstSize - 1, j = iSecondSize - 1; i >= 0 || j >= 0; i --, j --)
          {
            if(i >= 0 && j >= 0)
            {
              lFirst = DataLeft.Integer[i];
              lSecond = DataRight.Integer[j];
            }
            else if(i >= 0)
            {
              lFirst = DataLeft.Integer[i];
              lSecond = 0;
            }
            else if(j >= 0)
            {
              lFirst = 0;
              lSecond = DataRight.Integer[j];
            }
            if(lFirst < lSecond)
            {
              lFirst += 10000;
              DataLeft.Integer[i - 1] --;
            }
            lFirst = lFirst - lSecond;
            ldResult.Integer[(i > j ? i : j)] = lFirst;
          }
          while(ldResult.Decimal.size() > 1)
          {
            if(!ldResult.Decimal.back())
            {
              ldResult.Decimal.pop_back();
            }
            else
            {
              break;
            }
          }
          while(ldResult.Integer.size() > 1)
          {
            if(!ldResult.Integer[0])
            {
              ldResult.Integer.erase(ldResult.Integer.begin());
            }
            else
            {
              break;
            }
          }
          if(ldResult.Decimal.back())
          {
            ldResult.lPoint = (ldResult.Integer.size() - 1) * 4;//小数点基本位数为其“整数部分”（节数 - 1） * 4
            if(ldResult.Integer[0] / 1000)//最高位节为四位数
            {
              ldResult.lPoint += 4;
            }
            else if(ldResult.Integer[0] / 100)
            {
              ldResult.lPoint += 3;
            }
            else if(ldResult.Integer[0] / 10)
            {
              ldResult.lPoint += 2;
            }
            else
            {
              ldResult.lPoint += 1;
            }
          }
          else
          {
            ldResult.lPoint = -1;
          }
          return ldResult;
          break;
        }
      };
      break;
    }
  }
  return 0;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(int iNumber) const
{
  return * this - Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(long lNumber) const
{
  return * this - Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(float fNumber) const
{
  return * this - Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(double dNumber) const
{
  return * this - Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(String ^ strNumber) const
{
  return * this - Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 乘法运算

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(Calculate::LargeDecimal & ldSecond) const
{
  if(* this == 0 || ldSecond == 0)
  {
    return 0;
  }
  long i, j, k;
  long lFirst, lSecond, lResult;
  Calculate::LargeDecimal DataLeft = * this;
  Calculate::LargeDecimal DataRight = ldSecond;
  Calculate::LargeDecimal ldResult = 0;
  DataLeft = DataLeft.Abs();
  DataRight = DataRight.Abs();
  String ^ strResult = "";
  long lFirstPointer = DataLeft.Decimal.size();
  long lSecondPointer = DataRight.Decimal.size();
  if(lFirstPointer == 1 && DataLeft.Decimal[0] == 0)
  {
    lFirstPointer = 0;
  }
  if(lSecondPointer == 1 && DataRight.Decimal[0] == 0)
  {
    lSecondPointer = 0;
  }
  long lPointer = lFirstPointer + lSecondPointer;//答案的小数位数
  while(DataLeft.Decimal.size() > 1)
  {
    DataLeft.Integer.push_back(DataLeft.Decimal[0]);
    DataLeft.Decimal.erase(DataLeft.Decimal.begin());
  }
  while(DataRight.Decimal.size() > 1)
  {
    DataRight.Integer.push_back(DataRight.Decimal[0]);
    DataRight.Decimal.erase(DataRight.Decimal.begin());
  }
  if(DataLeft.Decimal[0])
  {
    DataLeft.Integer.push_back(DataLeft.Decimal[0]);
    DataLeft.Decimal.erase(DataLeft.Decimal.begin());
  }
  if(DataRight.Decimal[0])
  {
    DataRight.Integer.push_back(DataRight.Decimal[0]);
    DataRight.Decimal.erase(DataRight.Decimal.begin());
  }
  while(DataLeft.Integer.size() > 1)
  {
    if(DataLeft.Integer[0] == 0)
    {
      DataLeft.Integer.erase(DataLeft.Integer.begin());
    }
    else
    {
      break;
    }
  }
  while(DataRight.Integer.size() > 1)
  {
    if(DataRight.Integer[0] == 0)
    {
      DataRight.Integer.erase(DataRight.Integer.begin());
    }
    else
    {
      break;
    }
  }
  DataLeft.Decimal.resize(1);
  DataRight.Decimal.resize(1);
  for(i = DataLeft.Integer.size() - 1; i >= 0; i --)
  {
    lFirst = DataLeft.Integer[i];
    if(lFirst)
    {
      for(j = DataRight.Integer.size() - 1; j >= 0; j --)
      {
        lSecond = DataRight.Integer[j];
        if(lSecond)
        {
          lResult = lFirst * lSecond;
        }
        else
        {
          lResult = 0;
        }
        strResult = lResult.ToString();
        for(k = DataLeft.Integer.size() - 1 - i + DataRight.Integer.size() - 1 - j; k > 0; k --)
        {
          strResult += "0000";
        }
        ldResult += strResult;
      }
    }
  }
  if(lPointer)
  {
    for(i = 0; i < lPointer; i ++)
    {
      if(ldResult.Integer.size())
      {
        ldResult.Decimal.insert(ldResult.Decimal.begin(), ldResult.Integer.back());
        ldResult.Integer.pop_back();
      }
      else
      {
        ldResult.Decimal.insert(ldResult.Decimal.begin(), 0);
      }
    }
    if(!ldResult.Integer.size())
    {
      ldResult.Integer.resize(1);
    }
    ldResult.lPoint = ldResult.ToInteger().ToString()->Length;
  }
  while(ldResult.Decimal.size() > 1)
  {
    if(ldResult.Decimal.back())
    {
      break;
    }
    else
    {
      ldResult.Decimal.pop_back();
    }
  }
  ldResult.bIsNegative = this->bIsNegative != ldSecond.bIsNegative;
  return ldResult;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(int iNumber) const
{
  return * this * Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(long lNumber) const
{
  return * this * Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(float fNumber) const
{
  return * this * Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(double dNumber) const
{
  return * this * Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(String ^ strNumber) const
{
  return * this * Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 除法运算

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(Calculate::LargeDecimal & ldSecond) const
{
  if(ldSecond == 0)
  {
    String ^ msg = "除数不可以为 0 ";
    throw msg;
  }
  if( * this == 0)
  {
    return 0;
  }
  Calculate::LargeDecimal ldResult = 0;
  Calculate::LargeDecimal DataLeft = * this;
  Calculate::LargeDecimal DataRight = ldSecond;
  long i;
  Calculate::LargeDecimal j, k;
  long lPointer = -1;
  String ^ strResult = "";
  bool bNegativeFlag = !(this->bIsNegative == ldSecond.bIsNegative);
  while(DataRight.lPoint != -1)
  {
    if(DataLeft.ToInteger() == 0)
    {
      DataLeft.Integer.clear();
    }
    if(DataRight.ToInteger() == 0)
    {
      DataRight.Integer.clear();
    }
    if(DataLeft.Decimal.size())
    {
      DataLeft.Integer.push_back(DataLeft.Decimal[0]);
      DataLeft.Decimal.erase(DataLeft.Decimal.begin());
      DataLeft.lPoint += 4;
    }
    else
    {
      DataLeft.Integer.push_back(0);
      DataLeft.lPoint = -1;
    }
    if(DataRight.Decimal.size() > 1)
    {
      DataRight.Integer.push_back(DataRight.Decimal[0]);
      DataRight.Decimal.erase(DataRight.Decimal.begin());
      DataRight.lPoint += 4;
    }
    else
    {
      DataRight.Integer.push_back(DataRight.Decimal[0]);
      DataRight.Decimal[0] = 0;
      DataRight.lPoint = -1;
    }
  }
  DataLeft.Decimal.resize(1);
  DataLeft.bIsNegative = false;
  DataRight.bIsNegative = false;
  Calculate::LargeDecimal RecorderLeft;
  Calculate::LargeDecimal RecorderRight;
  Calculate::LargeDecimal RecorderMiddle;
  long lTimes;
  String ^ strValueJ;
  lTimes = DataLeft.Size() + DataRight.Size() + 1;
  for(i = 0; (DataLeft != 0) && (i < lTimes); i ++)
  {
    for(j = 0; DataLeft >= DataRight; j ++)
    {
      DataLeft -= DataRight;
    }
    strValueJ = j.ToString();
    while(strValueJ->Length < 4)
    {
      strValueJ = "0" + strValueJ;
    }
    strResult += strValueJ;
    if(!i)
    {
      strResult += ".";
    }
    DataLeft *= 10000;
  }
  if(bNegativeFlag)//设定正负号，同号为正，否则为负
  {
    strResult = "-" + strResult;
  }
  if(strResult[strResult->Length - 1] == '.')//最后一位为 “.” 则删除
  {
    strResult = strResult->Remove(strResult->Length - 1);
  }
  return strResult;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(int iNumber) const
{
  return * this / Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(long lNumber) const
{
  return * this / Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(float fNumber) const
{
  return * this / Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(double dNumber) const
{
  return * this / Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(String ^ strNumber) const
{
  return * this / Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 取模计算

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(Calculate::LargeDecimal & ldSecond) const
{
  if(ldSecond == 0)
  {
    return -1;
  }
  if( * this == 0)
  {
    return 0;
  }
  Calculate::LargeDecimal DataLeft = * this;
  Calculate::LargeDecimal DataRight = ldSecond;
  Calculate::LargeDecimal ldResult = DataLeft;
  if(DataLeft.ToDecimal() != 0 || DataRight.ToDecimal() != 0)
  {
    return -1;
  }
  while(DataLeft >= DataRight)
  {
    DataLeft -= DataRight;
  }
  return DataLeft;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(int iNumber) const
{
  return * this % Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(long lNumber) const
{
  return * this % Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(float fNumber) const
{
  return * this % Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(double dNumber) const
{
  return * this % Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(String ^ strNumber) const
{
  return * this % Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 赋值加

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(Calculate::LargeDecimal & ldSecond)
{
  * this = * this + ldSecond;
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(int iNumber)
{
  * this = * this + Calculate::LargeDecimal(iNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(long lNumber)
{
  * this = * this + Calculate::LargeDecimal(lNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(float fNumber)
{
  * this = * this + Calculate::LargeDecimal(fNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(double dNumber)
{
  * this = * this + Calculate::LargeDecimal(dNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(String ^ strNumber)
{
  * this = * this + Calculate::LargeDecimal(strNumber);
  return * this;
}

#pragma endregion

#pragma region 赋值减

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(Calculate::LargeDecimal & ldSecond)
{
  * this = * this - ldSecond;
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(int iNumber)
{
  * this = * this - Calculate::LargeDecimal(iNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(long lNumber)
{
  * this = * this - Calculate::LargeDecimal(lNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(float fNumber)
{
  * this = * this - Calculate::LargeDecimal(fNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(double dNumber)
{
  * this = * this - Calculate::LargeDecimal(dNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(String ^ strNumber)
{
  * this = * this - Calculate::LargeDecimal(strNumber);
  return * this;
}

#pragma endregion

#pragma region 赋值乘

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(Calculate::LargeDecimal & ldSecond)
{
  * this = * this * ldSecond;
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(int iNumber)
{
  * this = * this * Calculate::LargeDecimal(iNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(long lNumber)
{
  * this = * this * Calculate::LargeDecimal(lNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(float fNumber)
{
  * this = * this * Calculate::LargeDecimal(fNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(double dNumber)
{
  * this = * this * Calculate::LargeDecimal(dNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(String ^ strNumber)
{
  * this = * this * Calculate::LargeDecimal(strNumber);
  return * this;
}

#pragma endregion

#pragma region 赋值除

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(Calculate::LargeDecimal & ldSecond)
{
  * this = * this / ldSecond;
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(int iNumber)
{
  * this = * this / Calculate::LargeDecimal(iNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(long lNumber)
{
  * this = * this / Calculate::LargeDecimal(lNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(float fNumber)
{
  * this = * this / Calculate::LargeDecimal(fNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(double dNumber)
{
  * this = * this / Calculate::LargeDecimal(dNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(String ^ strNumber)
{
  * this = * this / Calculate::LargeDecimal(strNumber);
  return * this;
}

#pragma endregion

#pragma region 赋值模

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(Calculate::LargeDecimal & ldSecond)
{
  * this = * this % ldSecond;
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(int iNumber)
{
  * this = * this % Calculate::LargeDecimal(iNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(long lNumber)
{
  * this = * this % Calculate::LargeDecimal(lNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(float fNumber)
{
  * this = * this % Calculate::LargeDecimal(fNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(double dNumber)
{
  * this = * this % Calculate::LargeDecimal(dNumber);
  return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(String ^ strNumber)
{
  * this = * this % Calculate::LargeDecimal(strNumber);
  return * this;
}

#pragma endregion

#pragma region 逻辑大于

bool Calculate::LargeDecimal::operator >(Calculate::LargeDecimal & ldSecond) const
{
  bool bFirstNegative = !this->bIsNegative;
  bool bSecondNegative = !ldSecond.bIsNegative;
  int i;
  if(bFirstNegative > bSecondNegative)
  {
    return true;
  }
  else if(bFirstNegative < bSecondNegative)
  {
    return false;
  }
  int iFirstSize = this->Integer.size();
  int iSecondSize = ldSecond.Integer.size();
  if(iFirstSize > iSecondSize)
  {
    if(bFirstNegative)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
  else if(iFirstSize < iSecondSize)
  {
    if(bFirstNegative)
    {
      return false;
    }
    else
    {
      return true;
    }
  }
  for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
  {
    if(this->Integer[i] > ldSecond.Integer[i])
    {
      if(bFirstNegative)
      {
        return true;
      }
      else
      {
        return false;
      }
    }
    else if(this->Integer[i] < ldSecond.Integer[i])
    {
      if(bFirstNegative)
      {
        return false;
      }
      else
      {
        return true;
      }
    }
  }
  iFirstSize = this->Decimal.size();
  iSecondSize = ldSecond.Decimal.size();
  for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
  {
    if(this->Decimal[i] > ldSecond.Decimal[i])
    {
      if(bFirstNegative)
      {
        return true;
      }
      else
      {
        return false;
      }
    }
    else if(this->Decimal[i] < ldSecond.Decimal[i])
    {
      if(bFirstNegative)
      {
        return false;
      }
      else
      {
        return true;
      }
    }
  }
  if(iFirstSize > iSecondSize)
  {
    return true;
  }
  else
  {
    return false;
  }
}

bool Calculate::LargeDecimal::operator >(int iNumber) const
{
  return (* this) > Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator >(long lNumber) const
{
  return (* this) > Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator >(float fNumber) const
{
  return (* this) > Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator >(double dNumber) const
{
  return (* this) > Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator >(String ^ strNumber) const
{
  return (* this) > Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 逻辑小于

bool Calculate::LargeDecimal::operator <(Calculate::LargeDecimal & ldSecond) const
{
  bool bFirstNegative = !this->bIsNegative;
  bool bSecondNegative = !ldSecond.bIsNegative;
  int i;
  if(bFirstNegative < bSecondNegative)
  {
    return true;
  }
  else if(bFirstNegative > bSecondNegative)
  {
    return false;
  }
  int iFirstSize = this->Integer.size();
  int iSecondSize = ldSecond.Integer.size();
  if(iFirstSize < iSecondSize)
  {
    if(bFirstNegative)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
  else if(iFirstSize > iSecondSize)
  {
    if(bFirstNegative)
    {
      return false;
    }
    else
    {
      return true;
    }
  }
  for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
  {
    if(this->Integer[i] < ldSecond.Integer[i])
    {
      if(bFirstNegative)
      {
        return true;
      }
      else
      {
        return false;
      }
    }
    else if(this->Integer[i] > ldSecond.Integer[i])
    {
      if(bFirstNegative)
      {
        return false;
      }
      else
      {
        return true;
      }
    }
  }
  iFirstSize = this->Decimal.size();
  iSecondSize = ldSecond.Decimal.size();
  for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
  {
    if(this->Decimal[i] < ldSecond.Decimal[i])
    {
      if(bFirstNegative)
      {
        return true;
      }
      else
      {
        return false;
      }
    }
    else if(this->Decimal[i] > ldSecond.Decimal[i])
    {
      if(bFirstNegative)
      {
        return false;
      }
      else
      {
        return true;
      }
    }
  }
  if(iFirstSize < iSecondSize)
  {
    return true;
  }
  else
  {
    return false;
  }
}

bool Calculate::LargeDecimal::operator <(int iNumber) const
{
  return (* this) < Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator <(long lNumber) const
{
  return (* this) < Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator <(float fNumber) const
{
  return (* this) < Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator <(double dNumber) const
{
  return (* this) < Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator <(String ^ strNumber) const
{
  return (* this) < Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 逻辑大于或等于

bool Calculate::LargeDecimal::operator >=(Calculate::LargeDecimal & ldSecond) const
{
  return (* this) > ldSecond || (* this) == ldSecond;
}

bool Calculate::LargeDecimal::operator >=(int iNumber) const
{
  return (* this) >= Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator >=(long lNumber) const
{
  return (* this) >= Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator >=(float fNumber) const
{
  return (* this) >= Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator >=(double dNumber) const
{
  return (* this) >= Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator >=(String ^ strNumber) const
{
  return (* this) >= Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 逻辑小于或等于

bool Calculate::LargeDecimal::operator <=(Calculate::LargeDecimal & ldSecond) const
{
  return (* this) < ldSecond || (* this) == ldSecond;
}

bool Calculate::LargeDecimal::operator <=(int iNumber) const
{
  return (* this) <= Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator <=(long lNumber) const
{
  return (* this) <= Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator <=(float fNumber) const
{
  return (* this) <= Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator <=(double dNumber) const
{
  return (* this) <= Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator <=(String ^ strNumber) const
{
  return (* this) <= Calculate::LargeDecimal(strNumber);
}
#pragma endregion

#pragma region 逻辑等于

bool Calculate::LargeDecimal::operator ==(Calculate::LargeDecimal & ldSecond) const
{
  bool bFirstNegative = !this->bIsNegative;
  bool bSecondNegative = !ldSecond.bIsNegative;
  int i;
  if(bFirstNegative != bSecondNegative)
  {
    return false;
  }
  int iFirstSize = this->Integer.size();
  int iSecondSize = ldSecond.Integer.size();
  if(iFirstSize != iSecondSize)
  {
    return false;
  }
  for(i = 0; i < iFirstSize; i ++)
  {
    if(this->Integer[i] != ldSecond.Integer[i])
    {
      return false;
    }
  }
  iFirstSize = this->Decimal.size();
  iSecondSize = ldSecond.Decimal.size();
  if(iFirstSize != iSecondSize)
  {
    return false;
  }
  for(i = 0; i < iFirstSize; i ++)
  {
    if(this->Decimal[i] != ldSecond.Decimal[i])
    {
      return false;
    }
  }
  return true;
}

bool Calculate::LargeDecimal::operator ==(int iNumber) const
{
  int k = 0;
  if(this->lPoint != -1)
  {
    return false;
  }
  if(this->bIsNegative != (iNumber < 0 ? true : false))
  {
    return false;
  }
  do
  {
    if(this->Integer[this->Integer.size() - k - 1] != iNumber % (long)Math::Pow(10, k))
    {
      return false;
    }
    k ++;
  }while(iNumber);
  if(this->Integer.size() != 1)
  {
    return false;
  }
  return true;
}

bool Calculate::LargeDecimal::operator ==(long lNumber) const
{
  int k = 0;
  if(this->lPoint != -1)
  {
    return false;
  }
  if(this->bIsNegative != (lNumber < 0 ? true : false))
  {
    return false;
  }
  do
  {
    if(this->Integer[this->Integer.size() - k - 1] != lNumber % (long)Math::Pow(10, k))
    {
      return false;
    }
    k ++;
  }while(lNumber);
  if(this->Integer.size() != 1)
  {
    return false;
  }
  return true;
}

bool Calculate::LargeDecimal::operator ==(float fNumber) const
{
  return (* this) == Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator ==(double dNumber) const
{
  return (* this) == Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator ==(String ^ strNumber) const
{
  return (* this) == Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 逻辑不等于

bool Calculate::LargeDecimal::operator !=(Calculate::LargeDecimal & ldSecond) const
{
  return !(* this == ldSecond);
}

bool Calculate::LargeDecimal::operator !=(int iNumber) const
{
  return !(* this == iNumber);
}

bool Calculate::LargeDecimal::operator !=(long lNumber) const
{
  return !(* this == lNumber);
}

bool Calculate::LargeDecimal::operator !=(float fNumber) const
{
  return (* this) != Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator !=(double dNumber) const
{
  return (* this) != Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator !=(String ^ strNumber) const
{
  return (* this) != Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 自加运算符

// 后置
Calculate::LargeDecimal Calculate::LargeDecimal::operator ++(int)
{
  Calculate::LargeDecimal Data = * this;
  * this = * this + 1;
  return Data;
}

// 前置
Calculate::LargeDecimal Calculate::LargeDecimal::operator ++()
{
  * this = * this + 1;
  return * this;
}

#pragma endregion

#pragma region 自减运算符

// 前置
Calculate::LargeDecimal Calculate::LargeDecimal::operator --(int)
{
  Calculate::LargeDecimal Data = * this;
  * this = * this - 1;
  return Data;
}

// 后置
Calculate::LargeDecimal Calculate::LargeDecimal::operator --()
{
  * this = * this - 1;
  return * this;
}

#pragma endregion

#pragma region 负号运算符

Calculate::LargeDecimal Calculate::LargeDecimal::operator -() const
{
  if(* this == 0)
  {
    return 0;
  }
  Calculate::LargeDecimal Data;
  Data = * this;
  Data.bIsNegative = !this->bIsNegative;//负号取反
  return Data;
}

#pragma endregion

#pragma region 属性函数

std::vector<long>::size_type Calculate::LargeDecimal::Size()
{
  return this->Integer.size() + this->Decimal.size();
}

#pragma endregion

转载于:https://blog.51cto.com/starry/146250