/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package semestralni.prace.pkg2014;

/**
 *
 * @author Tegaf
 */
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.Random;
import java.util.Scanner;
import static semestralni.prace.pkg2014.SemestralniPrace2014.transponuj;
import static semestralni.prace.pkg2014.SemestralniPrace2014.vypis;

public class novyMain {

    private static double[][] matice = null;
    private static double[][] matice1 = null;
    private static double[][] matice2 = null;
    private static double[][] maticeVysledna = null;
    private static boolean sKolika;
    private static boolean zapis;
    private static double det;

    public static void main(String[] args) {
        System.out.println("-------------------------------------------");
        System.out.println("|Vítejte v programu na operace s maticemi!|");
        centralniCyklus:
        do {
            /* V tedo metode zadejMatici vybirame, odkud matici chceme vzít.
             Můžeme si vybrat mezi: ze souboru, ručně nebo náhodně*/
            zadejMaticiProPracu();

            /* V tedo metode zpracovaniZadanychMatic vybirame, co chceme
             s danou maticí/maticemi dělat. Menu nám automatovky vybírá pouze ty
             operace, ktere dana matice může vykonat*/
            zpracovaniZadanychMatic();
            /* V tedo metode ulozitMaticiAVybratCoDal vybirame, jak chceme provedene
             operace ukončit.Buď uložíme matici, nebo začneme znova nebo ukoncime program*/
            ulozitMaticiAVybratCoDal();
        } while (true);
    }

    private static void ulozitMaticiAVybratCoDal() {
        ulozitMaticiAVybratCoDal:
        do {
            System.out.println("Nakonec vyberte co na záver chcete udělat:");
            System.out.println("1 -> Uložit výslednou matici\n"
                    + "2 -> Zadat novou matici\n"
                    + "3 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    System.out.println("Zadej jaké má mít soubor jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), maticeVysledna);
                    break;
                case 2:
                    double[][] matice = null;
                    double[][] matice1 = null;
                    double[][] matice2 = null;
                    double[][] maticeVysledna = null;
                    break ulozitMaticiAVybratCoDal;
                case 3:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static void zadejMaticiProPracu() {
        uzProvedUkon: //Cyklus pro presunuti na vypocty
        do {

            hlavniCyklus: //Cyklus pro zadání matice
            do {
                System.out.println("-------------------------------------------");
                System.out.println("");
                System.out.println("HLAVNÍ MENU");
                System.out.println("Zadejte, kde budeme matici hledat:");
                System.out.println("1 -> Ze souboru\n"
                        + "2 -> Ručně \n"
                        + "3 -> Náhodně\n"
                        + "4 -> Konec programu");
                System.out.println("");
                System.out.print("Vybírám si:");
                switch (nactiInt()) {
                    case 1:
                        souborCyklus: //Cyklus pro nacitani ze souboru
                        do {
                            System.out.println("-------------------------------------------");
                            System.out.println("");
                            System.out.println("MENU NAČÍTÁNÍ");
                            System.out.println("Nyní musíme upřesnit zadání:");
                            System.out.println("1 -> Zadat jméno souboru\n"
                                    + "2 -> Zjistit požadovaný formát souboru \n"
                                    + "3 -> Vrátit se do hlavního menu\n"
                                    + "4 -> Konec programu");
                            System.out.println("");
                            System.out.print("Vybírám si:");
                            switch (nactiInt()) {

                                case 1:
                                    sKolika = vyber1nebo2();
                                    if (sKolika == true) {
                                        System.out.println("-------------------------------------------");
                                        System.out.println("Soubor s maticí:");
                                        matice = nactiZeSouboru(nactiString());
                                        if (matice == null) {
                                            break;
                                        }
                                        break uzProvedUkon;
                                    } else {
                                        System.out.println("-------------------------------------------");
                                        System.out.println("Soubor s první maticí:");
                                        matice1 = nactiZeSouboru(nactiString());
                                        if (matice1 == null) {
                                            break;
                                        }
                                        System.out.println("Soubor kde mám druhou matici:");
                                        matice2 = nactiZeSouboru(nactiString());
                                        if (matice2 == null) {
                                            break;
                                        }
                                        break uzProvedUkon;
                                    }

                                case 2:
                                    System.out.println("-------------------------------------------");
                                    System.out.println("Spravny format souboru je, že čísla jsou oddělena\n"
                                            + " mezerami a co řádek v souboru, to řádek matice.");
                                    System.out.println("Příklad:");
                                    System.out.println("");
                                    System.out.println("3.3 5 7 1 5");
                                    System.out.println("2.7 5 6 7 5");

                                    break;
                                case 3:
                                    break souborCyklus;

                                case 4:
                                    break hlavniCyklus;
                                default:
                                    System.out.println("___________________________________________");
                                    System.out.println("Zvolená možnost není platná. Zadejte novou.");

                            }
                        } while (true);
                        break;
                    case 2:

                        sKolika = vyber1nebo2();
                        if (sKolika == true) {
                            matice = rucneMatici();
                            break uzProvedUkon;
                        } else {
                            matice1 = rucneMatici();
                            matice2 = rucneMatici();
                            break uzProvedUkon;
                        }
                    case 3:
                        sKolika = vyber1nebo2();
                        if (sKolika == true) {
                            matice = vygenMatici();
                            while (matice == null) {
                                matice = vygenMatici();
                            }
                            break uzProvedUkon;
                        } else {
                            matice1 = vygenMatici();
                            while (matice1 == null) {
                                matice1 = vygenMatici();
                            }
                            matice2 = vygenMatici();
                            while (matice2 == null) {
                                matice2 = vygenMatici();
                            }
                            break uzProvedUkon;
                        }
                    case 4:
                        break hlavniCyklus;
                    default:
                        System.out.println("___________________________________________");
                        System.out.println("Zvolená možnost není platná. Zadejte novou.");

                }

            } while (true);

            System.out.println("-------------------------------------------");
            System.out.println("              Nashle příště!               ");
            System.out.println("-------------------------------------------");
            System.out.println("|                THE END                  |");
            System.out.println("-------------------------------------------");
            System.exit(0);

        } while (true);

    }

    private static void zpracovaniZadanychMatic() {
        if (sKolika == true) //*Pracujeme s jednou maticí
        {
            System.out.println("");
            System.out.println("");
            System.out.println("-------------------------------------------");
            System.out.println("--        Jdeme na práci s maticí        --");
            System.out.println("-------------------------------------------");
            System.out.println("");
            System.out.println("MATICE");
            vypis(matice);
            System.out.println("");
            System.out.println("-------------------------------------------");
            boolean ctvercova = jeCtvercova(matice);
            if (ctvercova == true)//Nase jedna matice je čtvercová
            {
                if (determinant(matice) == 0)// Naše jedna čtvercová matice je singularní
                {
                    jednaCtvercovaSing();
                } else// Naše jedna čtvercová matice je regulerni
                {
                    jednaCtvercovaReg();

                }
            } else // Naše jedna obdélníková matice
            {
                jednaObd();

            }

        } else if (sKolika == false) //Počítáme se dvěmi maticemi
        {
            int radkyM1 = matice1[0].length;
            int sloupceM1 = matice1.length;
            int radkyM2 = matice2[0].length;
            int sloupceM2 = matice2.length;
            System.out.println("");
            System.out.println("");
            System.out.println("-------------------------------------------");
            System.out.println("--       Jdeme na práci s maticemi       --");
            System.out.println("-------------------------------------------");
            System.out.println("");
            System.out.println("MATICE A");
            vypis(matice1);
            System.out.println("MATICE B");
            vypis(matice2);
            System.out.println("");
            System.out.println("-------------------------------------------");
            System.out.println("MENU OPERACÍ");
            if (radkyM1 == radkyM2 && sloupceM1 == sloupceM2) //Matice se velikosti rovnaji
            {
                dveCtvercova();

            } else if (radkyM2 == sloupceM1) //podminka nasobeni B*A
            {
                dveNasobBA();

            } else if (radkyM1 == sloupceM2) //Podmínka násobení A*B
            {
                dveNasobAB();

            } else {

                ostatniMatice();//ostatní

            }
        } else {
            System.out.println("-------------------------------------------");
            System.out.println("          Vyskytla se divná věc..          ");
            System.out.println("-------------------------------------------");
            System.out.println("|                THE END                  |");
            System.out.println("-------------------------------------------");
            System.exit(0);
        }

    }

    private static void ostatniMatice() {
        ostatni:
        do {
            System.out.println("");
            System.out.println("S temito maticemi nemůžu provést další operace...");
            System.out.println("");
            System.out.println("1 -> Uložit matice a ukončit program\n"
                    + "2 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    System.out.println("Zadej jaké má mít soubor MATICE A jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice1);
                    System.out.println("");
                    System.out.println("Zadej jaké má mít soubor MATICE B jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice2);

                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                case 2:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static void jednaCtvercovaSing() {
        jedCtSi:
        do {
            System.out.println("MENU OPERACÍ");

            System.out.println("Co chceš s touto čvercovou maticí udělat:");
            System.out.println("1 -> Vypočítat determinant\n"
                    + "2 -> Transponovat matici\n"
                    + "3 -> Uložit matici\n"
                    + "4 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");

            switch (nactiInt()) {
                case 1:
                    det = determinant(matice);
                    System.out.println("Dereminant matice je:" + det);
                    System.out.println("S derminantem již není co udělat."
                            + " Zadej co chceš udělat s původní maticí:");
                    System.out.println("");
                    break;
                case 2:
                    matice = transponujMatici(matice);
                    System.out.println("Transponovaná matice:");
                    vypis(matice);
                    break jedCtSi;
                case 3:
                    System.out.println("Zadej jaké má mít soubor jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice);

                    break;
                case 4:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);

    }

    private static void jednaCtvercovaReg() {
        jedCtRe:
        do {
            System.out.println("MENU OPERACÍ");
            System.out.println("Co chceš s touto čvercovou maticí udělat:");
            System.out.println("1 -> Vypočítat determinant\n"
                    + "2 -> Vypočítat inverzní matici\n"
                    + "3 -> Transponovat matici\n"
                    + "4 -> Uložit matici\n"
                    + "5 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");

            switch (nactiInt()) {
                case 1:
                    det = determinant(matice);
                    System.out.println("Dereminant matice je:" + det);
                    System.out.println("S derminantem již není co udělat."
                            + " Zadej co chceš udělat s původní maticí:");
                    System.out.println("");
                    break;
                case 2:
                    matice = inverzniMatice(matice);
                    System.out.println("Inverzní matice:");
                    vypis(matice);
                    break jedCtRe;
                case 3:
                    matice = transponujMatici(matice);
                    System.out.println("Transponovaná matice:");
                    vypis(matice);
                    break jedCtRe;
                case 4:
                    System.out.println("Zadej jaké má mít soubor jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice);

                    break;
                case 5:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static void jednaObd() {
        jednaObd:
        do {
            System.out.println("MENU OPERACÍ");
            System.out.println("Co chceš s touto obdelníkovou maticí udělat:");
            System.out.println("1 -> Transponovat matici\n"
                    + "2 -> Uložit matici\n"
                    + "3 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    matice = transponujMatici(matice);
                    System.out.println("Transponovaná matice:");
                    vypis(matice);
                    break jednaObd;
                case 2:
                    System.out.println("Zadej jaké má mít soubor jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice);
                    break;
                case 3:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);

                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static void dveCtvercova() {
        dveCtvercova:
        do {
            System.out.println("1 -> Sčítání dvou matic\n"
                    + "2 -> Odčítání matice A od B\n"
                    + "3 -> Odčítání matice B od A\n"
                    + "4 -> Násonbení matice A * matice B\n"
                    + "5 -> Násonbení matice B * matice A\n"
                    + "6 -> Uložit matice\n"
                    + "7 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    maticeVysledna = sectiMatice(matice1, matice2);
                    System.out.println("Sečtené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveCtvercova;
                case 2:
                    maticeVysledna = odectiMatice(matice1, matice2);
                    System.out.println("Odečtené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveCtvercova;
                case 3:
                    maticeVysledna = odectiMatice(matice2, matice1);
                    System.out.println("Odečtené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveCtvercova;
                case 4:
                    maticeVysledna = nasobMatice(matice1, matice2);
                    System.out.println("Znásobené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveCtvercova;
                case 5:
                    maticeVysledna = nasobMatice(matice2, matice1);
                    System.out.println("Znásobené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveCtvercova;
                case 6:
                    System.out.println("Zadej jaké má mít soubor MATICE A jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice1);
                    System.out.println("");
                    System.out.println("Zadej jaké má mít soubor MATICE B jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice2);
                    break;
                case 7:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static void dveNasobAB() {
        dveNasobAB:
        do {
            System.out.println("1 -> Násonbení matice A * matice B\n"
                    + "2 -> Uložit matice\n"
                    + "3 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    maticeVysledna = nasobMatice(matice1, matice2);
                    System.out.println("Znásobené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveNasobAB;
                case 2:
                    System.out.println("Zadej jaké má mít soubor MATICE A jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice1);
                    System.out.println("");
                    System.out.println("Zadej jaké má mít soubor MATICE B jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice2);
                    break;
                case 3:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static void dveNasobBA() {
        dveNasobBA:
        do {
            System.out.println("1 -> Násonbení matice B * matice A\n"
                    + "2 -> Uložit matice\n"
                    + "3 -> Konec programu");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    maticeVysledna = nasobMatice(matice2, matice1);
                    System.out.println("Znásobené matice dávají matici:");
                    vypis(maticeVysledna);
                    break dveNasobBA;
                case 2:
                    System.out.println("Zadej jaké má mít soubor MATICE A jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice1);
                    System.out.println("");
                    System.out.println("Zadej jaké má mít soubor MATICE B jméno:");
                    zapis = zapisMaticiDoSouboru(nactiString(), matice2);
                    break;
                case 3:
                    System.out.println("-------------------------------------------");
                    System.out.println("              Nashle příště!               ");
                    System.out.println("-------------------------------------------");
                    System.out.println("|                THE END                  |");
                    System.out.println("-------------------------------------------");
                    System.exit(0);
                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);
    }

    private static double determinant(double[][] ctvercovaMatice) {
        double det = 0;
        if (ctvercovaMatice.length == 1) {
            det = ctvercovaMatice[0][0];
            return det;
        }
        if (ctvercovaMatice.length == 2) {
            det = ctvercovaMatice[0][0] * ctvercovaMatice[1][1] - ctvercovaMatice[0][1] * ctvercovaMatice[1][0];
            return det;
        }
        for (int j = 0; j < ctvercovaMatice.length; j++) {
            double a[][] = new double[ctvercovaMatice.length - 1][ctvercovaMatice[0].length - 1];
            for (int k = 1; k < ctvercovaMatice.length; k++) {
                for (int l = 0; l < ctvercovaMatice[0].length; l++) {
                    if (l < j) {
                        a[k - 1][l] = ctvercovaMatice[k][l];
                    } else if (l > j) {
                        a[k - 1][l - 1] = ctvercovaMatice[k][l];
                    }
                }
            }
            det += ctvercovaMatice[0][j] * Math.pow(-1, (double) j) * determinant(a);
        }
        return det;
    }

    private static double[][] inverzniMatice(double[][] m) {
        int a = 1;
        int radky = m.length;
        int sloupce = m[radky - 1].length;
        double deSub = 0;
        double p[][] = new double[radky][sloupce];
        double det = determinant(m);//determinant matice

        for (int r = 0; r < sloupce; r++) {
            for (int s = 0; s < radky; s++) {
                deSub = determinant(subMatice(m, r, s));/*determinant
                 ze submatice a submatice z z radku a sloupce ktery vynecháme
                 */

                double f = ((deSub / det)) * 100;
                f = Math.round(f);
                f = f / 100;
                p[r][s] = f * a;
                a = -a;//kazdy koeficient mění zneménko
            }
        }
        p = transponujMatici(p);//nakonec se matice transponuje
        return p;
    }

    private static boolean jeCtvercova(double[][] m) {
        if (m.length != m[0].length) {
            return false;
        }
        return true;
    }

    private static int nactiInt() {
        Scanner sc = new Scanner(System.in);
        while (!sc.hasNextInt()) {
            System.out.println("Buďto jste nezadal/a číslo nebo je zadané číslo mimo dovolené meze. Zadejte nové.");
            sc.nextLine();
        }
        int cislo = sc.nextInt();
        sc.nextLine();
        return cislo;
    }

    private static double[][] nasobMatice(double[][] m1, double[][] m2) {
        double[][] znasobeno = new double[m1.length][m2[0].length];
        for (int j = 0; j < m1.length; j++) {
            for (int k = 0; k < m2[0].length; k++) {
                znasobeno[j][k] = 0;
                for (int l = 0; l < m1[0].length; l++) {
                    znasobeno[j][k] += m1[j][l] * m2[l][k];
                }
            }
        }
        return znasobeno;
    }

    private static double nactiDouble() {
        Scanner sc = new Scanner(System.in);
        while (!sc.hasNextDouble()) {
            System.out.println("Buďto jste nezadal/a číslo nebo je zadané číslo mimo dovolené meze. Zadejte nové.");
            sc.nextLine();
        }
        double cislo = sc.nextDouble();
        sc.nextLine();
        return cislo;
    }

    private static String nactiString() {
        Scanner sc = new Scanner(System.in);
        return sc.nextLine();
    }

    private static double[][] nactiZeSouboru(String jmenoSouboru) {
        try {
            FileInputStream fis = new FileInputStream(jmenoSouboru);
            Scanner sc = new Scanner(fis);
            sc.useLocale(Locale.US);
            int pocetRadku = sc.nextInt();
            int pocetSloupcu = sc.nextInt();
            double[][] matice = new double[pocetRadku][pocetSloupcu];
            for (int r = 0; r < pocetRadku; r++) {
                for (int s = 0; s < pocetSloupcu; s++) {
                    sc.useLocale(Locale.US);
                    matice[r][s] = sc.nextDouble();
                }
            }
            System.out.println("==============================");
            vypis(matice);
            System.out.println("==============================");

            fis.close();
            return matice;
        } catch (IOException ex) {
            System.out.println("__________________________________________");
            System.out.println("Soubor s tímto jménem neexistuje");

            return null;
        }
    }

    private static double[][] odectiMatice(double[][] m1, double[][] m2) {

        double[][] odecteno = new double[m1.length][m1[0].length];
        for (int j = 0; j < m1.length; j++) {
            for (int k = 0; k < m1[0].length; k++) {
                odecteno[j][k] = m1[j][k] - m2[j][k];
            }
        }
        return odecteno;
    }

    private static double[][] rucneMatici() {
        double[][] m;
        System.out.println("-------------------------------------------");
        System.out.println("Nezapomente,desetiné číslo je s čárkou 3,3");
        System.out.println("Matice má:");
        System.out.println("");
        int a, b;
        System.out.print("Řádků:");
        a = nactiInt();
        System.out.print("Sloupců:");
        b = nactiInt();

        while (a <= 0 || b <= 0) {
            System.out.println("__________________________________________");
            System.out.println("Čísla musí být větší než 0. Znova.");
            System.out.print("Řádků:");
            a = nactiInt();
            System.out.print("Sloupců:");
            b = nactiInt();
        }
        System.out.println("-------------------------------------------");
        System.out.println("Nyní zadej " + (a * b) + " čísel/a (zadáváte v řádkách)");
        m = new double[a][b];
        System.out.println("První řádek:");
        for (int r = 0; r < a; r++) {
            for (int s = 0; s < b; s++) {
                m[r][s] = nactiDouble();

            }
            if (r == a - 1) {
            } else {
                System.out.println("Další řádek");
            }

        }
        System.out.println("==============================");
        vypis(m);
        System.out.println("==============================");
        return m;
    }

    public static double[][] sectiMatice(double[][] m1, double[][] m2) {
        double[][] secteno = new double[m1.length][m2[0].length];
        for (int j = 0; j < m1.length; j++) {
            for (int k = 0; k < m1[0].length; k++) {
                secteno[j][k] = m1[j][k] + m2[j][k];
            }
        }
        return secteno;
    }

    private static double[][] subMatice(double[][] m, int R, int S) {
        double[][] vysledna = new double[m.length - 1][m[0].length - 1];
        int k = 0, l = 0;
        for (int r = 0; r < m.length; r++) {
            if (r != R) {
                for (int s = 0; s < m[0].length; s++) {
                    if (s != S) {
                        vysledna[k][l++] = m[r][s];
                    }
                }
                l = 0;
                k++;
            }
        }
        return vysledna;
    }

    public static double[][] transponujMatici(double[][] m) {
        double[][] transponovanaMatice = new double[m[0].length][m.length];
        for (int r = 0; r < transponovanaMatice.length; r++) {
            for (int s = 0; s < transponovanaMatice[r].length; s++) {
                transponovanaMatice[r][s] = m[s][r];
            }
        }
        return transponovanaMatice;
    }

    private static double[][] vygenMatici() {
        Random rd = new Random();
        int a, b;
        double rozsahD = 0;
        int rozsahI = 0;
        double[][] matice = null;
        System.out.println("-------------------------------------------");
        System.out.println("1 -> Chci celočíselnou matici\n2 -> Chci matici s reálnými čísly");
        System.out.println("");
        System.out.print("Vybírám si:");
        switch (nactiInt()) {
            case 1:
                System.out.println("");
                System.out.print("Řádků:");
                a = nactiInt();
                System.out.print("Sloupců:");
                b = nactiInt();
                System.out.print("Rozsah: 0 ----> vaše číslo:");
                rozsahI = nactiInt();
                while (a <= 0 || b <= 0 || rozsahI <= 0) {
                    System.out.println("__________________________________________");
                    System.out.println("Čísla musí být větší než 0. Znova.");
                    System.out.print("Řádků:");
                    a = nactiInt();
                    System.out.print("Sloupců:");
                    b = nactiInt();
                    System.out.print("Rozsah: 0 ----> >vaše číslo<:");
                    rozsahI = nactiInt();
                }
                matice = new double[a][b];
                for (int r = 0; r < a; r++) {
                    for (int s = 0; s < b; s++) {
                        matice[r][s] = (double) rd.nextInt(rozsahI);
                    }
                }

                break;
            case 2:
                System.out.println("");
                System.out.print("Řádků:");
                a = nactiInt();
                System.out.print("Sloupců:");
                b = nactiInt();
                System.out.print("Rozsah: 0 ----> vaše číslo:");
                rozsahD = nactiDouble();
                while (a <= 0 || b <= 0 || rozsahD <= 0) {
                    System.out.println("__________________________________________");
                    System.out.println("Čísla musí být větší než 0. Znova.");
                    System.out.print("Řádků:");
                    a = nactiInt();
                    System.out.print("Sloupců:");
                    b = nactiInt();
                    System.out.print("Rozsah: 0 ----> >vaše číslo<:");
                    rozsahD = nactiDouble();
                }
                matice = new double[a][b];
                for (int r = 0; r < a; r++) {
                    for (int s = 0; s < b; s++) {
                        double f = (Math.random() * rozsahD) * 100;
                        f = Math.round(f);
                        matice[r][s] = f / 100;
                    }
                }
                break;
            default:
                System.out.println("___________________________________________");
                System.out.println("Zvolená možnost není platná. Zadejte novou.");
                return null;
        }

        System.out.println("==============================");
        vypis(matice);
        System.out.println("==============================");
        return matice;

    }

    private static boolean vyber1nebo2() {
        VyberCyklus:
        do {
            System.out.println("-------------------------------------------");
            System.out.println("Budeš pracovat s jednou nebo se dvěmi maticemi?\n"
                    + "1 -> S jednu\n"
                    + "2 -> Se dvěmi");
            System.out.println("");
            System.out.print("Vybírám si:");
            switch (nactiInt()) {
                case 1:
                    return true;

                case 2:
                    return false;

                default:
                    System.out.println("___________________________________________");
                    System.out.println("Zvolená možnost není platná. Zadejte novou.");
                    break;
            }
        } while (true);

    }

    private static void vypis(double[][] m) {
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m[0].length; j++) {
                System.out.print("[" + m[i][j] + "] ");
            }
            System.out.println();
        }
    }

    private static boolean zapisMaticiDoSouboru(String jmenoSouboru, double[][] m) {
        PrintWriter out = null;
        try {
            out = new PrintWriter(new FileWriter(jmenoSouboru));
            out.print(m.length + " " + m[0].length + "\n\n");
            for (int r = 0; r < m.length; r++) {
                for (int s = 0; s < m[r].length; s++) {
                    out.print(m[r][s] + " ");
                }
                out.println();
            }
            System.out.println("Uložená matice:");
            System.out.println("==============================");
            vypis(m);
            System.out.println("==============================");
            return true;
        } catch (IOException ex) {
            System.out.println("Chyba zapisu do souboru!");
            return false;
        } finally {
            out.close();
        }
    }

}