izapr_Zapocet_Class

package zapocettest01;

import java.util.Locale;

/**
 * Trida Matice bude obsahovat nekolik zakladnich operaci s dvojrozmernym polem.
 *
 */
public class Matice {

    /**
     * TODO Doplnte konstanty, ktere budou definovat pripustny maximalni rozmer
     * matice
     */
    public final static int MaxRadek = 10;
    public final static int MaxSloupec = 10;
    /**
     * TODO Doplnte atributy tridy Matice
     */
    public final double[][] pole;
    private final int pocetRadku;
    private final int pocetSloupcu;

    /**
     * TODO Upravte konstruktor tridy Matice tak, aby inicializoval obdelnikovou
     * matici
     */
    public Matice(int pocetRadku, int pocetSloupcu) {
        if (0 < pocetRadku && 0 < pocetSloupcu && pocetRadku <= MaxRadek && pocetSloupcu <= MaxSloupec) {
            this.pole = new double[pocetRadku][pocetSloupcu];
            this.pocetRadku = pocetRadku;
            this.pocetSloupcu = pocetSloupcu;
        } else {
            this.pole = null;
            this.pocetRadku = 0;
            this.pocetSloupcu = 0;
        }
    }

    /**
     * TODO Doplnte konstruktor ctvercove matice
     */
    public Matice(int n) {
        this(n, n);
    }

    /**
     * Metoda vytvorPodleIndexu poskytne novy objekt typu Matice a provede
     * inicializaci prvku matice systematickym obsahem tak, ze hodnota desitek
     * bude rovna cislu radku a hodnota jednotek bude rovna cislu sloupce.
     *
     * TODO Doplnte implementaci metodu vytvorPodleIndexu
     *
     * @param pocetRadku kladne cislo s horizontalnim rozmerem matice
     * @param pocetSloupcu kladne cislo s vertikalnim rozmerem matice
     *
     * @return vraci referenci na novy objekt typu Matice *
     */
    public static Matice vytvorPodleIndexu(int pocetRadku, int pocetSloupcu) {
        if (pocetRadku >= 0 && pocetSloupcu >= 0) {
            Matice m = new Matice(pocetRadku, pocetSloupcu);
            for (int i = 0; i < pocetRadku; i++) {
                for (int j = 0; j < pocetSloupcu; j++) {
                    m.pole[i][j] = (i + (j * 0.1));
                }
            }
            return m;
        } else {
            return null;
        }

    }

    /**
     * Metoda dejSloupec doda kopii sloupce, ktery bude urcen parametrem metody
     *
     * TODO Implementujte metodu dejSloupec
     */

    /**
     * temp - Dočasné pole pro uložení sloupce.
     * @param sloupec
     * @return vrací kopi sloupce
     */
    public double[] dejSloupec(int sloupec) {
        if (sloupec >= 0 && sloupec <= pocetSloupcu) {
            double[] temp = new double[pocetRadku];
            for (int i = 0; i < pocetRadku; i++) {
                temp[i] = pole[i][sloupec];
            }
            return temp;
        }
        else
        {
            return null;
        }
    }

    /**
     * Metoda dejVedelsiDiagonalu doda kopii vedlejsi diagonaly
     *
     * TODO Implementujte metodu dejVedelsiDiagonalu
     */
    public double[] dejVedlejsiDiagonalu() {
       int delka = (this.pole.length < this.pole[0].length) ? this.pole.length : this.pole[0].length;
       double[] temp = new double[delka];
        for (int i = 0; i < delka; i++) {
            temp[i] = this.pole[i][delka-i-1];
        }
        return temp;
    }

    /**
     * Metoda vraci transpondovanou matice
     *
     * TODO Doplnte implementaci transponzice obdelnikove matice
     *
     */
    public final Matice transpose() {
        Matice m = new Matice(pocetSloupcu, pocetRadku);
        for (int i = 0; i < m.pocetRadku; i++) {
            for (int j = 0; j < m.pocetSloupcu; j++) {
                m.pole[i][j] = this.pole[j][i];
            }
        }
        return m;
    }

    /**
     * Standardni prekryta metoda toString sestavi text s prvky matice
     *
     * @return
     */
    @Override
    public final String toString() {
        return toString("%5.2f");
    }

    /**
     * Metoda poskytne textovy retezec s naformatovanymi hodnotami prvku matice.
     *
     * TODO Opravte sestaveni vystupniho retezce podle vasich atributu
     *
     */
    public final String toString(String format) {
        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < this.pocetRadku; i++) {
            for (int j = 0; j < this.pocetSloupcu; j++) {
                buffer.append(String.format(Locale.ENGLISH, format, pole[i][j]));
            }
            if (i < this.pocetRadku - 1) {
                buffer.append("\n");
            }
        }
        return buffer.toString();
    }

    public void naplnMatici(int min, int max)
    {
        for (int i = 0; i < pole.length; i++) {
            for (int j = 0; j < pole[0].length; j++) {
                pole[i][j] = (double) Math.round(Math.random() * (max-min) + min);
            }
        }
    }

}