import java.util.Scanner;

public class Main {

    public static double funkcja(double x) {
        return 7 * x * x * x * x
                + 0.12 * x * x
                - 3.4 * x
                - 0.7;
    }

    public static double bezwzgledna(double wartosc) {
        if (wartosc >= 0) {
            return wartosc;
        } else {
            return -wartosc;
        }
    }

    public static double metodaBisekcji(
            double a,
            double b,
            double Ex,package com.mycompany.ore;

import java.util.Scanner;

public class Ore {

    public static void main(String args[]) {
        int tablica[] = {8, 5, 2, 1, 6};

        sortujPrzezScalenie(tablica, 0, tablica.length - 1);

        for (int i = 0; i < tablica.length; i++) {
            System.out.print(tablica[i] + " ");
        }
    }

    public static void sortujPrzezScalenie(
            int tablica[],
            int indeksPoczatku,
            int indeksKonca
    ) {
        if (indeksPoczatku < indeksKonca) {

            // Krok 1 - podziel tablicę na dwie części
            int srodkowyIndeks =
                    (indeksKonca + indeksPoczatku) / 2;

            // Krok 2 - podziel lewą część
            sortujPrzezScalenie(
                    tablica,
                    indeksPoczatku,
                    srodkowyIndeks
            );

            // Krok 3 - podziel prawą część
            sortujPrzezScalenie(
                    tablica,
                    srodkowyIndeks + 1,
                    indeksKonca
            );

            // Krok 4 - scal dwie części
            scalDwieCzesci(
                    tablica,
                    indeksPoczatku,
                    srodkowyIndeks,
                    indeksKonca
            );

        } else {
            return;
        }
    }

    public static void scalDwieCzesci(
            int tablica[],
            int indeksPoczatku,
            int srodkowyIndeks,
            int indeksKonca
    ) {
        int rozmiarLewejCzesci =
                srodkowyIndeks - indeksPoczatku + 1;

        int rozmiarPrawejCzesci =
                indeksKonca - srodkowyIndeks;

        int kopiaLewejCzesci[] =
                new int[rozmiarLewejCzesci];

        int kopiaPrawejCzesci[] =
                new int[rozmiarPrawejCzesci];

        for (int i = 0; i < rozmiarLewejCzesci; i++) {
            kopiaLewejCzesci[i] =
                    tablica[indeksPoczatku + i];
        }

        for (int i = 0; i < rozmiarPrawejCzesci; i++) {
            kopiaPrawejCzesci[i] =
                    tablica[srodkowyIndeks + i + 1];
        }

        int biezacyIndeksLewejCzesci = 0;
        int biezacyIndeksPrawejCzesci = 0;

        int biezacyIndeksWOryginalnejTablicy =
                indeksPoczatku;

        while (
                biezacyIndeksLewejCzesci
                        < rozmiarLewejCzesci
                        &&
                biezacyIndeksPrawejCzesci
                        < rozmiarPrawejCzesci
        ) {
            if (
                    kopiaLewejCzesci[
                            biezacyIndeksLewejCzesci
                    ]
                            >=
                    kopiaPrawejCzesci[
                            biezacyIndeksPrawejCzesci
                    ]
            ) {
                tablica[biezacyIndeksWOryginalnejTablicy] =
                        kopiaLewejCzesci[
                                biezacyIndeksLewejCzesci
                        ];

                biezacyIndeksLewejCzesci++;

            } else {
                tablica[biezacyIndeksWOryginalnejTablicy] =
                        kopiaPrawejCzesci[
                                biezacyIndeksPrawejCzesci
                        ];

                biezacyIndeksPrawejCzesci++;
            }

            biezacyIndeksWOryginalnejTablicy++;
        }

        while (
                biezacyIndeksLewejCzesci
                        < rozmiarLewejCzesci
        ) {
            tablica[biezacyIndeksWOryginalnejTablicy] =
                    kopiaLewejCzesci[
                            biezacyIndeksLewejCzesci
                    ];

            biezacyIndeksLewejCzesci++;
            biezacyIndeksWOryginalnejTablicy++;
        }

        while (
                biezacyIndeksPrawejCzesci
                        < rozmiarPrawejCzesci
        ) {
            tablica[biezacyIndeksWOryginalnejTablicy] =
                    kopiaPrawejCzesci[
                            biezacyIndeksPrawejCzesci
                    ];

            biezacyIndeksPrawejCzesci++;
            biezacyIndeksWOryginalnejTablicy++;
        }
    }
}
            double Ey
    ) {
        double fa = funkcja(a);
        double fb = funkcja(b);

        // Na końcach przedziału funkcja musi mieć różne znaki.
        if (fa * fb > 0) {
            System.out.println(
                    "Błąd: funkcja na końcach przedziału "
                    + "musi mieć różne znaki."
            );

            return Double.NaN;
        }

        if (fa == 0) {
            return a;
        }

        if (fb == 0) {
            return b;
        }

        double x = (a + b) / 2.0;
        int liczbaIteracji = 0;
        int maksymalnaLiczbaIteracji = 1000;

        while (liczbaIteracji < maksymalnaLiczbaIteracji) {
            x = (a + b) / 2.0;

            double fx = funkcja(x);

            liczbaIteracji++;

            System.out.println(
                    "Iteracja " + liczbaIteracji
                    + ": a = " + a
                    + ", b = " + b
                    + ", x = " + x
                    + ", f(x) = " + fx
            );

            // Warunki zakończenia obliczeń
            if (bezwzgledna(b - a) / 2.0 <= Ex
                    || bezwzgledna(fx) <= Ey) {
                break;
            }

            if (fa * fx < 0) {
                b = x;
                fb = fx;
            } else {
                a = x;
                fa = fx;
            }
        }

        System.out.println("Liczba iteracji: " + liczbaIteracji);

        return x;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        double Ex;
        double Ey;

        do {
            System.out.print("Podaj dodatnią dokładność Ex: ");
            Ex = scanner.nextDouble();

            if (Ex <= 0) {
                System.out.println("Ex musi być większe od zera.");
            }
        } while (Ex <= 0);

        do {
            System.out.print("Podaj dodatnią dokładność Ey: ");
            Ey = scanner.nextDouble();

            if (Ey <= 0) {
                System.out.println("Ey musi być większe od zera.");
            }
        } while (Ey <= 0);

        System.out.print("Podaj początek przedziału a: ");
        double a = scanner.nextDouble();

        System.out.print("Podaj koniec przedziału b: ");
        double b = scanner.nextDouble();

        if (a > b) {
            double temp = a;
            a = b;
            b = temp;
        }

        double wynik = metodaBisekcji(a, b, Ex, Ey);

        if (!Double.isNaN(wynik)) {
            System.out.println();
            System.out.println("Przybliżony pierwiastek: " + wynik);
            System.out.println("Wartość funkcji: " + funkcja(wynik));
        }

        scanner.close();
    }
}