2019独角兽企业重金招聘Python工程师标准>>>   
                                        
                                                
         double n = 2;//底数
          double m = x；//指数
          double value = Math.log(m) / Math.log(n);
                                                    

                                                        





                                        
                                            
转载于:https://my.oschina.net/huangguangsheng/blog/1591480

引言
我在上一篇随笔中介绍了计算自然对数的快速算法。现在我们来看看计算指数函数的算法。我们知道，指数函数 ex 可以展开为泰勒级数：
这个级数对全体实数 x 都收敛，并且在 x 接近零时收敛得比较快。
实现该算法的 C# 程序
根据前面所述的 ex 的泰勒级数展开式，可以写出以下 C# 程序来为 decimal 数据类型添加一个 Exp 扩展方法：
1 usingSystem;2
3 namespaceSkyiv.Extensions4 {5   static classDecimalExtensions6 {7     static readonly decimal expmax = 66.542129333754749704054283659m;8     static readonly int[] mask = { 1, 2, 4, 8, 16, 32, 64};9     static readonly decimal[] exps =
10 {11       2.71828182845904523536028747135m, //exp(1)
12       7.38905609893065022723042746058m, //exp(2)
13       54.5981500331442390781102612029m, //exp(4)
14       2980.95798704172827474359209945m, //exp(8)
15       8886110.52050787263676302374078m, //exp(16)
16       78962960182680.6951609780226351m, //exp(32)
17       6235149080811616882909238708.93m  //exp(64)
18 };19
20     public static decimal Exp(this decimalx)21 {22       if (x > expmax) throw new OverflowException("overflow");23       if (x < -66) return 0;24       var n = (int)decimal.Round(x);25       if (n > 66) n--;26       decimal z = 1, y = Exponential(x -n);27       for (int m = (n < 0) ? -n : n, i = 0; i < mask.Length; i++)28         if ((m & mask[i]) != 0) z *=exps[i];29       return (n < 0) ? (y / z) : (y *z);30 }31
32     static decimal Exponential(decimalq)33     { //q (almost) in [ -0.5, 0.5 ]
34       decimal y = 1, t =q;35       for (var i = 1; t != 0; t *= q / ++i) y +=t;36       returny;37 }38 }39 }
简要说明如下：
第 7 行的 expmax 的值是 decimal.MaxValue 的自然对数的近似值，用于检测 Exp 方法是否溢出(第 22 行)。
第 20 至 30 行的 Exp 扩展方法就是用来计算指数函数了。
该方法利用 ex+y = exey 这个公式，将参数 x 分为整数部分 n 和小数部分 x - n 来计算。
整数部分 n 又分解为 1、2、4、8、16、32、 64 诸数中某些的和，利用事先计算出来的常量来计算。
第 25 行是为了防止将 e66.5421 分解为 e67e-0.4579，这样在计算 e67 时会溢出。而是分解为 e66e0.5421。
第 32 至 37 行的 Exponential 方法使用泰勒级数来计算 ex 。它的参数 q 越接近于零就计算得越快。
这个算法还是很快的，第 35 行的 for 循环执行次数不会超过 22 次。
测试程序
下面就是调用 decimal 数据类型的 Exp 扩展方法的测试程序：
1 usingSystem;2 usingSkyiv.Extensions;3
4 classTester5 {6   static voidMain()7 {8     try
9 {10       foreach (var x in new decimal[] {11         -100, -66, -65, -1, 0, 1, 2.5m, 16, 66.5421m, 67})12         Console.WriteLine("{0,-30}: exp({1})", x.Exp(), x);13 }14     catch(Exception ex) { Console.WriteLine(ex.Message); }15 }16 }
运行结果如下所示：
work$ dmcs Tester.cs DecimalExtensions.cs
work$ mono Tester.exe
0                             : exp(-100)
0.0000000000000000000000000000: exp(-66)
0.0000000000000000000000000001: exp(-65)
0.3678794411714423215955237702: exp(-1)
1                             : exp(0)
2.7182818284590452353602874714: exp(1)
12.182493960703473438070175950: exp(2.5)
8886110.520507872636763023741 : exp(16)
79225838488862236701995526357 : exp(66.5421)
overflow
可以看出，在计算 e67 时发现了溢出。这是因为：
decimal.MaxValue = 79,228,162,514,264,337,593,543,950,335
e67 = 125,236,317,084,221,378,051,352,196,074.4365767534885274 ...
可以看出，e67 已经超过 decimal 的最大值了。
事先计算的常数
在 DecimalExtensions.cs 程序的第 9 至 18 行中的 exps 静态只读数组中存放了 e1、e2、e4、e8、e16、e32 和 e64 的值。这些值是如何得到的呢？这很简单，Linux 操作系统中有一个高精度计算器 bc 。我们可以先编辑一个如下内容的文本文件 exps_in.txt：
scale=30
e(1)
e(2)
e(4)
e(8)
e(16)
e(32)
e(64)
l(2^96-1)
quit
上面的 e 代表 exp，l 代表 ln，296 - 1 就是 decimal.MaxValue。然后执行以下命令：
work$ bc -l exps_in.txt > exps_out.txt
就可以得出如下内容的输出 exps_out.txt：
2.718281828459045235360287471352
7.389056098930650227230427460575
54.598150033144239078110261202860
2980.957987041728274743592099452888
8886110.520507872636763023740781450350
78962960182680.695160978022635108224219956195
6235149080811616882909238708.928469744831391846235799914388
66.542129333754749704054283659972
稍加整理，就可以用在上述 C# 程序中了：
前 7 行就是 e 的各次幂。
最后一行就是 decimal.MaxValue 的自然对数。

    /**
     * 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
     */
    public static void testGetExponentOfNum() {

        double base = Math.random();
        int exponent = new Random().nextInt(5);
        System.out.println("testGetExponentOfNum--base=" + base+"--exponent="+exponent);
        if (exponent == 0) {
            System.out.println("testGetExponentOfNum--0--result=" + 1);
        } else if (exponent == 1) {
            System.out.println("testGetExponentOfNum--1--result=" + base);
        } else if (exponent > 1) {
            double num = base;
            for (int i = 2; i <= exponent; i++) {
                num = num * base;
            }
            System.out.println("testGetExponentOfNum-->1--result=" + num);
        } else {
            System.out.println("testGetExponentOfNum error");
        }
        System.out.println("testGetExponentOfNum use Api result="+Math.pow(base,exponent));
    }
写完以后突然发现上面的代码没有考虑base 与 exponent可能为负数的情况。
    /**
     * 给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
     */
    public static void testGetExponentOfNum01() {
        double base = Math.random() * (new Random().nextInt(1) > 0 ? 1 : -1);
        int exponent = new Random().nextInt(5) * (new Random().nextInt(1) > 0 ? 1 : -1);
        double result = 1;
        System.out.println("testGetExponentOfNum--base=" + base + "--exponent=" + exponent);
        if(base == 0){
            System.out.println("testGetExponentOfNum--base == 0");
            return;
        }
        if (exponent == 0) {
            System.out.println("testGetExponentOfNum--[=0]--result=" + 1);
            return;
        } else if (exponent > 0) {
            result = base;
            for (int i = 2; i <= exponent; i++) {
                result = result * base;
            }
            System.out.println("testGetExponentOfNum--[>0]--result=" + result);
        } else {
            result = base;
            for (int i = 2; i <= Math.abs(exponent); i++) {
                result = result * base;
            }
            result = 1 / result;
            System.out.println("testGetExponentOfNum--[<0]--result=" + result);
        }

        System.out.println("testGetExponentOfNum use Api result=" + Math.pow(base, exponent));
    }


RESULT
12-15 20:08:29.977 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--base=-0.7797871217121436--exponent=-3
12-15 20:08:29.977 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--[<0]--result=-2.1089769082499257
12-15 20:08:29.977 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum use Api result=-2.1089769082499257
12-15 20:08:29.977 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum==========
12-15 20:08:32.400 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--base=-0.7498661439578588--exponent=-3
12-15 20:08:32.400 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--[<0]--result=-2.3716399771135768
12-15 20:08:32.400 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum use Api result=-2.3716399771135768
12-15 20:08:32.400 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum==========
12-15 20:08:33.991 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--base=-0.23920783483769525--exponent=-2
12-15 20:08:33.991 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--[<0]--result=17.476288271069706
12-15 20:08:33.991 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum use Api result=17.476288271069706
12-15 20:08:33.991 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum==========
12-15 20:08:35.715 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--base=-0.12243023418032972--exponent=0
12-15 20:08:35.715 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum--[=0]--result=1
12-15 20:08:35.715 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum use Api result=1.0
12-15 20:08:35.715 20837-20837/com.example.bxh.sayhello I/System.out: testGetExponentOfNum==========


====如果有错误，请指正====

在Java中，当我们计算2的n次方时，可以直接用Math.pow来计算。非常方便。
但是，已知一个幂的结果为M和幂的底数a , 现在要求幂的指数n。Math中提供的有log(double)方法，但是只能传入一个参数，即M。那么问题来了，如何简单、方便、快捷的达到我们的要求呢？ 答案如下：
    n = Math.log(M) / Math.log(a) ;