使用 Java 开发移动设备应用程序时 可能需要用到特定 Java VM 所没有的数学方法 本文将专门解决 Java ME 没有 幂 方法 Math pow() 的问题 我们将演示使用三种不同的方法开发同一个 ME 应用程序 并从中选出最佳的编程解决方案
创新互联公司主营高港网站建设的网络公司,主营网站建设方案,app开发定制,高港h5重庆小程序开发搭建,高港网站营销推广欢迎高港等地区企业咨询
要讨论此问题 我们先考察整数和分数幂参数 将我们的分析限于正实数 我们将演示求整数问题和小数问题的解集相对而言比较容易（而不考虑指数的符号） 在大多数情况下 我们将使用示例问题 n = / 其中我们会求出 n 的良好估计或实际解 如果初始指数事先不可用 则此问题的其他解（包括牛顿法和割线法）不易编程 虽然二分法是可行的解决方案 但我们将关注传统上不为人所探究的三个方法 第一个是简单的（不过有时效率低下）几何衰变算法 而第二个方法将利用 Math sqrt() 方法并保证在不超过 次迭代中收敛到一个近似解 第三个方法将使用泰勒级数逼近法求对数并对泰勒级数进行欧拉转换
产生整数解的 ME Math pow() 方法
传统上 Java Math pow() 方法包含两个参数 这两个参数包括底数和指数 我们假定（最初）这两个参数均为整数 然后求出 ME 中与 Java 方法使用相同参数的 Math pow() 方法的可编程解 此处 可编程解相当简单 如示例 所示 在本例中 我们仅运行以指数值为指标的倍乘循环
示例
int pow( int x int y) /*we define the power method with base x and power y (i e x^y)*/ { int z = x; for( int i = ; i y; i++ )z *= x; return }
当然 有人可能会发现需要求出非整数幂的值 正实数的简单解（无需访问 Math pow() 方法）可能涉及使用 Math log() 例如 请考虑 / 的情况 利用 / *ln( ) = 中自然对数的结果 要得到最终解 需要利用指数 （特别指出 e = ） 在这种情况下 可能不需要使用幂函数 遗憾的是 Java ME 也不支持 Math log() 方法 没有 Math pow() 或 Math log() 方法时 我们会考虑使用朴素的 强力 试探性方法 应用 Math sqrt() 方法以及自然对数（和欧拉 e）的泰勒级数逼近来求得 Java ME 问题的解
使用几何衰变算法作为强力解的 ME Math pow()
Java ME 的早期实现包括浮点主数据类型 float 和 double 最近 已添加了这些类型 现在我们将 Math pow() 声明中的整型参数替换为 double 数据类型
可能需要在 Java ME Math pow() 幂方法中使用小数指数 我们提供的生成 Math pow() 的第一种方法是使用几何衰变算法的朴素的 强力 试探性方法 简单而言 衰变算法以一个大于已知解的值开始 然后应用某个方法来衰变该值 直到该值非常逼近该解（有关简单线性衰变算法的演示 请参见示例 ） 在我们的例子中 将进一步演示向上述解收敛的几何形式
示例
/* This example illustrates a simplistic decay algorithm that we will assume converges to our desired solution (a positive integer) */ int n; // assume that n is the solution to the number we are trying to find int varX = ; //assume that we know the solution is less than or equal to while( varX ) { varX = ; // decrement by if( varX == n)return varX; }
在示例 中 我们从 开始递减 直到找到预期的数字 假定预期数字是一个正整数 这种类型的算法构成了强力试探性方法的基础
使用类似的方法 我们可在遇到小数时应用此算法 假定我们需要求出 n 的值 其中 n = / 要使用衰变算法 我们必须首先找到一个合适的起点 该点要等于或大于解本身 这对于带有正指数的正实数很容易做到 对于我们的示例 要对此解进行编程 对方法两边求立方 得到 n = 当然 此方程与 n = 等效 之后 我们的起始值将变为 我们知道 n 必须小于 （因为 n = ） 注意 如果限于正实数 则此推导方法同样适用于任何正指数值 现在 我们可能需要设计一个循环来产生 n 的 充分接近 预期数字的解 我们再来看示例 它适合于所有正底数和正指数
示例
double pow( double x double y ) //we define our new power method for fractions { int den = ; // specify arbitrary denominator int num = (int)(y*den); // find numerator int s = (num/den)+ ; /*********************************************************************** ** Variable s provides the power for which we multiply the base to find ** our starting search value For example if we seek a solution for ** n = ^( / ) then we will use ^ or as our starting value (which is ** generated in our next section of code ) Why? The solution for our ** problem (given that the base is positive) will always be less than or ** equal to the base times the numerator power ************************************************************************/ /*********************************************************************** ** Because we set the denominator to an arbitrary high value ** we must attempt to reduce the fraction In the example below ** we find the highest allowable fraction that we can use without ** exceeding the limitation of our primitive data types ************************************************************************/ double z = Double MAX_VALUE; while( z = Double MAX_VALUE ) { den = ; // decrement denominator num = (int)(y*den); // find numerator s = (num/den)+ ; // adjust starting value // find value of our base number to the power of numerator z = x; for( int i = ; i num; i++ )z *= x; } /*********************************************************************** ** Now we are going to implement the decay algorithm to find ** the value of n ************************************************************************/ /*********************************************************************** ** We now find n to the power of s We will then decrement n ** finding the value of n to the power of the denominator This ** value variable a will be pared to z If the a is nearly ** equal to z then we will return n our desired result ************************************************************************/ double n = x; // We define n as our return value (estimate) for x // find n to the power of s for( int i = ; i s; i++)n *= x; // Begin decay loop while( n ) { double a = n; //proxy for n // find a the value of n to the power of denominator for( int i = ; i den; i++ )a *= n; // pare a to z Is the value within the hundred thousandth? // if so return n double check = a z; double check = z a; if( check || check ) return n; n *= ;// We arbitrarily use a decay of % per iteration } // value could not be found return return ; }
本示例演示了衰变算法的使用方法 您会注意到 n 的值（解的估计值）将按 % 强制递减 您可能需要根据编程精度要求来改变此值 也可能考虑包括编程逻辑 该逻辑用于将前一迭代解与当前迭代进行比较 然后 如果有改善继续进行迭代 但是 如果解已回归 则返回前一个值
这里讲述的解只处理正指数 如果值为负会出现什么情况呢？下面我们将解决这种意外情况
处理负指数
要再增加一层复杂度 假定正在向 Math pow() 方法传递负指数 在这种情况下 指数为负 一种简单的解决方案是将底数转换为小数 使指数为正 例如 可转换为 ( / ) 我们以可编程的方式用底数 x 来除 用 来乘 y（参见示例 ）
示例
if( y ) { x = ( /x); // convert base number to fraction y *= ; // make exponent positive }
lishixinzhi/Article/program/Java/hx/201311/26818
实现的代码如下：
#include stdio.h
__int64 fun(int n)
{
if(n==0) return 1;
return 1n;
}
void main()
{
int n;
scanf("%d",n);
printf("%I64d\n",fun(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中通常进行数学运算的东西都在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 的近似值都能自动满足单调性要求。
参考资料：
package mainjava;
import java.util.Scanner;
public class mihanshu {
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int n = sc.nextInt();
System.out.println(mihanshu(x,n));
}
public static int mihanshu(int x,int n)
{
if(n == 0)
{
return 1;
}
return x*mihanshu(x,n-1);
}
}
用递归解决，诸如y = x^n 每次调用n都减一，当n = 0时，返回1。即可 如果还有不懂，可追问，我现在给你编写一下，稍等。
java中输出幂函数可以：
直接输出比如 long mi = 2 (n-1)。
也可以跑循环计算比如 int n = 3;
long mi = 1L;
for(int i = 1; i = n; i++){
mi *= 2;
}
System.out.println(mi)。
