package 实验一;
public class Test2 { static double x0; // 二分次数 public static double f(int x) {
return x * x * x + x * x - 3 * x - 3;
}
public static double fDerivative(int x){ //导数表达式
return 3*x*x+2*x-3;
}
public static double x(int n){ //递归求Xn
if(n==0){
return x0;
}else{
return x(n-1)-f(n-1)/fDerivative(n-1);
}
}
public static double newton(double x0, double eps,int n) {
int k=1;
while(Math.abs(x(k)-x(k-1))>eps){
k++;
}
if(k>n){
return 0;
}else{
return x(k);
}
} public static void main(String[] args) {
System.out.print("请输入初始值X0:");
x0=KB.scanDouble();
System.out.print("\n请输入根的容许误差限EPS的值:");
double EPS = KB.scanDouble();
System.out.print("\n请输入迭代次数N:");
int n=(int) KB.scanInt();
newton(x0,EPS,n);
if (newton(x0, EPS, n) != 0) {
System.out.println(newton(x0, EPS, n));
}else{
System.out.println("算法失败!");
}
}}import java.util.Scanner;
class KB {
public static int scanInt(){ //接收数值型输入
Scanner in=new Scanner(System.in);
int a=in.nextInt();
return a;
} public static double scanDouble() { // 接收数值输入
Scanner in = new Scanner(System.in);
double a=in.nextDouble();
return a;
}
}这是数值计算 牛顿迭代法的程序!!麻烦给看看哪里错了!!
牛顿迭代法思想如下:f'(x)为多项式f(x)的导数表达式!
当X(k)-X(k-1)<EPS时,迭代结束!!
X(k)就是多项式的根!!
递归迭代Java堆栈溢出
public class Test2 { static double x0; // 二分次数 public static double f(int x) {
return x * x * x + x * x - 3 * x - 3;
}
public static double fDerivative(int x){ //导数表达式
return 3*x*x+2*x-3;
}
public static double x(int n){ //递归求Xn
if(n==0){
return x0;
}else{
return x(n-1)-f(n-1)/fDerivative(n-1);
}
}
public static double newton(double x0, double eps,int n) {
int k=1;
while(Math.abs(x(k)-x(k-1))>eps){
k++;
}
if(k>n){
return 0;
}else{
return x(k);
}
} public static void main(String[] args) {
System.out.print("请输入初始值X0:");
x0=KB.scanDouble();
System.out.print("\n请输入根的容许误差限EPS的值:");
double EPS = KB.scanDouble();
System.out.print("\n请输入迭代次数N:");
int n=(int) KB.scanInt();
newton(x0,EPS,n);
if (newton(x0, EPS, n) != 0) {
System.out.println(newton(x0, EPS, n));
}else{
System.out.println("算法失败!");
}
}}import java.util.Scanner;
class KB {
public static int scanInt(){ //接收数值型输入
Scanner in=new Scanner(System.in);
int a=in.nextInt();
return a;
} public static double scanDouble() { // 接收数值输入
Scanner in = new Scanner(System.in);
double a=in.nextDouble();
return a;
}
}这是数值计算 牛顿迭代法的程序!!麻烦给看看哪里错了!!
牛顿迭代法思想如下:f'(x)为多项式f(x)的导数表达式!
当X(k)-X(k-1)<EPS时,迭代结束!!
X(k)就是多项式的根!!
递归迭代Java堆栈溢出
while (Math.abs(x(k) - x(k - 1)) > eps) {
在一个循环内用了k++,但是到了x这个函数里:
return x(n - 1) - f(n - 1) / fDerivative(n - 1);
又进行了x(n-1)的调用,所以结果是当你k=1的时候,调用了x(1),x(0);k=2的时候调用了x(2), x(1), x(0)。k的值是多少,就有多少次递归调用,这个大概是让你stack爆炸的原因。你把 if (k>n) return 0这个放到while里面就行了
程序循环结束条件是|x(k)-x(k-1)|<EPS
x(k)就是得到的根!
不循环计算K,怎么得到K的值
你再仔细看看流程图里面的k是干啥用的
牛顿迭代法就是拿前一个x来生成后一个x,去逼近根的值,k只是表示这样的过程重复几次,而N就是限制重复的次数。
x(10) - x(9) < EPS是你的条件,x( x(9) ) - x (9) < EPS 则是牛顿的意思
可是你不知道迭代多少次 例如想x(k)是多项式的根,不算出k的值,怎么得到x(k)
if (n == 0) {
return x0;
}
else {
return x(n - 1) - f(x(n - 1)) / fDerivative(x(n - 1));
}
}
public static double newton(double x0, double eps, int n) {
int k = 1;
while (Math.abs(x(k) - x(k - 1)) > eps) {
k++; if (k > n) {
return 0;
}
} return x(k);
}把你的x和newton改成这样,输入1,1e-6,60。然后f和fDerivative的参数改成double x问题的关键你是拿了k去算f(x(k)),应该拿x(k)去算f(x(k))之前没看仔细,抱歉
这里有完整的实验文档,麻烦给看下!!非常感谢你能帮我答疑!!!
http://pan.baidu.com/disk/home#dir/path=%2F%E6%88%91%E7%9A%84%E6%96%87%E6%A1%A3
看文档,我把概念搞错了?想法哪里有偏差!!
这里有完整的实验文档,麻烦给看下!!非常感谢你能帮我答疑!!!
http://pan.baidu.com/disk/home#dir/path=%2F%E6%88%91%E7%9A%84%E6%96%87%E6%A1%A3
看文档,我把概念搞错了?想法哪里有偏差!!
已经答了
代码之前有改进,和你改的差不多!但是没用!永远是算法失败!
package 实验一;public class Test3 { static double x0; // 二分次数 public static double f(int x) {
return x * x * x + x * x - 3 * x - 3;
} public static double fDerivative(int x) { // 导数表达式
return 3 * x * x + 2 * x - 3;
} public static double x(int n) { // 递归求Xn
if (n == 0) {
return x0;
} else {
return x(n - 1) - f(n - 1) / fDerivative(n - 1);
}
} public static double newton(double x0, double eps, int n) { int k = 1;
while (Math.abs(x(k) - x(k - 1)) > eps) {
if (k > n) {
return 0;
}
k++;
} return x(k); } public static void main(String[] args) { System.out.print("请输入初始值X0:");
x0 = KB.scanDouble();
System.out.print("\n请输入根的容许误差限EPS的值:");
double EPS = KB.scanDouble();
System.out.print("\n请输入迭代次数N:");
int n = (int) KB.scanInt();
newton(x0, EPS, n);
if (newton(x0, EPS, n) != 0) {
System.out.println(newton(x0, EPS, n));
} else {
System.out.println("算法失败!");
} }}
结果永远是算法失败!难道牛顿迭代法逻辑有错?
1.7320508075688774关键的这句你没改:
return x(n - 1) - f(n - 1) / fDerivative(n - 1);
仔细看我改的