Подтвердить что ты не робот

Приближенная производная для непрерывной функции в течение определенных интервалов шага

Я хочу написать метод в Java, который находит производную для непрерывной функции. Это некоторые предположения, которые были сделаны для метода -

  • Функция непрерывна от x = 0 до x = бесконечность.
  • Производная существует в каждом интервале.
  • Размер шага должен быть определен как параметр.
  • Метод найдет max/min для непрерывной функции по заданному интервалу [a: b].

В качестве примера можно показать, что функция cos (x) имеет максимум или минимум при 0, pi, 2pi, 3pi,... npi.

Я хочу написать метод, который найдет все эти максимумы или минимумы, если будут предоставлены функции, lowerBound, upperBound и размер шага.

Чтобы упростить мой тестовый код, я написал программу для cos (x). Функция, которую я использую, очень похожа на cos (x) (по крайней мере, графически). Вот несколько тестовых кодов, которые я написал -

public class Test {
    public static void main(String[] args){
        Function cos = new Function () 
        {
        public double f(double x) {
        return Math.cos(x);
        }
    };

        findDerivative(cos, 1, 100, 0.01);      
    }

    // Needed as a reference for the interpolation function.
    public static interface Function {
    public double f(double x);
    }

     private static int sign(double x) {
    if (x < 0.0)
            return -1;
        else if (x > 0.0)
            return 1;
        else
            return 0;
    }

     // Finds the roots of the specified function passed in with a lower bound,
    // upper bound, and step size.
    public static void findRoots(Function f, double lowerBound,
                  double upperBound, double step) {
    double x = lowerBound, next_x = x;
    double y = f.f(x), next_y = y;
    int s = sign(y), next_s = s;

    for (x = lowerBound; x <= upperBound ; x += step) {
        s = sign(y = f.f(x));
        if (s == 0) {
        System.out.println(x);
        } else if (s != next_s) {
        double dx = x - next_x;
        double dy = y - next_y;
        double cx = x - dx * (y / dy);
        System.out.println(cx);
        }
        next_x = x; next_y = y; next_s = s;
    }
    }

    public static void findDerivative(Function f, double lowerBound, double 
            upperBound, double step) {
    double x = lowerBound, next_x = x;
    double dy = (f.f(x+step) - f.f(x)) / step;

    for (x = lowerBound; x <= upperBound; x += step) {
        double dx = x - next_x;
        dy = (f.f(x+step) - f.f(x)) / step;
        if (dy < 0.01 && dy > -0.01) {
            System.out.println("The x value is " + x + ". The value of the "
                    + "derivative is "+ dy);
            }
        next_x = x;
        }
    }   
}

Метод поиска корней используется для нахождения нулей (это определенно работает). Я включил его только в свою тестовую программу, потому что думал, что могу как-то использовать подобную логику внутри метода, который находит производные.

Метод

public static void findDerivative(Function f, double lowerBound, double 
            upperBound, double step) {
    double x = lowerBound, next_x = x;
    double dy = (f.f(x+step) - f.f(x)) / step;

    for (x = lowerBound; x <= upperBound; x += step) {
        double dx = x - next_x;
        dy = (f.f(x+step) - f.f(x)) / step;
        if (dy < 0.01 && dy > -0.01) {
            System.out.println("The x value is " + x + ". The value of the "
                    + "derivative is "+ dy);
            }
        next_x = x;
        }
    }

можно определенно улучшить. Как я мог написать это по-другому? Вот пример вывода.

The x value is 3.129999999999977. The value of the derivative is -0.006592578364594814
The x value is 3.1399999999999766. The value of the derivative is 0.0034073256197308943
The x value is 6.26999999999991. The value of the derivative is 0.008185181673381337
The x value is 6.27999999999991. The value of the derivative is -0.0018146842631128202
The x value is 9.409999999999844. The value of the derivative is -0.009777764220086915
The x value is 9.419999999999844. The value of the derivative is 2.2203830347677922E-4
The x value is 12.559999999999777. The value of the derivative is 0.0013706082193754021
The x value is 12.569999999999776. The value of the derivative is -0.00862924258597797
The x value is 15.69999999999971. The value of the derivative is -0.002963251265619693
The x value is 15.70999999999971. The value of the derivative is 0.007036644660118885
The x value is 18.840000000000146. The value of the derivative is 0.004555886794943564
The x value is 18.850000000000147. The value of the derivative is -0.005444028885981389
The x value is 21.980000000000636. The value of the derivative is -0.006148510767989279
The x value is 21.990000000000638. The value of the derivative is 0.0038513993028788107
The x value is 25.120000000001127. The value of the derivative is 0.0077411191450771355
The x value is 25.13000000000113. The value of the derivative is -0.0022587599505241585
4b9b3361

ОТВЕТЫ

Ответ 1

Главное, что я могу улучшить для производительности в случае, когда f дорого вычислить, вы можете сохранить предыдущее значение f (x) вместо того, чтобы дважды его вычислять для каждой итерации. Также dx никогда не используется и всегда будет равным шагу. next_x также никогда не использовался. Некоторая переменная может быть объявлена ​​внутри цикла. Перемещение деклараций переменных внутри улучшает читаемость, но не производительность.

public static void findDerivative(Function f, double lowerBound, double upperBound, double step) {
    double fxstep = f.f(x);

    for (double x = lowerBound; x <= upperBound; x += step) {
        double fx = fxstep;
        fxstep = f.f(x+step);
        double dy = (fxstep - fx) / step;
        if (dy < 0.01 && dy > -0.01) {
            System.out.println("The x value is " + x + ". The value of the "
                    + "derivative is " + dy);
        }
    }
}

Ответ 2

Код java, на котором вы основаны (из rosettacode), не в порядке, не зависит от него.

  • Ожидание y (двойное значение) станет равным нулю.
    Для таких тестов вам необходимо значение допуска.
  • вычислить производную и использовать Newton Method для вычисления следующего значения x,
    но не используя его для обновления x, там нет никакой оптимизации.

Здесь приведен пример метода Newton в Java

Да, вы можете оптимизировать свой код с помощью метода Ньютона,
Поскольку он может решить f (x) = 0, если f '(x),
также может решить f '(x) = 0, если f' '(x), то же самое.

Ответ 3

Чтобы прояснить мой комментарий, я изменил код в ссылке.
Я использовал step = 2 и получил правильные результаты. Проверьте, насколько это быстро, по сравнению с другими.
Вот почему используется оптимизация,
в противном случае уменьшение размера шага и использование грубой силы выполняли бы работу.

class Test {

    static double f(double x) {
        return Math.sin(x);
    }

    static double fprime(double x) {
        return Math.cos(x);
    }

    public static void main(String argv[]) {

        double tolerance = .000000001; // Our approximation of zero
        int max_count = 200; // Maximum number of Newton method iterations

        /*
         * x is our current guess. If no command line guess is given, we take 0
         * as our starting point.
         */

        double x = 0.6;
        double low = -4;
        double high = 4;
        double step = 2;
        int inner_count = 0;

        for (double initial = low; initial <= high; initial += step) {
            x = initial;
            for (int count = 1; (Math.abs(f(x)) > tolerance)
                    && (count < max_count); count++) {
                inner_count++;
                x = x - f(x) / fprime(x);
            }

            if (Math.abs(f(x)) <= tolerance) {
                System.out.println("Step: " + inner_count + ", x = " + x);
            } else {
                System.out.println("Failed to find a zero");
            }
        }
    }

}