4

这是一个家庭作业问题。我无法将以下内容转换为递归函数：

public class Integrate {
    public static double integrate(int  a, int b, int steps)
    {
        double sum=0;
        double delta = 1.0 * (b - a)/steps;
        double x = a;
        double f = 0.5*x*x + 3*x + 5;

        for (int i = 0; i< steps; i++)
        {
            x = x + delta;
            double fr = 0.5*x*x + 3*x + 5;
            double area = f * delta + 0.5*(fr - f)*delta;
            sum += area;
            f = fr;
        }
        return sum;
    }
    public static void main(String [] args)
    {
        int a, b, step;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        step = Integer.parseInt(args[2]);
        System.out.format("Integral is %f\n", integrate(a,b,step));
    }
}

这是我到目前为止所拥有的，但输出与原始代码不同。我不知道出了什么问题

public class Integrate {

    public static double integrate(int a, int b, int steps) {
        double sum=0;
        int i=0;
        sum = rintegrate(a, b, steps, i, sum);
        return sum;
    }

    public static double rintegrate(int a, int b, int steps, 
            int i, double sum) {
        double delta = 1.0 * (b - a)/steps;
        double x = a;
        double f = 0.5*x*x + 3*x + 5;
        if (i<steps) {
            x = x + delta;
            double fr = 0.5*x*x + 3*x + 5;
            double area = f * delta + 0.5*(fr - f)*delta;
            sum += area;
            f = fr;
            i++;
            rintegrate(a, b, steps, i, sum);
        }
        return sum;
    }

    public static void main(String[] args) {
        int a, b, step;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        step = Integer.parseInt(args[2]);
        System.out.format("Integral is %f\n", integrate(a,b,step));
    }

}
4

3 回答 3

3

我不会完全分析这个问题，但这里有一些我的观察

    if (i<steps) {
        x = x + delta;
        double fr = 0.5*x*x + 3*x + 5;
        double area = f * delta + 0.5*(fr - f)*delta;
        sum += area;
        f = fr;
        i++;
        rintegrate(a, b, steps, i, sum);
    }
    return sum;

sum += area;和之间的一切return sum;都是多余的。

  • 您设置f为fr，但f之后您甚至从未使用过。如果您f下次想与众不同，也许您可​​以将其作为参数传递给您的递归函数
  • 您正在递归调用rintegrate(...)，但您没有对它返回的值做任何事情。您可能想要使用该值。

您应该将递归视为使用较小版本的问题来解决自身问题。

假设您有一个函数，这里有一些代码可以解决您的问题：segment它只计算给定的第一段的大小a，并且delta

rintegrate(a, b, steps)
{
    if(steps <= 1)
    {
        delta = b-a;
        return segment(a, delta)
    }
    else
    {
        delta = (b-a)/steps
        return segment(a, delta) + rintegrate(a+delta, b, steps-1)
    }
}
于 2013-05-13T16:18:15.087 回答
1

工作版本

只需复制粘贴，您将获得与原始方法相同的输出。

   public static void main(String[] args) {
        int a = 1, b = 10, step = 1000;
            double delta = 1.0 * (b - a) / step;
        double sum = integrate(a, b, step, 0, 0, 0, delta);
        double test = working(a, b, step);
        System.out.println("Integral is " + sum);
        System.out.println("Integral is " + test);
    }

工作递归版本：

    public static double integrate(double x, int b, int steps, int i,
            double sum, double f, double delta) { 
        f = 0.5 * x * x + 3 * x + 5;
        if (i < steps) {
            x = x + delta;
            double fr = 0.5 * x * x + 3 * x + 5;
            double area = f * delta + 0.5 * (fr - f) * delta;
            return integrate(x, b, steps, i + 1, sum + area, fr, delta);
        }
        return sum;
    }

你原来的迭代方法；

public static double working(int a, int b, int steps) {
    double sum = 0;
    double delta = 1.0 * (b - a) / steps;
    double x = a;
    double f = 0.5 * x * x + 3 * x + 5;

    for (int i = 0; i < steps; i++) {
        x = x + delta;
        double fr = 0.5 * x * x + 3 * x + 5;
        double area = f * delta + 0.5 * (fr - f) * delta;
        sum += area;
        f = fr;
    }
    return sum;
}
于 2013-05-13T16:21:42.700 回答
0

这就是你想要的；）

public class Integrate{

    /**
     * @param args
     */
    public static void main(String[] args) {
        int a, b, step;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        step = Integer.parseInt(args[2]);
        System.out.format("Integral is %f\n",
                adaptiveSimpsons(a, b, step));

    }

    private static double f(double i) {
        return (0.5 * i * i + 3 * i + 5);
    }

    static double adaptiveSimpsons(double a, double b, // interval [a,b]
            int maxRecursionDepth) { // recursion cap
        double c = (a + b) / 2, h = b - a;
        double fa = f(a), fb = f(b), fc = f(c);
        double S = (h / 6) * (fa + 4 * fc + fb);
        return adaptiveSimpsonsAux(a, b, S, fa, fb, fc, maxRecursionDepth);
    }

    private static double adaptiveSimpsonsAux(double a, double b, double S, double fa,
            double fb, double fc, int bottom) {
        double c = (a + b) / 2, h = b - a;
        double d = (a + c) / 2, e = (c + b) / 2;
        double fd = f(d), fe = f(e);
        double Sleft = (h / 12) * (fa + 4 * fd + fc);
        double Sright = (h / 12) * (fc + 4 * fe + fb);
        double S2 = Sleft + Sright;
        if (bottom <= 0)
            return S2 + (S2 - S) / 15;
        return adaptiveSimpsonsAux(a, c, Sleft, fa, fc, fd, bottom - 1)
                + adaptiveSimpsonsAux(c, b, Sright, fc, fb, fe, bottom - 1);
    }
}

经过测试和工作

此处给出的翻译后的 C 代码

于 2013-05-13T16:58:30.243 回答