爪哇 2博客
 爪哇 2博客

爪哇 中的幂函数

爪哇 中的幂函数用于获取第一个参数’的第二个论点的力量。
例如:
让’s表示您要计算2的幂4。

那 will be 2*2*2*2=16
在Java中,您可以通过以下方式实现:
数学 .pow(2,4)= 16

句法

1
2
3
 
上市 静态的 战俘 ( x, y)
 

范例:
让’在Java中使用幂函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
进口 爪哇 ..*;
 
上市 电源主 {
 
上市 静态的 虚空 主要 ([] args ) {
 
//打印2到幂4
系统 .. 打印 (“ 数学 .pow(2,4)=” + 数学 . 战俘 (2, 4));
//打印4.2到幂3
系统 .. 打印 (“ 数学 .pow(4.2,3)=” + 数学 . 战俘 (4.2,3));
   }
}
 

当您运行上述程序时,将获得以下输出:

数学 .pow(2,4)= 16.0
数学 .pow(4.2,3)= 74.08800000000001

如果要从幂函数返回整数,则需要将其显式转换为Integer。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
进口 爪哇 ..*;
 
上市 电源主 {
 
上市 静态的 虚空 主要 ([] args ) {
 
//打印2的幂
整型 i=( 整型 ) 数学 . 战俘 (2,4);
系统 .. 打印 (“ 数学 .pow(2,4)=” + i);
 
  }
}
 

当您运行上述程序时,将获得以下输出:

数学 .pow(2,4)= 16

内部工作

数学 .pow是Java中的本机方法,它是用c编写的。
让我为您提供Math.pow方法的源代码。

数学 .java

1
2
3
4
5
 
上市 静态的 战俘 ( a, b) {
返回 严格数学. 战俘 (a, b); //默认的impl。 严格数学的代表
}
 

因此,如果您在上面的代码中,Math.pow委托将调用StrictMath。
严格数学.java

1
2
3
 
上市 静态的 本机 战俘 ( a, b);
 

如您所见,它调用了本机方法。

jdk / src / share / 本机 / 爪哇 / 郎 / fdlibm / src / w_pow.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
#include“ fdlibm.h”
#ifdef __STDC__
         战俘 ( x, y)  / *包装纸战俘* /
#其他
         战俘 (x,y)                 / *包装纸战俘* /
         x,y;
#万一
{
#ifdef _IEEE_ LIBM
         返回   __ieee754_pow(x,y);
#其他
         z;
        z=__ieee754_pow(x,y);
         如果 (_LIB_VERSION == _IEEE_ || 伊斯南 (y)) 返回 z;
         如果 ( 伊斯南 (x)) {
             如果 (y == 0.0)
                 返回 __kernel_standard(x,y,42); / *战俘(NaN,0.0)* /
             其他
                 返回 z;
        }
         如果 (x == 0.0){
             如果 (y == 0.0)
                 返回 __kernel_standard(x,y,20); / *战俘(0.0,0.0)* /
             如果 ( 有限 (y)&&y<0.0)
                 返回 __kernel_standard(x,y,23); / * 战俘 (0.0,负)* /
             返回 z;
        }
         如果 (! 有限 (z)) {
             如果 ( 有限 (x)&& 有限 (y)) {
                 如果 ( 伊斯南 (z))
                     返回 __kernel_standard(x,y,24); / * 战俘 neg ** non-int * /
                 其他
                     返回 __kernel_standard(x,y,21); / *战俘溢出* /
            }
        }
         如果 (z == 0.0&& 有限 (x)&& 有限 (y))
             返回 __kernel_standard(x,y,22); / *战俘下溢* /
         返回 z;
#万一
}
 

jdk / src / share / 本机 / 爪哇 / 郎 / fdlibm / src / e_pow.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
#include“ fdlibm.h”
#ifdef __STDC__
静态的 const
#其他
静态的
#万一
bp [] = {1.0, 1.5,},
dp_h [] = { 0.0, 5.84962487220764160156e-01,}, / * 0x3FE2B803、0x40000000 * /
dp_l [] = { 0.0, 1.35003920212974897128e-08,}, / * 0x3E4CFDEB,0x43CFD006 * /
    =  0.0,
     =  1.0,
     =  2.0,
二 53   =  9007199254740992.0,  / * 0x43400000、0x00000000 * /
巨大     =   1.0e300 ,
    =  1.0e-300,
        / *用于(3/2)*(log(x)-2s-2 / 3 * s ** 3 * /
L1  =  5.99999999999994648725e-01, / * 0x3FE33333、0x33333303 * /
L2  =  4.28571428578550184252e-01, / * 0x3FDB6DB6,0xDB6FABFF * /
L3  =  3.33333329818377432918e-01, / * 0x3FD55555、0x518F264D * /
L4  =  2.72728123808534006489e-01, / * 0x3FD17460、0xA91D4101 * /
L5  =  2.30660745775561754067e-01, / * 0x3FCD864A,0x93C9DB65 * /
L6  =  2.06975017800338417784e-01, / * 0x3FCA7E28,0x4A454EEF * /
P1   =  1.66666666666666019037e-01, / * 0x3FC55555、0x5555553E * /
P2   = -2.77777777770155933842e-03, / * 0xBF66C16C,0x16BEBD93 * /
P3   =  6.61375632143793436117e-05, / * 0x3F11566A,0xAF25DE2C * /
P4   = -1.65339022054652515390e-06, / * 0xBEBBBD41,0xC5D26BF1 * /
P5   =  4.13813679705723846039e-08, / * 0x3E663769、0x72BEA4D0 * /
lg2  =  6.93147180559945286227e-01, / * 0x3FE62E42、0xFEFA39EF * /
lg2_h  =  6.93147182464599609375e-01, / * 0x3FE62E43,0x00000000 * /
lg2_l  = -1.90465429995776804525e-09, / * 0xBE205C61,0x0CA86C39 * /
=  8.0085662595372944372e-0017, / *-(1024-log2(ovfl + .5ulp))* /
cp     =  9.61796693925975554329e-01, / * 0x3FEEC709,0xDC3A03FD = 2 /(3ln2)* /
cp _h   =  9.61796700954437255859e-01, / * 0x3FEEC709,0xE0000000 =(float)cp * /
cp _l   = -7.02846165095275826516e-09, / * 0xBE3E2FE0,0x145B01F5 = cp _h 的尾部* /
ivln2    =  1.44269504088896338700e+00, / * 0x3FF71547、0x652B82FE = 1 / ln2 * /
ivln2_h   =  1.44269502162933349609e+00, / * 0x3FF71547,0x60000000 = 24b 1 / ln2 * /
ivln2_l   =  1.92596299112661746887e-08; / * 0x3E54AE0B,0xF85DDF44 = 1 / ln2尾部* /
#ifdef __STDC__
         __ieee754_pow( x, y)
#其他
         __ieee754_pow(x,y)
         x, y;
#万一
{
         z, 斧头 , z_h , z_l , p_h , p_l ;
         y1,t1,t2,r,s,t,u,v,w;
         整型 i0,i1,i,j,k, 伊辛 ,n;
         整型 x , HY , ix , y ;
         未签名 x , ly ;
        i0 = ((*( 整型 *)&)>>29)^1; i1=1-i0;
         x = __HI (x); x = __LO (x);
         HY = __HI (y); ly = __LO (y);
         ix = x &0x7fffffff;   y = HY &0x7fffffff;
    / * y == 零:x ** 0 = 1 * /
         如果 (( y | ly ) == 0) 返回 ;
    / * + -NaN返回x + y * /
         如果 ( ix > 0x7ff00000 || (( ix == 0x7ff00000)&&( x != 0)) ||
           y > 0x7ff00000 || (( y == 0x7ff00000)&&( ly != 0)))
                 返回 x+y;
    / *确定x时y是否为奇数int< 0
     * 伊辛 = 0      ... y不是整数
     * 伊辛 = 1       ... y is an odd 整型
     * 伊辛 = 2      ... y是一个偶数整数
     */
         伊辛   = 0;
         如果 ( x <0) {
             如果 ( y >=0x43400000) 伊辛 = 2; / *偶数y * /
             其他 如果 ( y >=0x3ff00000) {
                k = ( y >>20)-0x3ff;        / *指数* /
                 如果 (k>20) {
                    j = ly >>(52-k);
                     如果 ((j<<(52-k)) == ly ) 伊辛 = 2-(j&1);
                } 其他 如果 ( ly == 0) {
                    j = y >>(20-k);
                     如果 ((j<<(20-k)) == y ) 伊辛 = 2-(j&1);
                }
            }
        }
    / * y的特殊值* /
         如果 ( ly == 0) {
             如果 ( y == 0x7ff00000) {       / * y为+ -inf * /
                 如果 ((( ix -0x3ff00000)| x ) == 0)
                     返回   y - y;      / * inf ** +-1为NaN * /
                 其他 如果 ( ix >= 0x3ff00000)/ *(| x |>1)**+-inf = inf,0 */
                     返回 ( HY >=0)? y: ;
                 其他                     / *(| x |<1)**-,+ inf = inf,0 * /
                     返回 ( HY <0)?-y: ;
            }
             如果 ( y == 0x3ff00000) {        / * y是  +-1 */
                 如果 ( HY <0) 返回 /x; 其他 返回 x;
            }
             如果 ( HY == 0x40000000) 返回 X* x; / * y是  2 */
             如果 ( HY == 0x3fe00000) {        / * y是  0.5 */
                 如果 ( x >=0)       / * X>= +0 */
                 返回 sqrt (x);
            }
        }
         斧头    = 晶圆厂 (x);
    / * x的特殊值* /
         如果 ( x == 0) {
             如果 ( ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000){
                z = 斧头 ;                 / * x为+ -0,+-inf,+-1 * /
                 如果 ( HY <0) z = /z;     / * z =(1 / | x |)* /
                 如果 ( x <0) {
                     如果 ((( ix -0x3ff00000)| 伊辛 ) == 0) {
                        z = (z-z)/(z-z); / *(-1)**非整数为NaN * /
                    } 其他 如果 ( 伊辛 == 1)
                        z = -1.0*z;             / * (X<0)**奇数=-(| x | **奇数)* /
                }
                 返回 z;
            }
        }
        n = ( x >>31)+1;
     / * (X<0)**(非整数)为NaN * /
         如果 ((n| 伊辛 ) == 0) 返回 (x-x)/(x-x);
        s = ; / * s(结果的符号-ve ** odd)= -1 其他 = 1 * /
         如果 ((n|( 伊辛 -1)) == 0) s = -;/ *(-ve)**(奇数整数)* /
    / * | y |很大 */
         如果 ( y >0x41e00000) { / *如果| y |> 2**31 */
             如果 ( y >0x43f00000){  / *如果| y |>2 ** 64,必须为o / uflow * /
                 如果 ( ix <=0x3fefffff) 返回 ( HY <0)? 巨大* 巨大 : 小* ;
                 如果 ( ix >=0x3ff00000) 返回 ( HY >0)? 巨大* 巨大 : 小* ;
            }
        / *如果x不接近1,则上溢/下溢* /
             如果 ( ix <0x3fefffff) 返回 ( HY <0)? s * 巨大* 巨大 : s * 小* ;
             如果 ( ix >0x3ff00000) 返回 ( HY >0)? s * 巨大* 巨大 : s * 小* ;
        / *现在| 1-x |很小<= 2 **-20,足以计算
          log(x)x-x ^ 2/2 + x ^ 3 / 3-x ^ 4/4 * /
            t = 斧头 -;         / * t有20个尾随零* /
            w = ( t * t)*(0.5- t * (0.3333333333333333333333- t * 0.25));
            u = ivln2_h * t;      / * ivln2_h 具有21个信号。位* /
            v = t * ivln2_l - w * ivln2;
            t1 = u+v;
             __LO (t1) = 0;
            t2 = v-(t1-u);
        } 其他 {
             ss ,s2, s_h , s_l , t_h , t_l ;
            n = 0;
        / *注意次要数字* /
             如果 ( ix <0x00100000)
                { 斧* = 二 53; n -= 53; ix = __HI ( 斧头 ); }
            n   + = (( ix )>>20)-0x3ff;
            j  = ix &0x000fffff;
        / *确定间隔* /
             ix = j|0x3ff00000;          / *标准化ix * /
             如果 (j<= 0x3988E ) k=0;         / * | x |<sqrt(3/2) */
             其他 如果 (j< 0xBB67A ) k=1;     / * | x |<sqrt(3)   */
             其他 {k=0;n + = 1; ix -= 0x00100000;}
             __HI ( 斧头 ) = ix ;
        / *计算ss = s_h + s_1 =(x-1)/(x + 1)或(x-1.5)/(x + 1.5)* /
            u = 斧头 - bp [k];               / * bp [0] = 1.0,bp [1] = 1.5 * /
            v = /( 斧头 + bp [k]);
             ss = 你* v;
             s_h = ss ;
             __LO ( s_h ) = 0;
        / * t_h = 斧头 + bp [k]高* /
             t_h = ;
             __HI ( t_h )=(( ix >>1)|0x20000000)+0x00080000+(k<<18);
             t_l = 斧头 - ( t_h - bp [k]);
             s_l = v * ((u- s_h * t_h )- s_h * t_l );
        / *计算日志(ax)* /
            s2 = ss * ss ;
            r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
            r + = s_l * ( s_h + ss );
            s2  = s_h * s_h ;
             t_h = 3.0+s2+r;
             __LO ( t_h ) = 0;
             t_l = r-(( t_h -3.0)-s2);
        / * u + v = ss *(1 + ...)* /
            u = s_h * t_h ;
            v = s_l * t_h + t_l * ss ;
        / * 2 /(3log2)*(ss + ...)* /
             p_h = u+v;
             __LO ( p_h ) = 0;
             p_l = v-( p_h -u);
             z_h = cp _h * p_h ;             / * cp _h + cp _1 = 2 /(3 * log2)* /
             z_l = cp _l * p_h + p_l * cp + dp_l [k];
        / * log2(ax)=(ss + ..)* 2 /(3 * log2)= n + dp_h + z_h + z_1 * /
            t = ()n;
            t1 = ((( z_h + z_l )+ dp_h [k])+t);
             __LO (t1) = 0;
            t2 = z_l -(((t1-t)- dp_h [k])- z_h );
        }
    / *将y分成y1 + y2并计算(y1 + y2)*(t1 + t2)* /
        y1  = y;
         __LO (y1) = 0;
         p_l = (y-y1)*t1+ y * t2;
         p_h = y1*t1;
        z = p_l + p_h ;
        j = __HI (z);
        i = __LO (z);
         如果 (j>=0x40900000) {                            / * z>= 1024 */
             如果 (((j-0x40900000)|i) != 0)                   / *如果z> 1024 */
                 返回 s * 巨大* 巨大 ;                     / *溢出* /
             其他 {
                 如果 ( p_l +>z- p_h ) 返回 s * 巨大* 巨大 ;   / *溢出* /
            }
        } 其他 如果 ((j&0x7fffffff)>=0x4090cc00 ) {        / * z<= -1075 */
             如果 (((j-0xc090cc00)|i) != 0)           / * z< -1075 */
                 返回 s * 小* ;             / *下溢* /
             其他 {
                 如果 ( p_l <=z- p_h ) 返回 s * 小* ;      / *下溢* /
            }
        }
     / *
    *计算2 **(p_h + p_l )
     */
        i = j&0x7fffffff;
        k = (i>>20)-0x3ff;
        n = 0;
         如果 (i>0x3fe00000) {              / *如果| z | >0.5,设置n = [z + 0.5] * /
            n = j+(0x00100000>>(k+1));
            k = ((n&0x7fffffff)>>20)-0x3ff;     / * n为新k * /
            t = ;
             __HI (t) = (n&~(0x000fffff>>k));
            n = ((n&0x000fffff)|0x00100000)>>(20-k);
             如果 (j<0) n = -n;
             p_h -= t;
        }
        t = p_l + p_h ;
         __LO (t) = 0;
        u = t * lg2_h;
        v = ( p_l -(t- p_h ))*lg2+ t * lg2_l;
        z = u+v;
        w = v-(z-u);
        t  = z * z;
        t1  = z - t * (P1+ t * (P2+ t * (P3+ t * (P4+ t * P5))));
        r  = ( z * t1)/(t1-)-(w+ z * w);
        z  = -(r-z);
        j  = __HI (z);
        j + = (n<<20);
         如果 ((j>>20)<=0) z = 头皮 (z,n); / *次标准输出* /
         其他 __HI (z) + = (n<<20);
         返回 s * z;
}
 

那’关于Java中的电源功能的所有内容。

分享这个

作者

关注作者

相关文章

  • 9月28日

    爪哇 中的PI

    Pi是数学中的恒定值,代表浮点值3.1415。它主要用于几何中以计算面积,周长,体积等。如果您在学术界学习过几何,则您可能会知道使用Pi,例如计算面积需要此常数。在Java中,当我们[…]

  • 10月05日

    用Java计算圆柱体的总表面积

    在这篇文章中,我们将看到如何在Java中计算Cylinder的总表面积。圆柱体总表面积的计算公式为:圆柱体表面积= 2 *Π* r * r + 2 *Π* r * h其中r是圆柱体的半径,h是圆柱体的高度[…]

  • 10月05日

    用Java计算半球的总表面积

    在这篇文章中,我们将看到如何在Java中计算半球的总表面积。半球正好是球的一半。半球有许多实际的例子。您可以将地球分为两个半球,即北半球和南半球。计算半球总表面积的公式为:…]

  • 10月05日

    在Java中获取0到1之间的随机数

    在这篇文章中,我们将看到如何在Java中获得0到1之间的随机数。我们已经在Java中看到了随机数生成器。我们可以简单地使用Math.random()方法获取0到1之间的随机数。Math.random方法返回o(包括)到1(不包括)之间的双精度值。 [crayon-601e020dd778a474523490 /]当您运行上述程序时,[…]

  • 一月03

    爪哇 将double / float舍入到小数点后两位

    在这篇文章中,我们将看到如何在Java中将整数四舍五入到小数点后两位。有很多方法可以做到这一点。’通过几种方式。让’通过简单的示例了解每个对象。使用DecimalFormat您也可以使用DecimalFormat将数字四舍五入到小数点后两位。 [crayon-601e020dd784f519528926 /]输出:四舍五入(DecimalFormat)[…]

  • 一月03

    如何在Java中获取数字的平方根

    在本教程中。我们将看看如何在Java中获取数字的平方根。在Java中获得数字的平方根非常简单。您可以简单地使用数学’s sqrt ()方法来计算数字的平方根。语法[crayon-601e020dd7d19227209328 /]返回类型返回数字的平方根。 [的平方根…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇 2博客