Java 爪哇-辛普森'；s方法与误差_Java_Numerical Methods_Estimation

Java 爪哇-辛普森'；s方法与误差

java

Java 爪哇-辛普森'；s方法与误差,java,numerical-methods,estimation,Java,Numerical Methods,Estimation,我正在为辛普森的方法编写一个Java程序。basic程序按预期工作，尽管我无法使（绝对）错误部分正常工作我想我需要以不同的方式引用我的while（absError

我正在为辛普森的方法编写一个Java程序。basic程序按预期工作，尽管我无法使（绝对）错误部分正常工作

我想我需要以不同的方式引用我的

while（absError<0.000001）

循环。我做错了什么

初试

public static double function(double x, double s) {
    double sech = 1 / Math.cosh(x); // Hyperbolic cosecant
    double squared = Math.pow(sech, 2);
    return ((Math.pow(x, s)) * squared);
 }

 // Simpson's rule - Approximates the definite integral of f from a to b.
 public static double SimpsonsRule(double a, double b, double s, int n) {
    double dx, x, sum4x, sum2x;
    double absError = 1.0;
    double simpson = 0.0;
    double simpson2 = 0.0;

    dx = (b-a) / n;
    sum4x = 0.0;
    sum2x = 0.0;

    // 4/3 terms
    for (int i = 1; i < n; i += 2) {
        x = a + i * dx;
        sum4x += function(x,s);
    }

    // 2/3 terms
    for (int i = 2; i < n-1; i += 2) {
        x = a + i * dx;
        sum2x += function(x,s);
    }

    // Compute the integral approximation.
    simpson = function(a,s) + function(a,b);
    simpson = (dx / 3)*(simpson + 4 * sum4x + 2 * sum2x);
    while ( absError < 0.000001)
    {
        simpson2 = SimpsonsRule(a, b, s, n);
        absError = Math.abs(simpson2 - simpson) / 15;
        simpson = simpson2;
        n++;
    }
    System.out.println("Number of intervals is " + n + ".");
    return simpson2;
}

没错

我尝试了第二种方法，但最终解决方案也失败了

public static double function(double x, double s) {
    double sech = 1 / Math.cosh(x); // Hyperbolic cosecant
    double squared = Math.pow(sech, 2);
    return ((Math.pow(x, s)) * squared);
 }

 // Simpson's rule - Approximates the definite integral of f from a to b.
public static double SimpsonsRule(double a, double b, double s, int n) {
    double dx, x, sum4x, sum2x;
    double absError = 1.0;
    double simpson = 0.0;
    double simpson2 = 0.0;

    dx = (b-a) / n;
    sum4x = 0.0;
    sum2x = 0.0;

    // 4/3 terms
    for (int i = 1; i < n; i += 2) {
        x = a + i * dx;
        sum4x += function(x,s);
    }

    // 2/3 terms
    for (int i = 2; i < n-1; i += 2) {
        x = a + i * dx;
        sum2x += function(x,s);
    }

    // Compute the integral approximation.
    simpson = function(a,s) + function(a,b);
    simpson = (dx / 3)*(simpson + 4 * sum4x + 2 * sum2x);
    while ( absError < 0.000001)
    {
        n++;
        dx = (b-a) / n;
         // 4/3 terms
        for (int i = 1; i < n; i += 2) {
            x = a + i * dx;
            sum4x += function(x,s);
        }

        // 2/3 terms
        for (int i = 2; i < n-1; i += 2) {
            x = a + i * dx;
            sum2x += function(x,s);
        }
        simpson = function(a,s) + function(a,b);
        simpson2 = (dx / 3)*(simpson + 4 * sum4x + 2 * sum2x);
        absError = Math.abs(simpson2 - simpson) / 15;
        simpson = simpson2;
    }
    System.out.println("Number of intervals is " + n + ".");
    return simpson2;
}

公共静态双功能（双x，双s）{
double sech=1/Math.cosh（x）；//双曲余割
双平方=数学功率（秒，2）；
返回（（数学功率（x，s））*平方）；
}
//辛普森规则-近似f从a到b的定积分。
公共静态双辛普森规则（双a、双b、双s、整数n）{
双dx，x，sum4x，sum2x；
双误差=1.0；
双辛普森=0.0；
双辛普森2=0.0；
dx=（b-a）/n；
sum4x=0.0；
sum2x=0.0；
//4/3条款
对于（int i=1；i


我需要以不同的方式编写while循环。while循环中引用错误的方式有什么问题
java代码直到
    while ( absError < 0.000001)
{
    simpson2 = SimpsonsRule(a, b, s, n);
    absError = Math.abs(simpson2 - simpson) / 15;
    simpson = simpson2;
    n++;
}
System.out.println("Number of intervals is " + n + ".");
return simpson2;

while（absError<0.000001）
{
simpson2=SimpsonRule（a、b、s、n）；
absError=Math.abs（simpson2-simpson）/15；
辛普森=辛普森2；
n++；
}
System.out.println（“间隔数为“+n+”）；
返回辛普森2；

工作正常，正确计算辛普森方法。
看起来您的辛普森方法实现没有收敛。你可以做的最简单的事情就是避免无限循环，而你必须添加另一个条件——最大迭代次数
诸如此类：
int n = 0;
while (error < ACCURACY && n++ < MAX_ITERATIONS) {
    // while body
}

int n=0；
while（误差<精度和n++<最大迭代次数）{
//而身体
}

其中，精度
在您的情况下是0.000001
（或1e-6
），并且MAX_迭代次数
是一个整数常量，例如100000
或1e+6

为什么您的算法不收敛-这是另一个问题-仔细查看您的公式-使用调试工具。祝你好运
 我把它修好了。谢谢你的帮助
 // Simpson's rule - Approximates the definite integral of f from a to b.
 public static double SimpsonsRule(double a, double b, double s, int n) {
    double simpson, dx, x, sum4x, sum2x;

    dx = (b-a) / n;
    sum4x = 0.0;
    sum2x = 0.0;

    // 4/3 terms
    for (int i = 1; i < n; i += 2) {
        x = a + i * dx;
        sum4x += function(x,s);
    }

    // 2/3 terms
    for (int i = 2; i < n-1; i += 2) {
        x = a + i * dx;
        sum2x += function(x,s);
    }

    // Compute the integral approximation.
    simpson = function(a,s) + function(a,b);
    simpson = (dx / 3)*(simpson + 4 * sum4x + 2 * sum2x);
    return simpson;
}

// Handles the error for for f(x) = t^s * sech(t)^2. The integration is
// done from 0 to 100.
// Stop Simspson's Method when the relative error is less than 1 * 10^-6
public static double SimpsonError(double a, double b, double s, int n)
{
    double futureVal;
    double absError = 1.0;
    double finalValueOfN;
    double numberOfIterations = 0.0;
    double currentVal = SimpsonsRule(a,b,s,n);

    while (absError / currentVal > 0.000001) {
        n = 2*n;
        futureVal = SimpsonsRule(a,b,s,n);
        absError = Math.abs(futureVal - currentVal) / 15;
        currentVal = futureVal;
    }

    // Find the number of iterations. N starts at 8 and doubles every iteration.
    finalValueOfN = n / 8;
    while (finalValueOfN % 2 == 0) {
        finalValueOfN = finalValueOfN / 2;
        numberOfIterations++;
    }
    System.out.println("The number of iterations is " + numberOfIterations + ".");
    return currentVal;
}

//辛普森规则-近似f从a到b的定积分。
公共静态双辛普森规则（双a、双b、双s、整数n）{
双辛普森，dx，x，sum4x，sum2x；
dx=（b-a）/n；
sum4x=0.0；
sum2x=0.0；
//4/3条款
对于（int i=1；i0.000001）{
n=2*n；
futureVal=辛普森规则（a、b、s、n）；
absError=Math.abs（futureVal-currentVal）/15；
当前值=未来值；
}
//求迭代次数。N从8开始，每次迭代加倍。
最终值OFN=n/8；
while（n%2的最终值==0）{
最终价值OFN=最终价值OFN/2；
numberOfIterations++；
}
System.out.println（“迭代次数为“+numberOfIterations+”）；
返回currentVal；
}
您不能让它工作是什么意思？出了什么问题？它创建了一个无限循环，并且没有用辛普森方法计算正确的数值结果。给定条件，可能是误差差收敛太慢（让你相信它是无限的）或者差异不收敛。second@discipliuned：在计算误差时，尝试用更大的ε除以15？这是毫无意义的-只需使用一个大15倍的ε值，就可以得到相同的结果，而不需要所有的除法。
 // Simpson's rule - Approximates the definite integral of f from a to b.
 public static double SimpsonsRule(double a, double b, double s, int n) {
    double simpson, dx, x, sum4x, sum2x;

    dx = (b-a) / n;
    sum4x = 0.0;
    sum2x = 0.0;

    // 4/3 terms
    for (int i = 1; i < n; i += 2) {
        x = a + i * dx;
        sum4x += function(x,s);
    }

    // 2/3 terms
    for (int i = 2; i < n-1; i += 2) {
        x = a + i * dx;
        sum2x += function(x,s);
    }

    // Compute the integral approximation.
    simpson = function(a,s) + function(a,b);
    simpson = (dx / 3)*(simpson + 4 * sum4x + 2 * sum2x);
    return simpson;
}

// Handles the error for for f(x) = t^s * sech(t)^2. The integration is
// done from 0 to 100.
// Stop Simspson's Method when the relative error is less than 1 * 10^-6
public static double SimpsonError(double a, double b, double s, int n)
{
    double futureVal;
    double absError = 1.0;
    double finalValueOfN;
    double numberOfIterations = 0.0;
    double currentVal = SimpsonsRule(a,b,s,n);

    while (absError / currentVal > 0.000001) {
        n = 2*n;
        futureVal = SimpsonsRule(a,b,s,n);
        absError = Math.abs(futureVal - currentVal) / 15;
        currentVal = futureVal;
    }

    // Find the number of iterations. N starts at 8 and doubles every iteration.
    finalValueOfN = n / 8;
    while (finalValueOfN % 2 == 0) {
        finalValueOfN = finalValueOfN / 2;
        numberOfIterations++;
    }
    System.out.println("The number of iterations is " + numberOfIterations + ".");
    return currentVal;
}