NumericalAnalysis_LAB_2

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.DecimalFormat;


//По условию: f(x) = (tg(5*x))^2;
//По условию: F(x) = (tg(5*x)/5) - x;
public class Main {

    public static void main(String[] args) throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        //Границы интегрирования
        double a, b;
        System.out.println("Введите левую и правую границы интегрирования:");
        System.out.print("a: ");
        a = Double.parseDouble(reader.readLine());
        do {
            System.out.print("b: ");
            b = Double.parseDouble(reader.readLine());
        } while (b <= a);

        //Ввод N(число разбиений):
        int n;
        do {
            System.out.print("Введите N(число разбиений): ");
            n = Integer.parseInt(reader.readLine());
        } while (n <= 0);
        System.out.println();

        printAllFormulas(a, b, n);
        System.out.println();

        printAllRungeDeviations(a, b, n);
        System.out.println();

        printAllNumbersOfIterations(a, b);
        System.out.println();

    }

    //Вывод значений интеграла по каждой формуле
    public static void printAllFormulas(double a, double b, int n) {
        System.out.println("Точное значение интеграла(через первообразную) на отрезке ["
                + new DecimalFormat("#.###").format(a) + "; "
                + new DecimalFormat("#.###").format(b) + "] = "
                + new DecimalFormat("#.######").format(func_F(b) - func_F(a)));

        System.out.println("Приближённое значение интеграла (N = " + n + ") через квадратурную"
                + " формулу по ЛЕВЫМ прямоугольникам на отрезке ["
                + new DecimalFormat("#.###").format(a) + "; "
                + new DecimalFormat("#.###").format(b) + "] = "
                + new DecimalFormat("#.######").format(leftSquareFormula(a, b, n)));

        System.out.println("Приближённое значение интеграла (N = " + n + ") через квадратурную"
                + " формулу по ПРАВЫМ прямоугольникам на отрезке ["
                + new DecimalFormat("#.###").format(a) + "; "
                + new DecimalFormat("#.###").format(b) + "] = "
                + new DecimalFormat("#.######").format(rightSquareFormula(a, b, n)));

        System.out.println("Приближённое значение интеграла (N = " + n + ") через квадратурную"
                + " формулу по СРЕДНИМ прямоугольникам на отрезке ["
                + new DecimalFormat("#.###").format(a) + "; "
                + new DecimalFormat("#.###").format(b) + "] = "
                + new DecimalFormat("#.######").format(midSquareFormula(a, b, n)));

        System.out.println("Приближённое значение интеграла (N = " + n + ") через квадратурную"
                + " формулу ТРАПЕЦИЙ на отрезке ["
                + new DecimalFormat("#.###").format(a) + "; "
                + new DecimalFormat("#.###").format(b) + "] = "
                + new DecimalFormat("#.######").format(trapezoidFormula(a, b, n)));

        System.out.println("Приближённое значение интеграла (N = " + n + ") через квадратурную"
                + " формулу СИМПСОНА на отрезке ["
                + new DecimalFormat("#.###").format(a) + "; "
                + new DecimalFormat("#.###").format(b) + "] = "
                + new DecimalFormat("#.######").format(simpsonFormula(a, b, n)));
    }

    //Вывод отклонений каждого метода по правилу Рунге
    public static void printAllRungeDeviations(double a, double b, int n) {
        System.out.println("Погрешность метода левых пр-ков при N = " + n + " по правилу Рунге = "
                + rungeDeviation(a, b, n, 1));
        System.out.println("Погрешность метода правых пр-ков при N = " + n + " по правилу Рунге = "
                + rungeDeviation(a, b, n, 2));
        System.out.println("Погрешность метода средних пр-ков при N = " + n + " по правилу Рунге = "
                + rungeDeviation(a, b, n, 3));
        System.out.println("Погрешность метода трапеций при N = " + n + " по правилу Рунге = "
                + rungeDeviation(a, b, n, 4));
        System.out.println("Погрешность метода Симпсона при N = " + n + " по правилу Рунге = "
                + rungeDeviation(a, b, n, 5));
    }

    //Вывод всех N-разбиений, нужных для того, чтобы данный метод достиг погрешности <= 0.001
    public static void printAllNumbersOfIterations(double a, double b) {
        System.out.println("Число N, при котором достигается погрешность < 0.0001 по ф-ле ЛЕВЫХ пр-ков = "
                + findNumberOfIterations(a, b, 1));
        System.out.println("Число N, при котором достигается погрешность < 0.0001 по ф-ле ПРАВЫХ пр-ков = "
                + findNumberOfIterations(a, b, 2));
        System.out.println("Число N, при котором достигается погрешность < 0.0001 по ф-ле СРЕДНИХ пр-ков = "
                + findNumberOfIterations(a, b, 3));
        System.out.println("Число N, при котором достигается погрешность < 0.0001 по ф-ле трапеций = "
                + findNumberOfIterations(a, b, 4));
        System.out.println("Число N, при котором достигается погрешность < 0.0001 по ф-ле СИМПСОНА = "
                + findNumberOfIterations(a, b, 5));
    }

    //Функция, заданная по условию
    public static double func_f(double x) {
        return Math.pow(Math.tan(5*x), 2);
    }

    //Первоообразная, заданная по условию
    public static double func_F(double x) {
        return (Math.tan(5*x)/5) - x;
    }

    //Квадратурная формула по левым прямоугольникам
    public static double leftSquareFormula(double a, double b, int n) {
        double result = 0;
        double h = (b - a)/n;

        double xi;
        for (int i = 0; i < n; i++) {
            xi = a + i*h;
            result += func_f(xi);
        }
        result *= h;

        return result;
    }

    //Квадратурная формула по правым прямоугольникам
    public static double rightSquareFormula(double a, double b, int n) {
        double result = 0;
        double h = (b - a)/n;

        double xi;
        for (int i = 1; i <= n; i++) {
            xi = a + i*h;
            result += func_f(xi);
        }
        result *= h;

        return result;
    }

    //Квадратурная формула по средним прямоугольникам
    public static double midSquareFormula(double a, double b, int n) {
        double result = 0;
        double h = (b - a)/n;

        double xi, xi_1;
        for (int i = 0; i < n; i++) {
            xi = a + i*h;
            xi_1 = a + (i + 1)*h;
            result += func_f((xi + xi_1)/2);
        }
        result *= h;

        return result;
    }

    //Обобщённая квадратурная формула трапеций
    public static double trapezoidFormula(double a, double b, int n) {
        double result = 0;
        double h = (b - a)/n;

        double xi;
        for (int i = 1; i < n; i++) {
            xi = a + i*h;
            result += func_f(xi);
        }
        result *= h;
        result += (h/2)*(func_f(a) + func_f(b));
        return result;
    }

    //Обобщённая квадратурная формула Симпсона
    public static double simpsonFormula(double a, double b, int n) {
        double result = 0;
        double h = (b - a)/n;

        double xi;

        double temp = 0;
        for (int i = 2; i < n - 1; i += 2) {
            xi = a + i*h;
            temp += func_f(xi);
        }
        temp *= 2;
        result += temp;

        temp = 0;
        for (int i = 1; i < n; i += 2) {
            xi = a + i*h;
            temp += func_f(xi);
        }
        temp *= 4;
        result += temp;

        result += (func_f(a) + func_f(b));
        result *= (h/3);

        return result;
    }

    //Погрешность метода по правилу Рунге:
    public static double rungeDeviation(double a, double b, int n, int methodNumber) {

        switch (methodNumber) {
            case 1: //ЛЕВЫЕ прямоугольники
                return Math.abs(leftSquareFormula(a, b, 2*n) - leftSquareFormula(a, b, n)) / 3;
            case 2: //ПРАВЫЕ прямоугольники
                return Math.abs(rightSquareFormula(a, b, 2*n) - rightSquareFormula(a, b, n)) / 3;
            case 3: //СРЕДНИЕ прямоугольники
                return Math.abs(midSquareFormula(a, b, 2*n) - midSquareFormula(a, b, n)) / 3;
            case 4: //ТРАПЕЦИИ
                return Math.abs(trapezoidFormula(a, b, 2*n) - trapezoidFormula(a, b, n)) / 3;
            case 5: //СИМПСОН
                return Math.abs(simpsonFormula(a, b, 2*n) - simpsonFormula(a, b, n)) / 15;
        }

        return 0;
    }

    public static int findNumberOfIterations(double a, double b, int methodNumber) {

        double eps = 0.0001;
        int n = 1;
        double accurateIntegral = func_F(b) - func_F(a);
        double approximateIntegral;
        switch (methodNumber) {
            case 1: //ЛЕВЫЕ прямоугольники
                do {
                    approximateIntegral = leftSquareFormula(a, b, n);
                    n++;
                } while (Math.abs(accurateIntegral - approximateIntegral) > eps);
                return n-1;
            case 2: //ПРАВЫЕ прямоугольники
                do {
                    approximateIntegral = rightSquareFormula(a, b, n);
                    n++;
                } while (Math.abs(accurateIntegral - approximateIntegral) > eps);
                return n-1;
            case 3: //СРЕДНИЕ прямоугольники
                do {
                    approximateIntegral = midSquareFormula(a, b, n);
                    n++;
                } while (Math.abs(accurateIntegral - approximateIntegral) > eps);
                return n-1;
            case 4: //ТРАПЕЦИИ
                do {
                    approximateIntegral = trapezoidFormula(a, b, n);
                    n++;
                } while (Math.abs(accurateIntegral - approximateIntegral) > eps);
                return n-1;
            case 5: //СИМПСОН
                do {
                    approximateIntegral = simpsonFormula(a, b, n);
                    n++;
                } while (Math.abs(accurateIntegral - approximateIntegral) > eps);
                return n-1;
        }

        return n;
    }

}