• 大数计算：e^1000/300！

    1.问题：大数计算可能超出数据类型范围

    当单独计算 e^{1000}，因为 e^{1000} > e^{700} \approx 1.01432e304，double的最大取值为1.79769e+308，所以 e^{1000} 肯定超过了double的表示范围。

    同样，对于300！也是如此。

    那我们应该怎么去计算和存储结果呢？

    2.解决方案

    从数学角度出发，对于超级大的数，运算方式、运算规律等肯定保持不变的。

    很多时候，我们主要是利用相关的定理、公式进行简化或者极限处理。

    由于我项目里的精度要求不是很高，于是，可以采用相对宽松的方式解决这个问题：

    科学计数法！

    3.代码实现

    1. /*
    2. * @file     BigNumeric.hpp
    3. * @brief    模板类，用于大数计算，以科学计数法为实现形式，尾数部分有效位数12，指数部分完全准确.
    4. * 直接在工程中引入该hpp文件即可使用该类，重载了+-/*以及幂运算和开方等.
    5. * 由于指数部分采用的市 int ，故限制了本类使用时科学计数法的最大表示范围为：
    6. *                       a*10^2147483647 (-1.0<=a<=1.0)         
    7. **
    8. * @author   DongFengChuiLiu
    9. * @email    308021782@qq.com 
    10. * @version  1.0 
    11. * @date     2023/10/15
    12. */
    13.  
    14.  
    15. #ifndef __BigNumeric_h
    16. #define __BigNumeric_h
    17. #include 
    18. #include 
    19.  
    20.  
    21. template<typename _T>
    22. class BigNumeric
    23. {
    24. private:
    25.     _T mantissa;        //尾数
    26.     int exponent;       //指数
    27.  
    28. public:
    29.     BigNumeric(_T num)
    30.     {
    31.         if (num == (_T)0)
    32.         {
    33.             exponent = 0;
    34.             mantissa = 0;
    35.         }
    36.         else
    37.         {
    38.             exponent = std::floor(std::log10(std::abs(num)));
    39.             mantissa = num / std::pow(10.0, exponent);
    40.         }
    41.     }
    42.  
    43.     BigNumeric(_T mnt,int exp)
    44.     {
    45.         this->mantissa = mnt;
    46.         this->exponent = exp;
    47.     }
    48.  
    49.     ~BigNumeric() {}
    50.  
    51.     BigNumeric(const BigNumeric& other)
    52.     {
    53.         if (this == &other)
    54.             return;
    55.         this->exponent = other.exponent;
    56.         this->mantissa = other.mantissa;
    57.     }
    58.  
    59.     BigNumeric& operator=(const BigNumeric& other)
    60.     {
    61.         if(this == &other)
    62.             return *this;
    63.         this->exponent = other.exponent;
    64.         this->mantissa = other.mantissa;
    65.         return *this;
    66.     }
    67.  
    68. public:
    69.     //取 BigNumeric 对象的实际值
    70.     _T value()
    71.     {
    72.         if (this->exponent >= 308) return std::numeric_limits<_T>::infinity();
    73.         return this->mantissa * std::pow(10.0, this->exponent);
    74.     }
    75.  
    76.  
    77.     //乘法运算
    78.     // BigNumeric * BigNumeric
    79.     BigNumeric operator*(const BigNumeric opr)
    80.     {
    81.         BigNumeric<_T> resmnt(this->mantissa * opr.mantissa);
    82.         resmnt.exponent = CheckRange((_T)resmnt.exponent + this->exponent + opr.exponent);
    83.         return resmnt;
    84.     }
    85.     // BigNumeric * _T
    86.     BigNumeric operator*(const _T opr)
    87.     {
    88.         return *this * BigNumeric<_T>(opr);
    89.     }
    90.     //_T * BigNumeric
    91.     friend    BigNumeric operator*(const _T opr, BigNumeric opr1)
    92.     {
    93.         return opr1 * opr;
    94.     }
    95.  
    96.  
    97.     //除法
    98.     // BigNumeric / BigNumeric
    99.     BigNumeric operator/(const BigNumeric opr)
    100.     {
    101.         BigNumeric<_T> resmnt(this->mantissa / opr.mantissa);
    102.         resmnt.exponent = CheckRange((_T)resmnt.exponent + this->exponent - opr.exponent);
    103.         return resmnt;
    104.     }
    105.     // BigNumeric / _T
    106.     BigNumeric operator/(const _T opr)
    107.     {
    108.         return *this / BigNumeric<_T>(opr);
    109.     }
    110.     // _T / BigNumeric
    111.     friend     BigNumeric operator/(const _T opr, const BigNumeric opr1)
    112.     {
    113.         return BigNumeric<_T>(opr) / opr1;
    114.     }
    115.  
    116.  
    117.     //加法
    118.     // BigNumeric + BigNumeric
    119.     BigNumeric operator+(const BigNumeric opr)
    120.     {
    121.         if (this->exponent - opr.exponent > 15) return *this;
    122.         else if (this->exponent - opr.exponent < -15) return opr;
    123.         int min = this->exponent > opr.exponent ? opr.exponent : this->exponent;
    124.         BigNumeric<_T> resmnt(this->mantissa * std::pow(10.0, this->exponent - min) + opr.mantissa * std::pow(10.0, opr.exponent - min));
    125.         resmnt.exponent = CheckRange((_T)resmnt.exponent + min);
    126.         return resmnt;
    127.     }
    128.     // BigNumeric + _T
    129.     BigNumeric operator+(const _T opr)
    130.     {
    131.         return *this + BigNumeric<_T>(opr);
    132.     }
    133.     // _T + BigNumeric
    134.     friend    BigNumeric operator+(const _T opr, BigNumeric opr1)
    135.     {
    136.         return opr1 + opr;
    137.     }
    138.  
    139.  
    140.     //减法
    141.     // BigNumeric - BigNumeric
    142.     BigNumeric operator-(const BigNumeric opr)
    143.     {
    144.         return *this + BigNumeric<_T>(opr) * (-1.0);
    145.     }
    146.     // BigNumeric - _T
    147.     BigNumeric operator-(const _T opr)
    148.     {
    149.         return *this - BigNumeric<_T>(opr);
    150.     }
    151.     // _T - BigNumeric
    152.     friend    BigNumeric operator-(const _T opr, BigNumeric opr1)
    153.     {
    154.         return opr1 - opr;
    155.     }
    156.  
    157.  
    158.     //开方
    159.     // BigNumeric^0.5
    160.     BigNumeric Sqrt()
    161.     {
    162.         BigNumeric<_T> result(0.0);
    163.         _T bgnmant = std::sqrt(this->mantissa);
    164.         int bgnexp = this->exponent;
    165.         if (bgnexp % 2 == 0)
    166.         {
    167.             result.mantissa = bgnmant;
    168.             result.exponent = bgnexp / 2;
    169.         }
    170.         else
    171.         {
    172.             BigNumeric temp(bgnmant * std::sqrt(10.0));
    173.             result.mantissa = temp.mantissa;
    174.             result.exponent = temp.exponent + bgnexp / 2;
    175.         }
    176.         return result;
    177.     }
    178.  
    179.  
    180.     //幂
    181.     // BigNumeric^_T
    182.     BigNumeric Pow(_T exp)
    183.     {
    184.         BigNumeric temp(Vpow(this->mantissa, exp) * Vpow(10.0, this->exponent * (exp - (int)exp)));
    185.         temp.exponent = CheckRange((_T)temp.exponent + (_T)this->exponent * exp);
    186.         return temp;
    187.     }
    188.  
    189. public:
    190.     //整数阶乘 int!
    191.     static BigNumeric Factorial(const int opr)
    192.     {
    193.         if (opr < 0) return 1.0 / Factorial(-1.0 * opr + 1);
    194.         else if (opr == 0) return BigNumeric(1.0);
    195.         return Factorial(opr - 1) * opr;
    196.     }
    197.  
    198.  
    199.     //e指数幂运算 e^_T
    200.     static BigNumeric Epow(const _T exp)
    201.     {
    202.         BigNumeric res(1.0);
    203.         double e = 2.71828182845904523536;
    204.         if (exp <= 700) return BigNumeric(std::pow(e, exp));
    205.         int count = exp / 700;
    206.         BigNumeric bgn(std::pow(e, 700));
    207.         for (size_t i = 0; i < count; i++)
    208.             res = res * bgn;
    209.         BigNumeric bgn1(std::pow(e, exp - count * 700));
    210.         res = res * bgn1;
    211.         return res;
    212.     }
    213.     //e^BigNumeric
    214.     static BigNumeric Epow(const BigNumeric opr)
    215.     {
    216.         BigNumeric res(1.0);
    217.         double e = 2.71828182845904523536;
    218.         BigNumeric mnt(std::pow(e, opr.mantissa));
    219.         int count = std::abs(opr.exponent) > 1000 ? 1000 : std::abs(opr.exponent);
    220.         if (count == 0) return mnt;
    221.         if(opr.exponent < 0) res = mnt.Pow(0.1);
    222.         else res = mnt.Pow(10.0);
    223.         for (size_t i = 0; i < count - 1; i++)
    224.         {
    225.             if (opr.exponent < 0) res = res.Pow(0.1);
    226.             else res = res.Pow(10.0);
    227.         }        
    228.         return res;
    229.     }
    230.  
    231.  
    232.     //任意底数的幂运算 a^_T
    233.     static BigNumeric Vpow(const _T e, const _T exp)
    234.     {
    235.         BigNumeric res(1.0);
    236.         BigNumeric bgnmant(e);
    237.         int chk = bgnmant.exponent == 0 ? exp : CheckRange(exp * bgnmant.exponent);
    238.         if (chk <= 300) return BigNumeric(std::pow(e, exp));
    239.         int count = exp / 300;
    240.         BigNumeric bgn(std::pow(bgnmant.mantissa, 300));
    241.         for (size_t i = 0; i < count; i++)
    242.         {
    243.             res = res * bgn;
    244.             res.exponent = CheckRange(res.exponent + (_T)bgnmant.exponent * 300);
    245.         }
    246.         BigNumeric bgn1(std::pow(bgnmant.mantissa, exp - count * 300));
    247.         res = res * bgn1;
    248.         res.exponent = CheckRange(res.exponent + (_T)bgnmant.exponent * (exp - count * 300));
    249.         return res;
    250.     }
    251.  
    252. private:
    253.     //控制指数的值范围
    254.     static int CheckRange(const _T num)
    255.     {
    256.         if (num >= (_T)2147483647) return 2147483647;
    257.         else if( num <= (_T)-2147483648) return -2147483648;
    258.         return num;
    259.     }
    260. };
    261.  
    262. #endif // !__BigNumeric_h

    4.测试

    1. //测试代码
    2. #include "BigNumeric.hpp"
    3.  
    4.  
    5. int main() 
    6. {    
    7.     // 乘法测试
    8.     /*BigNumeric bignum(2.13e303);
    9.     BigNumeric bignum1(5e303);
    10.     BigNumeric res = bignum * bignum1;
    11.     res = bignum * 2;
    12.     res = 2 * bignum;
    13.     double t = res.value();*/
    14.  
    15.     // 除法测试
    16.     /*BigNumeric bignum(2.13e303);
    17.     BigNumeric bignum1(4.26e303);  
    18.     BigNumeric res = bignum1 / bignum;
    19.     res = 240.0 / bignum;
    20.     res = bignum / 2.13e302;*/
    21.  
    22.     //加法测试
    23.     /*BigNumeric bignum(987654321);
    24.     BigNumeric bignum1(9);
    25.     BigNumeric res(bignum + bignum1);
    26.     res = bignum + 9;
    27.     res = 9 + bignum;*/
    28.  
    29.  
    30.     //减法测试
    31.     /*BigNumeric bignum(987654321);
    32.     BigNumeric bignum1(9);
    33.     BigNumeric res(bignum - bignum1);
    34.     res = bignum - 9;
    35.     res = 987654321 - bignum;*/
    36.  
    37.  
    38.     //幂测试
    39.     /*BigNumeric bignum(2.15 * 1.0e303);
    40.     BigNumeric TMP = (bignum*54321).Sqrt();
    41.     BigNumeric TMP1 = (bignum * 54321).Pow(0.5);
    42.         
    43.     bignum  = BigNumeric(9.15);
    44.     BigNumeric TMP2 = bignum.Pow(400);
    45.     double t = TMP2.value();*/
    46.  
    47.     //阶乘测试
    48.     BigNumeric<double> bignum = BigNumeric<double>::Factorial(300);
    49.     BigNumeric<double> bignum1 = BigNumeric<double>::Epow(1000);
    50.     bignum = bignum1 / bignum;
    51.     double t = bignum.value();
    52.  
    53.     return 0;
    54. }

    结果：6.4369310844548986e-181，尾数部分有效位数为 12，指数部分完全准确。

  • 相关阅读:
    leetCode
    【博主推荐】SpringBoot API接口对数据库增删改查,路由,TOKEN,WebSocket完整版(附源码)
    Ag44团簇以及衍生团簇（银纳米团簇直径1-2nm）
    为什么都在说实时数据传输？
    基于 ApplicationEvent 实现事件监听（进阶篇）
    线程的概念及使用
    微信小程序 - - - - - 瀑布流效果实现
    TextView文字图片混排并添加点击事件监听，Textview里面的ImageSpan添加点击响应事件
    Oracle数据库从入门到精通系列之十二：段
    使用ChatGPT和MindShow一分钟生成PPT模板
  • 原文地址：https://blog.csdn.net/A_Pointer/article/details/133814946