Dvourozměrné pole - konzole

Následující zdrojový kód je kompletací předešlých kódů programu DvourozmernePole, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace DvourozmernePole
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Deklarace: 'pocetRadku' ... počet řádků matice; 'pocetSloupcu' ... počet sloupců matice; 
             * 'Max' ... konstantní hodnota maximální velikosti matice pro každou osu (pro 1. vertikální osu 
             * představuje maximální počet řádků matice, pro 2. osu představuje maximální počet sloupců matice; 
             * 'minHodnota' ... přípustná minimální hodnota (dolní mez) prvků matice; 'maxHodnota' ... přípustná 
             * maximální hodnota (horní mez) prvků matice; 'poradiRadku' ... pořadí řádku prvku (využití pro
             * vyhledání minima a maxima matice); 'poradiSloupce' ... pořadí sloupce prvku */
 
            // Maximální velikost matice pro každou osu, tj. řádky, nebo sloupce
            const int Max = 10;
 
            // Metoda pro inicializaci atributů matice a jejich případnou změnu
            Inicializace(Max, out int minHodnota, out int maxHodnota, out int pocetRadku, 
                out int pocetSloupcu, out int[,] pole);
 
            /* Zavolání metody pro plnění matice (náhodnými čísly, jednotlivě zadanými hodnotami, 
             * plnění nulami) */
            PlnitPole(pocetRadku, pocetSloupcu, minHodnota, maxHodnota, pole);
 
            // Výpis matice po jednotlivých řádcích, kde jednotlivé prvky jsou odděleny čárkami
            Console.WriteLine("Výpis matice: ");
            ZobrazitPole(pocetRadku, pocetSloupcu, pole);
 
            // Výpis hodnoty minima matice, včetně jeho pozice v matici
            Console.WriteLine("Minimum v matici: {0} na pozici [{1},{2}] ", 
                MinimumVPoli(pocetRadku, pocetSloupcu, pole, out int indexRadku, out int indexSloupce), indexRadku, indexSloupce);
 
            // Výpis hodnoty maxima matice, včetně jeho pozice v matici
            Console.WriteLine("Maximum v matici: {0} na pozici [{1},{2}] ",
                MaximumVPoli(pocetRadku, pocetSloupcu, pole, out indexRadku, out indexSloupce), indexRadku, indexSloupce);
 
            // Výpis průměru všech prvků matice
            Console.WriteLine("Průměr prvků matice: " + PrumerPole(pocetRadku, pocetSloupcu, pole));
 
            // Vzestupné řazení prvků v jednotlivých řádcích matice podle metody Bubble Sort
            SeraditPole(pocetRadku, pocetSloupcu, pole);
 
            // Výpis seřazené matice
            Console.WriteLine("Seřazená matice: ");
           ZobrazitPole(pocetRadku, pocetSloupcu, pole);
            
            // Transpozice matice podle hlavní diagonály
            HlavniTranspozice(pocetRadku, pocetSloupcu, pole);
 
            // Výpis transponované matice podle hlavní diagonály
            Console.WriteLine("Transpozice matice podle hlavní diagonály: ");
            ZobrazitPole(pocetRadku, pocetSloupcu, pole);
 
            // Transpozice matice podle vedlejší diagonály
            VedlejsiTranspozice(pocetRadku, pocetSloupcu, pole);
 
            // Výpis transponované matice podle vedlejší diagonály
            Console.WriteLine("Transpozice matice podle vedlejší diagonály: ");
            ZobrazitPole(pocetRadku, pocetSloupcu, pole);
 
            // Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
        #region Nastavení atributů pole
 
        /// <summary>
        /// Metoda pro inicializaci a změnu atributů pole 
        /// </summary>
        static void Inicializace(int Max, out int minHodnota, out int maxHodnota, out int pocetRadku, 
            out int pocetSloupcu, out int[,] pole)
        {
            // Dolní mez, které může nabýt prvek matice
            minHodnota = 1;
 
            // Horní mez, které může nabýt prvek matice
            maxHodnota = 100;
 
            // Počet řádků je roven horní mezi přípustného počtu řádků
            pocetRadku = Max;
 
            // Počet sloupců je roven horní mezi přípustného počtu sloupců
            pocetSloupcu = Max;
 
            // Výpis stávajících atributů matice
            Console.WriteLine("Matice je nastavena:" + Environment.NewLine +
                " Počet řádků: {0} \n Počet sloupců: {1} \n Dolní mez: {2} \n Horní mez: {3}",
                    pocetRadku, pocetSloupcu, minHodnota, maxHodnota);
 
            // Index pro změnu atributů matice
            int zmena;
            do
            {
                // Výzva ke změně atributů matice
                Console.Write("Změnit nastavení atributů matice? (0...Ne, 1...Ano): ");
 
                // Načtení hodnoty, zda má dojít ke změně
                int.TryParse(Console.ReadLine(), out zmena);
 
                // Pokud má být atribut matice změněn, pak prováděj...
                while (zmena == 1)
                {
                    // Index atributu ke změně
                    int atribut;
                    do
                    {
                        // Výzva k zadání indexu změny atributu matice
                        Console.Write("Zvolte změnu atributu matice " +
                            "(0...Počet řádků, 1...Počet sloupců, 2...Dolní mez, 3...Horní mez): ");
 
                        // Načtení indexu změny atributu
                        int.TryParse(Console.ReadLine(), out atribut);
                    }
 
                    /* Načtení indexu změny atributu matice proběhne znovu, pokud nebyl 
                     * zadán validní index změny atributu */
                    while ((atribut != 0) && (atribut != 1) && (atribut != 2) && (atribut != 3));
 
                    // Přepnutí do změny příslušného atributu matice
                    switch (atribut)
                    {
                        // Změna počtu řádků matice
                        case 0:
                            // Zavolání metody s celočíselným návratem pro změnu počtu řádků
                            pocetRadku = RozmerPole(pocetRadku, Max, "řádků");
                            break;
 
                        // Změna počtu sloupců matice
                        case 1:
                            // Zavolání metody s celočíselným návratem pro změnu počtu sloupců
                            pocetSloupcu = RozmerPole(pocetSloupcu, Max, "sloupců");
                            break;
                        // Změna dolní meze prvků matice
                        case 2:
                            /* Zavolání metody s celočíselný návratem pro změnu dolní meze, které 
                             * mohou nabývat prvky matice */
                            minHodnota = DolniMez(minHodnota, maxHodnota);
                            break;
                        // Změna horní meze prvků matice
                        case 3:
                            /* Zavolání metody s celočíselným návratem pro změnu horní meze, které 
                             * mohou nabývat prvky matice */
                            maxHodnota = HorniMez(minHodnota, maxHodnota);
                            break;
                    }
 
                    // Výzva ke změně atributů matice
                    Console.Write("Změnit další nastavení atributů matice? (0...Ne, 1...Ano): ");
                    // Načtení hodnoty, zda má dojít k další změně
                    int.TryParse(Console.ReadLine(), out zmena);
                }
            }
            // Pokud načtená hodnota nebyla validní, cyklus zadání je znovu opakován
            while ((zmena < 0) || (zmena > 1));
 
            // Deklarace a vytvoření instance matice se zadanými rozměry (počtem prvků pro každou osu)
            pole = new int[pocetRadku, pocetSloupcu];
        }
 
        /// <summary>
        /// Metoda navracející velikost pole v ose
        /// </summary>
        /// <param name="velikost"> aktuální velikost matice v ose </param>
        /// <param name="max"> maximální velikost matice v ose </param>
        /// <returns> Velikost matice v ose </returns>
        static int RozmerPole(int velikost, int max, string text)
        {
            // Deklarace: 'novaHodnota' ... nová velikost matice v ose 
            int novaHodnota;
 
            // Vypsání stávající velikosti matice v ose
            Console.WriteLine("Stávající počet " + text + " matice {0}:", velikost);
 
            // Výzva k zadání velikosti matice v ose 
            Console.Write("Zadejte počet " + text + " matice (1 - {0}): ", max);
 
            // Načtení velikosti matice
            int.TryParse(Console.ReadLine(), out novaHodnota);
 
            // Pokud nová hodnota je větší než maximum, nebo menší než 1 ...
            if ((novaHodnota > max) || (novaHodnota < 1))
            {
                /* Přiřazení maximální velikosti matice do lokální proměnné určující 
                    * velikost matice v ose */
                novaHodnota = max;
                // Vypsání nové velikosti matice v ose
                Console.WriteLine("Redukce počtu " + text + " matice: {0}", novaHodnota);
            }
 
            // Pokud nová velikost matice není stejná jako stávající velikost v ose ...
            if (novaHodnota != velikost)
            {
                // Uložení nové velikosti matice do proměnné
                velikost = novaHodnota;
            }
 
            // Návrat metody
            return velikost;
        }
 
        /// <summary>
        /// Metoda navracející dolní mez intervalu přípustných hodnot prvků matice
        /// </summary>
        /// <param name="minHodnota"> dolní mez prvků matice </param>
        /// <param name="maxHodnota"> horní mez prvků matice </param>
        /// <returns> Dolní mez pro všechny prvky matice </returns>
        public static int DolniMez(int minHodnota, int maxHodnota)
        {
            // Deklarace: 'novaHodnota' ... nová dolní mez prvků matice
            int novaHodnota;
 
            // Výpis stávající hodnoty dolní meze
            Console.WriteLine("Dolní mez prvků pole: {0} (horní mez = {1})", minHodnota, maxHodnota);
 
            // Výzva k zadání nové dolní meze prvků matice
            Console.Write("Zadejte dolní mez prvků pole: ");
 
            // Načtení nové dolní meze prvků matice
            int.TryParse(Console.ReadLine(), out novaHodnota);
 
            // Pokud nová hodnota dolní meze je větší než horní mez, pak...
            if (novaHodnota > maxHodnota)
            {
                // Přiřazení horní meze do lokální proměnné určující dolní mez (horní a dolní mez budou stejné)
                novaHodnota = maxHodnota;
                // Výpis nové redukované dolní meze pro prvky matice
                Console.WriteLine("Redukce dolní meze prvků pole: {0}", novaHodnota);
            }
 
            // Pokud nová dolní mez prvků matice není stejná jako stávající dolní mez prvků matice, pak...
            if (novaHodnota != minHodnota)
            {
                // Přepsání stávající dolní meze prvků matice novou hodnotou
                minHodnota = novaHodnota;
            }
 
            // Návrat metody
            return minHodnota;
        }
 
 
        /// <summary>
        /// Metoda navracející horní mez intervalu přípustných hodnot prvků matice
        /// </summary>
        /// <param name="minHodnota"> dolní mez prvků matice </param>
        /// <param name="maxHodnota"> horní mez prvků matice </param>
        /// <returns> Horní mez pro všechny prvky matice </returns>
        static int HorniMez(int minHodnota, int maxHodnota)
        {
            // Deklarace: 'novaHodnota' ... nová horní mez prvků matice
            int novaHodnota;
 
            // Výpis stávající hodnoty horní meze
            Console.WriteLine("Horní mez prvků pole: {0} (dolní mez = {1})", maxHodnota, minHodnota);
 
            // Výzva k zadání nové horní meze prvků matice
            Console.Write("Zadejte horní mez prvků pole: ");
 
            // Načtení nové horní meze prvků matice
            int.TryParse(Console.ReadLine(), out novaHodnota);
 
            // Pokud nová hodnota horní meze je menší než dolní mez, pak...
            if (novaHodnota < minHodnota)
            {
                // Přiřazení dolní meze do lokální proměnné určující horní mez (horní a dolní mez budou stejné)
                novaHodnota = minHodnota;
                // Výpis nové redukované horní meze pro prvky matice
                Console.WriteLine("Redukce horní meze prvků pole: {0}", novaHodnota);
            }
 
            // Pokud nová horní mez prvků matice není stejná jako stávající horní mez prvků matice, pak...
            if (novaHodnota != maxHodnota)
            {
                // Přepsání stávající horní meze prvků matice novou hodnotou
                maxHodnota = novaHodnota;
            }
 
            // Návrat metody
            return maxHodnota;
        }
 
        #endregion Nastavení atributů pole
 
        #region Plnění pole
 
        /// <summary>
        /// Metoda volající některou z metod plnění matice
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="minHodnota"> dolní mez prvků matice </param>
        /// <param name="maxHodnota"> horní mez prvků matice </param>
        /// <param name="pole"> matice, která má být naplněna </param>
        static void PlnitPole(int m, int n, int minHodnota, int maxHodnota, int[,] pole)
        {
            /* Deklarace: 'zpusobPlneni' ... způsob plnění matice('0'...Náhodně, '1'...Jednotlivě, 
             * '2'...Nulovat) */
            int zpusobPlneni;
 
            do
            {
                // Výzva k zadání způsobu plnění matice
                Console.Write("Zvolte způsob plnění pole (0...Náhodně, 1...Jednotlivě, 2...Nulovat): ");
 
                // Načtení způsobu plnění
                int.TryParse(Console.ReadLine(), out zpusobPlneni);
            }
 
            // Načtení způsobu plnění proběhne znovu, pokud nebyl zadán validní celočíselný kód způsobu plnění
            while ((zpusobPlneni != 0) && (zpusobPlneni != 1) && (zpusobPlneni != 2));
 
            // Přepnutí na různý způsob plnění
            switch (zpusobPlneni)
            {
                // Plnění matice náhodnými čísly
                case 0:
                    // Zavolání metody pro plnění matice náhodnými čísly
                    NahodnePole(m, n, minHodnota, maxHodnota, pole);
                    break;
 
                // Plnění matice jednotlivými zadanými hodnotami uživatelem
                case 1:
                    // Volání metody pro plnění matice uživatelem zadanými čísly
                    PlnitJednotlive(m, n, minHodnota, maxHodnota, pole);
                    break;
 
                case 2:
                    // Volání metody, kdy všem prvkům matice je přiřazena hodnotu nula
                    NulovatPole(m, n, pole);
                    break;
            }
        }
 
        /// <summary>
        /// Metoda pro plnění matice náhodnými čísly
        /// </summary>
        /// <param name="m"> aktuální počet řádků matice </param>
        /// <param name="n"> aktuální počet sloupců matice </param>
        /// <param name="minHodnota"> dolní mez prvků matice </param>
        /// <param name="maxHodnota"> horní mez prvků matice </param>
        /// <param name="pole"> matice, který má být naplněna </param>
        static void NahodnePole(int m, int n, int minHodnota, int maxHodnota, int[,] pole)
        {
            /* Deklarace: 'rnd' ... náhodné číslo (generované na základě rovnoměrného rozdělení); 
             * 'i' ... index řádku prvku matice, 'j' ... index sloupce prvku matice */
 
            // Deklarace náhodného čísla (objektu) včetně inicializace
            Random rnd = new Random();
 
            // Pro všechny řádky matice od '0' (počátečního) do 'm-1'-tého (posledního) řádku
            for (int i = 0; i < m; i++)
            {
                // Pro všechny sloupce matice od '0' (počátečního) do 'n-1'-tého (posledního) sloupce
                for (int j = 0; j < n; j++)
                    /* Vygenerování náhodného čísla uloženého do 'rnd' v rozsahu 'minHodnota' až 'maxHodnota'
                     * Přiřazení náhodného čísla do aktuálního prvku */
                    pole[i, j] = rnd.Next(minHodnota, maxHodnota + 1);
            }
        }
 
        /// <summary>
        /// Metoda s logickým návratem - validace, zda předaná hodnota náleží intervalu 
        /// </summary>
        /// <param name="hodnota"> předaná hodnota </param>
        /// <param name="minRozmer"> dolní mez intervalu </param>
        /// <param name="maxRozmer"> horní mez intervalu </param>
        /// <returns> Logická informace, zda předaná hodnota náleží intervalu povolených hodnot
        /// </returns>
        static bool Validace(int hodnota, int dolniMez, int horniMez)
        {
            // Informace, že předaná hodnota je validní
            bool validni = true;
 
            // Test, zda načtená hodnota je mimo interval povolených hodnot ...
            if ((hodnota < dolniMez) || (hodnota > horniMez))
            {
                // Výpis o chybě
                Console.WriteLine("Zadaná hodnota je mimo povolené meze <{0}, {1}>", dolniMez, horniMez);
                    
                // Hodnota není validní
                validni = false;
            }
 
            // Návrat metody
            return validni;
        }
 
 
        /// <summary>
        /// Metoda pro plnění jednotlivých prvků matice specifikovaných uživatelem
        /// </summary>
        /// <param name="m"> aktuální počet řádků matice </param>
        /// <param name="n"> aktuální počet sloupců matice </param>
        /// <param name="minHodnota"> dolní mez prvků matice </param>
        /// <param name="maxHodnota"> horní mez prvků matice </param>
        /// <param name="pole"> matice, který má být naplněna </param>
        static void PlnitJednotlive(int m, int n, int minHodnota, int maxHodnota, int[,] pole)
        {
            /* Deklarace: 'indexRadku' ... index řádku prvku, který má být naplněn; 'indexSloupce' ... index 
             * sloupce prvku, který má být naplněn; 'hodnota' ... hodnota prvku, který má být naplněn; 
             * 'plnit' ... informace, zda má zadán (naplněn) další prvek ('true'...Ano, 'false'...Ne) */
            int indexRadku, indexSloupce, hodnota; 
            bool plnit;
 
            /* Cyklus s podmínkou na konci pro načtení indexu řádku plněného prvku - první souřadnice
             * prvku, od kterého lze postupně plnit další prvky matice */
            do
            {
                // Výzva k zadání indexu řádku plněného prvku
                Console.Write("Zadejte index řádku u prvku, který chcete naplnit (0 - {0}): ", m - 1);
 
                // Načtení indexu řádku
                int.TryParse(Console.ReadLine(), out indexRadku);
            }
            /* Podmínka cyklu, zda načtený index řádku je mimo meze. Pokud ano, opakování 
             * načtení indexu řádku */
            while (!Validace(indexRadku, 0, m-1));
 
            // Cyklus s podmínkou na konci pro načtení indexu sloupce plněného prvku 
            do
            {
                // Výzva k zadání pořadového čísla sloupce plněného prvku
                Console.Write("Zadejte index sloupce u prvku, který chcete naplnit (0 - {0}): ", n - 1);
 
                // Načtení indexu sloupce
                int.TryParse(Console.ReadLine(), out indexSloupce);
            }
            /* Podmínka cyklu, zda načtený index sloupce je mimo meze. Pokud ano, opakovaní 
             * načtení indexu sloupce */
            while (!Validace(indexSloupce, 0, n-1));
 
            // Matice má být plněna prvky zadanými uživatelem
            plnit = true;
            // Cyklus s podmínkou na konci pro plnění prvků matice
            do
            {
                // Cyklus s podmínkou na konci - validace zadané hodnoty zda je hodnota mimo rozsah intervalu 
                do
                {
                    /* Výzva k zadání hodnoty prvku, včetně vypsání dolní a horní meze včetně indexu 
                     * řádku a sloupce v hranatých závorkách */
                    Console.Write("Zadejte hodnotu prvku ({0} - {1}) na pozici [{2}, {3}]: ", minHodnota.ToString(),
                        maxHodnota.ToString(), indexRadku.ToString(), indexSloupce.ToString());
 
                    // Načtení hodnoty prvku
                    int.TryParse(Console.ReadLine(), out hodnota);
                }
                /* Podmínka cyklu, zda načtená hodnota prvku je mimo meze. Pokud ano, opakovaní 
                 * načtení hodnoty */
                while (!Validace(hodnota, minHodnota, maxHodnota));
 
                // Přiřazení hodnoty z lokální proměnné do prvku matice na určenou pozici
                pole[indexRadku, indexSloupce] = hodnota;
 
                // Pokud bylo dosaženo posledního řádku a posledního sloupce, pak...
                if ((indexRadku == m - 1) && (indexSloupce == n - 1))
                    // Zastavení plnění matice
                    plnit = false;
                    
                // Pokud index sloupce je menší než celkový počet sloupců - 1, pak...
                if (indexSloupce < n - 1)
                {
                    //zvýšení indexu sloupce o 1
                    indexSloupce++;
                }
                // Jinak ...
                else
                {
                    // Pokud index řádku je menší než celkový počet řádků - 1, pak...
                    if (indexRadku < m - 1)
                    {
                        // Zvýšení indexu řádku o 1
                        indexRadku++;
                        // Přiřazení 0 do indexu sloupce
                        indexSloupce = 0;
                    }
                }
            }
 
            /* Podmínka cyklu, zda má být provedeno další načtení prvku. Pokud ano (hodnota 'true'), 
             * opakovaní načtení hodnoty */
            while (plnit == true);
        }
 
        /// <summary>
        /// Metoda pro plnění prvků matice hodnotou nula
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> Matice, která má být naplněna </param>
        static void NulovatPole(int m, int n, int[,] pole)
        {
            /* Pro všechny řádky od počátečního do posledního řádku matice;
             * 'i' ... index (pozice) řádku matice */
            for (int i = 0; i < m; i++)
            {
                // Pro všechny sloupce
                for (int j = 0; j < n; j++)
                {
                    // Přiřazení nuly prvku na pozici [i,j]
                    pole[i, j] = 0;
                }
            }
        }
 
        #endregion Plnění pole
 
        #region Zobrazení pole
 
        /// <summary>
        /// Prvky v sloupcích matice jsou převedeny na text a odděleny čárkou, kde každá řádka  
        /// matice je umístěna na novém řádku ve výstupním textovém řetězci
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> matice </param>
        /// <returns> výstupní textový řetezec s prvky matice </returns>     
        static string PoleJakoText(int m, int n, int[,] pole)
        {
            /* Lokální proměnná: 'vystup' - výsledek převodu na text - inicializace 
             * a vložení nového řádku */
            string vystup = "";
 
            // Procházení řádků matice
            for (int i = 0; i < m; i++)
            {
                // Procházení sloupců matice
                for (int j = 0; j < n; j++)
                {
                    // Převod hodnoty prvku na text včetně připojení čárky
                    vystup += string.Format("{0:D3}, ", pole[i, j]);
                }
                // Přidání odstavce na konci každého řádku (také možnost vložení "\n")
                vystup += Environment.NewLine;
            }
            // Návrat výsledného textového řetězce
            return vystup;
        }
 
        /// <summary>
        /// Volání metody pro výpis prvků matice do textového řetězce
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> vypisovaná matice </param>
        static void ZobrazitPole(int m, int n, int[,] pole)
        {
            // Zavolání metody pro výpis matice do textového řetězce
            Console.Write(PoleJakoText(m, n, pole));
        }
 
        #endregion Zobrazení pole
 
        #region Operace s polem
 
        /// <summary>
        /// Návrat hodnoty minima matice - nejmenší prvek
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> prohledávaná matice </param>
        /// <param name="indexRadku"> index řádku minima </param>
        /// <param name="indexSloupce"> index sloupce minima </param>
        /// <returns> Minimum matice </returns>
        static int MinimumVPoli(int m, int n, int[,] pole, out int indexRadku, out int indexSloupce)
        {
            /* Deklarace: 'minimum' ... nalezená minimální hodnota v matici; 'i' ... index řádku 
             * matice; 'j' ... index sloupce matice */
            int minimum;
 
            // Hodnotu počátečního prvku prohlásíme minimem
            minimum = pole[0, 0];
 
            // Přiřazení hodnoty 0 do indexu řádku minima
            indexRadku = 0;
 
            // Přiřazení hodnoty 0 do indexu sloupce minima
            indexSloupce = 0;
 
            // Pro všechny řádky matice
            for (int i = 0; i < m; i++)
            {
                // Pro všechny sloupce matice
                for (int j = 0; j < n; j++) 
                {
                    // Pokud je aktuálně procházený prvek menší než minimum, pak...
                    if (pole[i, j] < minimum)
                    {
                        // Uložené aktuálního prvku do minima
                        minimum = pole[i, j];
 
                        // Přiřazení indexu aktuálního řádku do indexu řádku minima
                        indexRadku = i;
 
                        //přiřazení indexu aktuálního sloupce do indexu sloupce minima
                        indexSloupce = j;
                    }
                }
            }
 
            // Přiřazení minima návratu metody
            return minimum;
        }
 
        /// <summary>
        /// Návrat hodnoty maxima matice - největší prvek
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> prohledávaná matice </param>
        /// <param name="indexRadku"> index řádku maxima </param>
        /// <param name="indexSloupce"> index sloupce maxima </param>
        /// <returns> Maximum matice </returns>
        static int MaximumVPoli(int m, int n, int[,] pole, out int indexRadku, out int indexSloupce)
        {
            /* Deklarace: 'maximum' ... nalezená maximální hodnota v matici;  'i' ... index řádku 
            *matice; 'j'... index sloupce matice */
            int maximum;
 
            // Hodnotu prvního prvku prohlásíme maximem
            maximum = pole[0, 0];
 
            // Přiřazení hodnoty 0 do indexu řádku maxima
            indexRadku = 0;
 
            // Přiřazení hodnoty 0 do indexu sloupce maxima
            indexSloupce = 0;
 
            // Pro všechny řádky matice
            for (int i = 0; i < m; i++)
            {
                // Pro všechny sloupce matice
                for (int j = 0; j < n; j++)
                {
                    // Pokud je aktuálně procházený prvek menší než maximum, pak...
                    if (pole[i, j] > maximum)
                    {
                        // Uložené aktuálního prvku do maxima
                        maximum = pole[i, j];
 
                        // Přiřazení indexu aktuálního řádku do indexu řádku maxima
                        indexRadku = i;
 
                        //přiřazení indexu aktuálního sloupce do indexu sloupce maxima
                        indexSloupce = j;
                    }
                }
            }
 
            // Přiřazení maxima návratu metody
            return maximum;
        }
 
 
        /// <summary>
        /// Návrat aritmetického průměru prvků matice
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> matice </param>
        /// <returns> Průměr matice </returns>
        static double PrumerPole(int m, int n, int[,] pole)
        {
            /* Deklarace: 'prumer' ... průměrná reálná hodnota ze všech prvků matice; 
             * 'suma' ... suma hodnot všech prvků matice; i' ... index řádku matice; 
             * 'j' ... index sloupce matice */
            double prumer;
            int suma;
 
            // Inicializace - suma prvků je 0
            suma = 0;
 
            // Pro všechny řádky matice
            for (int i = 0; i < m; i++)
            {
                // Pro všechny sloupce matice
                for (int j = 0; j < n; j++)
                {
                    // Přičtení dalšího prvku vektoru do sumy
                    suma += pole[i, j];
                }
            }
 
            // Výpočet reálného průměru včetně přetypování
            prumer = (double)suma / (m * n);
 
            // Přiřazení vypočteného průměru návratu metody
            return prumer;
        }
 
        /// <summary>
        /// Vzestupné řazení prvků řádků matice
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> matice, kde prvky v každém řádku mají být setříděny vzestupně </param>
        static void SeraditPole(int m, int n, int[,] pole)
        {
            /* Deklarace: 'pom' ... pomocná proměnná pro dočasné uložení prvku; 'b' ... logická proměnná 
             * obsahující informaci, zda došlo k prohození některých sousedních prvků; 'i' ... index řádku 
             * matice; 'j' ... index sloupce matice */
            int pom;
            bool b;
 
 
            // Pro všechny řádky matice
            for (int i = 0; i < m; i++)
            {
                // Opakuj tak dlouho u každé řádky, dokud bude docházet k prohození prvků
                do
                {
                    // Nedošlo k prohození sousedních prvků
                    b = false;
                    // Pro všechny sloupce matice
                    for (int j = 0; j < n - 1; j++)
                    {
                        /* Pokud je hodnota sousedícího prvku větší než hodnota aktuálně
                         * testovaného prvku, pak... */
                        if (pole[i, j] > pole[i, j + 1])
                        {
                            // Ulož hodnotu aktuálního prvku do pomocné proměnné
                            pom = pole[i, j];
 
                            // Ulož hodnotu sousedícího prvku do aktuálního prvku
                            pole[i, j] = pole[i, j + 1];
 
                            // Ulož hodnotu z pomocné proměnné do sousedícího prvku
                            pole[i, j + 1] = pom;
 
                            // Došlo k prohození sousedních prvků
                            b = true;
                        }
                    }
                }
                // Testování, zda došlo k prohození některých sousedních prvků
                while (b == true);
            }
        }
 
        /// <summary>
        /// Transpozice prvků matice podle hlavní diagonály
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> matice, kde jsou prvky otočeny podle hlavní diagonály </param>
        static void HlavniTranspozice(int m, int n, int[,] pole)
        {
            /* Deklarace: 'pom' ... pomocná proměnná pro přesun osově souměrných prvků matice podle 
             * hlavní diagonály; 'i' ... index řádku matice; 'j' ... index sloupce matice */
            int pom;
 
            // Pokud počet řádek není roven počtu sloupců (matice není symetrická), pak...
            if (m != n)
            {
                // Výpis varovného upozornění
                Console.WriteLine("Nelze transponovat obdélníkovou matici");
                // Ukončení metody
                return;
            }
            // Jinak ...
            else
            {
                // Od počátečního až předposledního řádku matice
                for (int i = 0; i < m - 1; i++)
                {
                    // Od i + 1-tého sloupce do posledního sloupce matice
                    for (int j = i + 1; j < m; j++)
                    {
                        // Uložení aktuálního prvku matice na pozici [i,j] do pomocné proměnné
                        pom = pole[i, j];
                       
                        /* Přepsání aktuálního prvku matice na pozici [i,j] osově souměrným prvkem
                         * podle hlavní diagonály, tj. na pozici [j,i] */
                        pole[i, j] = pole[j, i];
                       
                        /* Přepsání osově souměrného prvku na pozici [j,i] prvkem uloženým
                         * v pomocné proměnné */
                        pole[j, i] = pom;
                    }
                }
            }
        }
 
        /// <summary>
        /// Transpozice prvků matice podle vedlejší diagonály
        /// </summary>
        /// <param name="m"> počet řádků matice </param>
        /// <param name="n"> počet sloupců matice </param>
        /// <param name="pole"> matice, kde jsou prvky otočeny podle vedlejší diagonály </param>
        static void VedlejsiTranspozice(int m, int n, int[,] pole)
        {
            /* Deklarace: 'pom' ... pomocná proměnná pro přesun osově souměrných prvků matice podle 
             * vedlejší diagonály; 'i' ... index řádku matice; 'j' ... index sloupce matice */
            int pom;
 
            // Pokud počet řádek není roven počtu sloupců (matice není symetrická), pak...
            if (m != n)
            {
                // Výpis varovného upozornění
                Console.WriteLine("Nelze transponovat obdélníkovou matici");
                // Ukončení metody
                return;
            }
            // Jinak ...
            else
            {
                // Od počátečního až předposledního řádku matice
                for (int i = 0; i < m - 1; i++)
                {
                    // Od i + 1-tého sloupce do posledního sloupce matice
                    for (int j = 0; j < m - i; j++)
                    {
                        // Uložení aktuálního prvku matice na pozici [i,j] do pomocné proměnné
                        pom = pole[i, j];
 
                        /* Přepsání aktuálního prvku matice na pozici [i,j] osově souměrným prvkem
                         * podle vedlejší diagonály, tj. na pozici [m-j-1,m-i-1] */
                        pole[i, j] = pole[m - j - 1, m - i - 1];
 
                        /* Přepsání osově souměrného prvku na pozici [m-j-1, m-i-1] prvkem uloženým
                         * v pomocné proměnné */
                        pole[m - j - 1, m - i - 1] = pom;
                    }
                }
            }
        }
 
        #endregion Operace s polem
    }
}

Kód 1: Program DvourozmernePole - deklarace hlavní statické metody Main včetně deklarací dalších metod