Algoritma Penyelesaian Matriks

Dulu prnah iseng2 buat aplikasi penyelesaian matriks nih gan. Itung2 buat ngasah ilmu METODE NUMERIK(hehe, rada serem denger ny). Nah, daripada tuh aplikasi nganggur di kompi ane. Apa salahnya klo ane share ke temen2. Rencananya mw di share smua ny bserta source code ny c, tpi kyaknya lebih efektif klo algoritma ny dlu aja deh. Biar dipelajari satu2. Salah satu algoritma di aplikasi ini, yaitu algoritma INTEGRAL jga udah prnah ane bahas sbelum nya algoritma nya. Yaudah langsung aja nih algoritma nya. ------>


///

        /// Untuk mendapatkan matriks transpost dari suatu matriks
        ///

        ///

        ///

        ///

        ///
        public double[,] getTranspost(double[,] data)
        {
            double[,] hasil = new double[data.GetLength(1), data.GetLength(0)];
            for (int i = 0; i < data.GetLength(0); i++)
            {
                for (int j = 0; j < data.GetLength(1); j++)
                    hasil[j, i] = data[i, j];
            }
            return hasil;
        }        ///

        /// Digunakan untuk mencari nilai determinan
        /// Mnggunakan metode eliminasi Gauss
        ///

        ///

        public void segitigaAtas(double[,] A)
        {
            determinan = 1;
            int jumlah = A.GetLength(0);
            /// Merubah matriks menjadi matriks segitiga atas
            for (int x = 0; x < jumlah - 1; x++)
            {
                for (int y = (x + 1); y < jumlah; y++)
                {
                    double tampung = A[x, y] / A[x, x];
                    for (int z = x; z < jumlah; z++)
                        A[z, y] = A[z, y] - (tampung * A[z, x]);
                }
            }
            /// Menghitung nilai determinan
            for (int i = 0; i < jumlah; i++)
            {
                determinan *= A[i, i];
            }
        }
        ///

        /// Create sebuah matriks identitas dengan ordo n*n
        ///

        ///

        private void Identitas(int n)
        {
            identitas = new double[n, n];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i == j)
                        identitas[i, j] = 1;
                    else
                        identitas[i, j] = 0;
                }
            }
        }
        ///

        /// Digunakan untuk menghitung invers matriks ordo n*n
        /// Menggunakan metode Eliminasi
        ///

        ///

        public void toIdentitas(double[,] A)
        {
            int jumlah = A.GetLength(0);
            identitas = new double[jumlah, jumlah];
            Identitas(jumlah);
            for (int x = 0; x < jumlah; x++)
            {
                for (int y = 0; y < jumlah; y++)
                {
                    if (x != y)
                    {
                        double tampung = A[x, y] / A[x, x];
                        for (int z = 0; z < jumlah; z++)
                        {
                            A[z, y] -= (tampung * A[z, x]);
                            identitas[z, y] -= (tampung * identitas[z, x]);
                        }
                    }
                }
            }

            for (int x = 0; x < jumlah; x++)
            {
                double bagi = A[x, x];
                for (int y = 0; y < jumlah; y++)
                {
                    identitas[y, x] /= bagi;
                }
            }
        }
        ///

        /// Menghitung operasi penjumlahan/pengurangan pada matriks
        ///

        ///
Matriks A
        ///
Matriks B
        ///
Operasi +/-
        public void plusMinus(double[,] A, double[,] B, string operasi)
        {
            hasil = new double[A.GetLength(0), A.GetLength(1)];
            for (int i = 0; i < A.GetLength(0); i++)
            {
                for (int j = 0; j < A.GetLength(1); j++)
                {
                    if (operasi == "+")
                        hasil[i, j] = A[i, j] + B[i, j];
                    else
                        hasil[i, j] = A[i, j] - B[i, j];
                }
            }
        }
        ///

        /// Manghitung operasi perkalian pada Matriks
        ///

        ///
Matriks A
        ///
Matriks B
        public void kali(double[,] A, double[,] B)
        {
            hasil = new double[A.GetLength(0), B.GetLength(1)];
            for (int x = 0; x < A.GetLength(0); x++)
            {
                for (int y = 0; y < B.GetLength(1); y++)
                {
                    for (int z = 0; z < A.GetLength(1); z++)
                        hasil[x, y] += (A[x, z] * B[z, y]);
                }
            }
        }
        ///

        /// Menghitung operasi perkalian kronecker product
        ///

        ///

        ///

        public void kronecker(double[,] A, double[,] B)
        {
            int baris = A.GetLength(0) * B.GetLength(0);
            int kolom = A.GetLength(1) * B.GetLength(1);
            hasil = new double[baris, kolom];
            for (int a = 0; a < B.GetLength(0); a++)
            {
                for (int b = 0; b < B.GetLength(1); b++)
                {
                    for (int c = 0; c < A.GetLength(0); c++)
                    {
                        for (int d = 0; d < A.GetLength(1); d++)
                            hasil[c + a * A.GetLength(0), d + b * A.GetLength(1)] = A[c, d] * B[a, b];
                    }
                }
            }
        }
Sekian gan dari ane, klo ada yg kurang jelas silahkan lngsung tanya aja di komentar ny gan, klo emang udah ngerti ALhamdulillah gan. Dan kalo ada kesalahan/ ada yg bisa mmberi algoritma yg lebih mudah dan efektif, mari di share gan. Ane juga manusia yg ga lepas dari salah gan...