「java几次幂」java中几次方

admin 2023-03-20 23:48:09 566

今天给各位分享java几次幂的知识，其中也会对java中几次方进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、Java中怎样怎样算出求函数的幂次方？
2、Java Math类中的新功能，第1 部分:实数
3、java 中数据的几次方怎么弄啊
4、用java编写程序计算x的n次幂
5、java中一个数的n次方应该怎么写？

Java中怎样怎样算出求函数的幂次方？

java中通常进行数学运算的东西都在Math类中，求函数的幂次方就是Math类中的pow方法：public static double pow(double a, double b)，返回第一个参数的第二个参数次幂的值。

例如求2的3次方，代码如下：

public class test {

public static void main(String[] args) {

double a= Math.pow(2, 3);

}

运行结果为8

扩展资料：

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

与 StrictMath 类的某些数学方法不同，并非 Math 类所有等价函数的实现都定义为返回逐位相同的结果。此类在不需要严格重复的地方可以得到更好的执行。

默认情况下，很多 Math 方法仅调用 StrictMath 中的等价方法来完成它们的实现。建议代码生成器使用特定于平台的本机库或者微处理器指令（可用时）来提供 Math 方法更高性能的实现。这种更高性能的实现仍然必须遵守 Math 的规范。

实现规范的质量涉及到两种属性，即返回结果的准确性和方法的单调性。浮点 Math 方法的准确性根据 ulp（units in the last place，最后一位的进退位）来衡量。对于给定的浮点格式，特定实数值的 ulp 是包括该数值的两个浮点值的差。

当作为一个整体而不是针对具体参数讨论方法的准确性时，引入的 ulp 数用于任何参数最差情况下的误差。

如果一个方法的误差总是小于 0.5 ulp，那么该方法始终返回最接近准确结果的浮点数；这种方法就是正确舍入。一个正确舍入的方法通常能得到最佳的浮点近似值；然而，对于许多浮点方法，进行正确舍入有些不切实际。

相反，对于Math 类，某些方法允许误差在 1 或 2 ulp 的范围内。非正式地，对于 1 ulp的误差范围，当准确结果是可表示的数值时，应该按照计算结果返回准确结果；否则，返回包括准确结果的两个浮点值中的一个。对于值很大的准确结果，括号的一端可以是无穷大。

除了个别参数的准确性之外，维护不同参数的方法之间的正确关系也很重要。

因此，大多数误差大于 0.5 ulp 的方法都要求是半单调的：只要数学函数是非递减的，浮点近似值就是非递减的；同样，只要数学函数是非递增的，浮点近似值就是非递增的。并非所有准确性为 1 ulp 的近似值都能自动满足单调性要求。

参考资料：

Java Math类中的新功能，第1 部分:实数

摘要在这篇由两部分组成的文章中 Elliotte Rusty Harold 与您一起探讨经典 java lang Math 类中的新功能第部分主要讨论比较单调的数学函数第部分将探讨专为操作浮点数而设计的函数

有时候您会对一个类熟悉到忘记了它的存在如果您能够写出 java lang Foo 的文档那么 Eclipse 将帮助您自动完成所需的函数您无需阅读它的 Javadoc 例如我使用 java lang Math（一个我自认为非常了解的类）时就是这样但令我吃惊的是我最近偶然读到它的 Javadoc —— 这可能是我近五年来第一次读到我发现这个类的大小几乎翻了一倍包含种我从来没听说过的新方法看来我要对它另眼相看了

Java# ;语言规范第版向 java lang Math（以及它的姊妹版 java lang StrictMath）添加了种新方法 Java 又添加了种在本文中我重点讨论其中的比较单调的数学函数如 log 和 cosh 在第部分我将探讨专为操作浮点数（与抽象实数相反）而设计的函数

抽象实数（如 π 或）与 Java double 之间的区别很明显首先数的理想状态是具有无限的精度而 Java 表示法把数限制为固定位数在处理非常大和非常小的数时这点很重要例如（二十亿零一）可以精确表示为一个 int 而不是一个 float 最接近的浮点数表示形式是 E — 即两亿使用 double 数会更好因为它们的位数更多（这是应该总是使用 double 数而不是 float 数的理由之一）但它们的精度仍然受到一定限制

计算机算法（Java 语言和其他语言的算法）的第二个限制是它基于二进制而不是十进制 / 和 / 之类的分数可用十进制精确表示（分别是和）但用二进制表示时就会出现重复的分数如同 / 在用十进制表示时就会变为 ……以为基数任何分母仅包含质数因子和的分数都可以精确表示以为基数则只有分母是的乘方的分数才可以精确表示 / / / / 等

这种不精确性是迫切需要一个 math 类的最主要的原因之一当然您可以只使用标准的 + 和 * 运算符以及一个简单的循环来定义三角函数和其他使用泰勒级数展开式的函数如清单所示

清单使用泰勒级数计算正弦

public class SineTaylor { public static void main(String[] args) { for (double angle = ; angle = *Math PI; angle += Math PI/ ) { System out println(degrees(angle) + \t + taylorSeriesSine(angle) + \t + Math sin(angle)); } } public static double degrees(double radians) { return * radians/ Math PI; } public static double taylorSeriesSine(double radians) { double sine = ; int sign = ; for (int i = ; i ; i+= ) { sine += Math pow(radians i) * sign / factorial(i); sign *= ; } return sine; } private static double factorial(int i) { double result = ; for (int j = ; j = i; j++) { result *= j; } return result; }}

开始运行得不错只有一点小的误差如果存在误差的话也只是最后一位小数不同

但是随着角度的增加误差开始变大这种简单的方法就不是很适用了

这里使用泰勒级数得到的结果实际上比我想像的要精确但是随着角度增加到度度（ pi 弧度）以及更大时泰勒级数就逐渐需要更多条件来进行准确计算 java lang Math 使用的更加完善的算法就避免了这一点

泰勒级数的效率也无法与现代桌面芯片的内置正弦函数相比要准确快速地计算正弦函数和其他函数需要非常仔细的算法专门用于避免无意地将小的误差变成大的错误这些算法一般内置在硬件中以更快地执行例如几乎每个在最近年内组装的 X 芯片都具有正弦和余弦函的硬件实现 X VM 只需调用即可不用基于较原始的运算缓慢地计算它们 HotSpot 利用这些指令显著加速了三角函数的运算

直角三角形和欧几里德范数

每个高中学生都学过勾股定理在直角三角形中斜边边长的平方等于两条直角边边长平方之和即 c = a + b

学习过大学物理和高等数学的同学会发现这个等式会在很多地方出现不只是在直角三角形中例如 R 的平方二维向量的长度三角不等式等都存在勾股定理（事实上这些只是看待同一件事情的不同方式重点在于勾股定理比看上去要重要得多）

Java 添加了 Math hypot 函数来精确执行这种计算这也是库很有用的一个出色的实例证明原始的简单方法如下

public static double hypot(double x double y){ return x*x + y*y;}

实际代码更复杂一些如清单所示首先应注意的一点是这是以本机 C 代码编写的以使性能最大化要注意的第二点是它尽力使本计算中出现的错误最少事实上应根据 x 和 y 的相对大小选择不同的算法

清单实现 Math hypot

的实际代码/** ====================================================* Copyright (C) by Sun Microsystems Inc All rights reserved ** Developed at SunSoft a Sun Microsystems Inc business * Permission to use copy modify and distribute this* sofare is freely granted provided that this notice * is preserved * ====================================================*/#include fdlibm h #ifdef __STDC__ double __ieee _hypot(double x double y)#else double __ieee _hypot(x y) double x y;#endif{ double a=x b=y t t y y w; int j k ha hb; ha = __HI(x) x fffffff; /* high word of x */ hb = __HI(y) x fffffff; /* high word of y */ if(hb ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;} __HI(a) = ha; /* a |a| */ __HI(b) = hb; /* b |b| */ if((ha hb) x c ) {return a+b;} /* x/y ** */ k= ; if(ha x f ) { /* a ** */ if(ha = x ff ) { /* Inf or NaN */ w = a+b; /* for sNaN */ if(((ha xfffff)|__LO(a))== ) w = a; if(((hb^ x ff )|__LO(b))== ) w = b; return w; } /* scale a and b by ** */ ha = x ; hb = x ; k += ; __HI(a) = ha; __HI(b) = hb; } if(hb x b ) { /* b ** */ if(hb = x fffff) { /* subnormal b or */ if((hb|(__LO(b)))== ) return a; t = ; __HI(t ) = x fd ; /* t = ^ */ b *= t ; a *= t ; k = ; } else { /* scale a and b by ^ */ ha += x ; /* a *= ^ */ hb += x ; /* b *= ^ */ k = ; __HI(a) = ha; __HI(b) = hb; } } /* medium size a and b */ w = a b; if (wb) { t = ; __HI(t ) = ha; t = a t ; w = sqrt(t *t (b*( b) t *(a+t ))); } else { a = a+a; y = ; __HI(y ) = hb; y = b y ; t = ; __HI(t ) = ha+ x ; t = a t ; w = sqrt(t *y (w*( w) (t *y +t *b))); } if(k!= ) { t = ; __HI(t ) += (k ); return t *w; } else return w;}

实际上是使用这种特定函数还是几个其他类似函数中的一个取决于平台上的 JVM 细节不过这种代码很有可能在 Sun 的标准 JDK 中调用（其他 JDK 实现可以在必要时改进它）

这段代码（以及 Sun Java 开发库中的大多数其他本机数学代码）来自 Sun 约年前编写的开源 fdlibm 库该库用于精确实现 IEE 浮点数能进行非常准确的计算不过会牺牲一些性能

以为底的对数

对数说明一个底数的几次幂等于一个给定的值也就是说它是 Math pow（）函数的反函数以为底的对数一般出现在工程应用程序中以 e为底的对数（自然对数）出现在复合计算以及大量科学和数学应用程序中以为底的对数一般出现在算法分析中

从 Java 开始 Math 类有了一个自然对数也就是给定一个参数 x 该自然对数返回 e 的几次幂等于给定的值 x 遗憾的是 Java 语言的（以及 C Fortran 和 Basic 的）自然对数函数错误命名为 log（）在我读的每本数学教材中 log 都是以为底的对数而 ln 是以 e 为底的对数 lg 是以为底的对数现在已经来不及修复这个问题了不过 Java 添加了一个 log （）函数它是以为底而不是以 e 为底的对数

清单是一个简单程序它输出整数到的以和 e 为底的对数

清单到的各种底数的对数

public static void main(String[] args) { for (int i = ; i = ; i++) { System out println(i + \t + Math log (i) + \t + Math log(i) + \t + lg(i)); } }

public static double lg(double x) { return Math log(x)/Math log( ); }}

下面是前行结果

Math log （）能正常终止对数函数执行或任何负数的对数返回 NaN

立方根

我不敢说我的生活中曾经需要过立方根我也不是每天都要使用代数和几何的少数人士之一更别提偶然涉足微积分微分方程甚至抽象代数因此下面这个函数对我毫无用处尽管如此如果意外需要计算立方根现在就可以了 — 使用自 Java 开始引入的 Math cbrt（）方法清单通过计算到之间的整数的立方根进行了演示

清单到的立方根

public class CubeRoots { public static void main(String[] args) { for (int i = ; i = ; i++) { System out println(Math cbrt(i)); } }}

下面是结果

结果显示与平方根相比立方根拥有一个不错的特性每个实数只有一个实立方根这个函数只在其参数为 NaN 时才返回 NaN

双曲三角函数

双曲三角函数就是对曲线应用三角函数也就是说想象将这些点放在笛卡尔平面上来得到 t 的所有可能值

x = r cos(t)y = r sin(t)

您会得到以 r 为半径的曲线相反假设改用双曲正弦和双曲余弦如下所示

x = r cosh(t)y = r sinh(t)

则会得到一个正交双曲线原点与它最接近的点之间的距离是 r

还可以这样思考其中 sin（x）可以写成（ei x e i x）/ cos（x）可以写成（ei x + e i x）/ 从这些公式中删除虚数单位后即可得到双曲正弦和双曲余弦即 sinh（x） = （e x e x）/ cosh（x） = （e x + e x）/

Java 添加了所有这三个函数 sh（） Math sinh（）和 Math tanh（）还没有包含反双曲三角函数 — 反双曲余弦反双曲正弦和反双曲正切

实际上 cosh（z）的结果相当于一根吊绳两端相连后得到的形状即悬链线清单是一个简单的程序它使用 sh 函数绘制一条悬链线

清单使用 sh（）绘制悬链线

import java awt *;

public class Catenary extends Frame {

private static final int WIDTH = ; private static final int HEIGHT = ; private static final double MIN_X = ; private static final double MAX_X = ; private static final double MAX_Y = ;

private Polygon catenary = new Polygon();

public Catenary(String title) { super(title); setSize(WIDTH HEIGHT); for (double x = MIN_X; x = MAX_X; x += ) { double y = sh(x); int scaledX = (int) (x * WIDTH/(MAX_X MIN_X) + WIDTH/ ); int scaledY = (int) (y * HEIGHT/MAX_Y); // in puter graphics y extends down rather than up as in // Caretesian coordinates so we have to flip scaledY = HEIGHT scaledY; catenary addPoint(scaledX scaledY); } }

public static void main(String[] args) { Frame f = new Catenary( Catenary ); f setVisible(true); }

public void paint(Graphics g) { g drawPolygon(catenary); }

}

图为绘制的曲线

图笛卡尔平面中的一条悬链曲线

双曲正弦双曲余弦和双曲正切函数也会以常见或特殊形式出现在各种计算中

符号

Math signum 函数将正数转换为将负数转换为仍然是实际上它只是提取一个数的符号在实现 Comparable 接口时这很有用

一个 float 和一个 double 版本可用来维护这种类型这个函数的用途很明显即处理浮点运算 NaN 以及正和负的特殊情况 NaN 也被当作正和负应该返回正和负例如假设如清单那样用简单的原始方法实现这个函数

清单存在问题的 Math signum 实现

public static double signum(double x) { if (x == ) return ; else if (x ) return ; else return ;}

首先这个方法会将所有负转换为正（负可能不好理解但它确实是 IEEE 规范的必要组成部分）其次它会认为 NaN 是正的实际实现如清单所示它更加复杂而且会仔细处理这些特殊情况

清单实际的正确的 Math signum 实现

public static double signum(double d) { return (d == || isNaN(d))?d:copySign( d);}

public static double copySign(double magnitude double sign) { return rawCopySign(magnitude (isNaN(sign)? d:sign));}

public static double rawCopySign(double magnitude double sign) { return Double longBitsToDouble((Double doubleToRawLongBits(sign) (DoubleConsts SIGN_BIT_MASK)) | (Double doubleToRawLongBits(magnitude) (DoubleConsts EXP_BIT_MASK | DoubleConsts SIGNIF_BIT_MASK)));}

事半功倍

最有效的代码是从您未编写过的代码不要做专家们已经做过的事情使用 java lang Math 函数（新的和旧的）的代码将更快更有效而且比您自己编写的任何代码都准确所以请使用这些函数

java 中数据的几次方怎么弄啊

JAVA 有提供次方运算, 您可以参考java.lang.Math pow( )用法: static pow(double a, double b) 例如: 求取3 的5 次方则写成 Math.pow(3, 5) , 将会得到 243.0

用java编写程序计算x的n次幂

import java.util.Scanner;

* 用java编写程序计算x的n次幂

* */

public class Test40003 {

public static void main(String[] args) {

int repeat;//定义要幂次

//int i, n;

double x, mypow=1;

Scanner in=new Scanner(System.in);//从控制台输入数字，比如 2 1.5，

//前面是整数，后面是要做幂次运算的数，中间用空格隔开

repeat=in.nextInt();//获取输入的幂次

x=in.nextDouble();//获取要进行幂次运算的数

System.out.println("现在要做"+x+"的"+repeat+"次幂运算！");

for(int ri=1; ri=repeat; ri++){

mypow = mypow*x;

}

System.out.println(x+"的"+repeat+"次幂运算的结果是："+mypow);

}

java中一个数的n次方应该怎么写？

public class Test {

public static void main(String[] args){

double m = 2;

double n = 3;

使用API，Math.pow(double m,double n) -- 'm' 的 'n' 次方

System.out.println("使用API：" + Math.pow(m, n));

通过两种回圈实现的 'm' 的 'n' 次方

System.out.println("使用while实现：" + MToThePowerOfNByWhile(m,n));

System.out.println("使用for实现：" + MToThePowerOfNByFor(m,n));

}

public static double MToThePowerOfNByWhile(double m,double n)

{

double result = 1;

while(n 0)

{

result *= m;

n--;

}

return result;

}

public static double MToThePowerOfNByFor(double m,double n)

{

double result = 1;

for(int i = 0;in;i++)

{

result *= m;

}

return result;

}

java 中一个数的n次方怎么写– 智联问道

Math.pow(double m, double n)

是求m的n次方的

你也可以用回圈实现^_^

望采纳~

一个数的n次方怎样搜寻怎样开一个数的n次方

用Excel表格在空格里输入 =a^n。

3的2次方:就是3x3=9 3的3次方:就是3x3x3=27 几次方，就乘几个相同的数

怎么求一个数的N次方和另外一个数的N次方的差？

2^17-2^13

=2^13×2^4-2^13(把2^17拆成2^13×2^4格式)

=2^13（2^4-1）

你这题出的有点难。考试卷上应该很少能出现这种题。

这样讲明白吗？如果不明白给我空间发信息。我大二，经常线上。或者在百度hi加我为好友。随时解答

一个数的n次方怎么打?

你好：

a的b次方，在电脑用a^b表示

祝愉快！

一个数的N次方怎么算

约等于0,这个需要一个判断标准.

比如要求前6位小数都是0的时候可以看做约等于0,那么就是4100*0.06^n0.000001

0.06^n0.000001/4100

0.06^n2.44*10^(-10)

由于0.061,log0.06x是减函式.

所以由0.06^n2.44*10^(-10),

可知nlog0.06(2.44*10^(-10))

则n7.86,则N=8.

计算可知,4100*6%^8=0.00000068864256,小数点后有6个0,可以约等于0.

其他的演算法都是一样的,先找到到底多少位是0就可以约等于0,然后一步一步计算

一个数的0.5次方应该怎么算？譬如：2

一个数的0.5次方就是2分之1次方，也就是开2次根号

2的0.5次方=√2

一个数的的小数次方应该怎么算

a^(1/n)就是对a开n次根号

而如果不能化为1/n次方的话

就先化为a^(m/n) 次方

得到结果为(a^m)^(1/n)

即先进行m次方，再开n次方

一个数的的小数次方应该怎么算呢？

这么举个例子吧，一个数的0.5次方就是开2次根号

java几次幂的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java中几次方、java几次幂的信息别忘了在本站进行查找喔。

标签：java几次幂