Untitled

using System;

class Program
{
    static void Main(string[] args)
    {
        // Przykładowa macierz wejściowa
        double[,] A = {
            { 4, -2, 1 },
            { 20, -7, 12 },
            { -8, 13, 17 }
        };

        Console.WriteLine("Macierz wejściowa:");
        PrintMatrix(A);

        // Dekompozycja LU metodą Crouta
        Console.WriteLine("\nDekompozycja LU metodą Crouta:");
        (double[,] L, double[,] U) = CroutLUDecomposition(A);
        Console.WriteLine("Macierz L:");
        PrintMatrix(L);
        Console.WriteLine("Macierz U:");
        PrintMatrix(U);

        // Odwracanie macierzy
        Console.WriteLine("\nMacierz odwrotna:");
        double[,] A_inv = InvertMatrix(A);
        PrintMatrix(A_inv);
    }

    // Algorytm dekompozycji LU metodą Crouta
    static (double[,] L, double[,] U) CroutLUDecomposition(double[,] A)
    {
        int n = A.GetLength(0);
        double[,] L = new double[n, n];
        double[,] U = new double[n, n];

        for (int i = 0; i < n; i++)
        {
            U[i, i] = 1; // U jest macierzą trójkątną górną z 1 na przekątnej

            for (int j = i; j < n; j++)
            {
                // Obliczanie elementów macierzy L
                double sumL = 0;
                for (int k = 0; k < i; k++)
                    sumL += L[j, k] * U[k, i];
                L[j, i] = A[j, i] - sumL;
            }

            for (int j = i + 1; j < n; j++)
            {
                // Obliczanie elementów macierzy U
                double sumU = 0;
                for (int k = 0; k < i; k++)
                    sumU += L[i, k] * U[k, j];
                U[i, j] = (A[i, j] - sumU) / L[i, i];
            }
        }

        return (L, U);
    }

    // Algorytm odwracania macierzy metodą bezwyznacznikową
    static double[,] InvertMatrix(double[,] A)
    {
        int n = A.GetLength(0);
        double[,] A_inv = new double[n, n];

        // Znajdowanie macierzy odwrotnej przez rozwiązywanie układów równań
        for (int i = 0; i < n; i++)
        {
            // Jednostkowy wektor kolumnowy e_i
            double[] e = new double[n];
            e[i] = 1;

            // Rozwiązanie układu równań A * x = e_i
            double[] x = SolveLinearSystem(A, e);
            
            // Przepisanie rozwiązania do macierzy odwrotnej
            for (int j = 0; j < n; j++)
                A_inv[j, i] = x[j];
        }

        return A_inv;
    }

    // Funkcja do rozwiązywania układu równań A * x = b z użyciem dekompozycji LU
    static double[] SolveLinearSystem(double[,] A, double[] b)
    {
        int n = A.GetLength(0);
        (double[,] L, double[,] U) = CroutLUDecomposition(A);

        // Rozwiązanie L * y = b
        double[] y = new double[n];
        for (int i = 0; i < n; i++)
        {
            double sum = 0;
            for (int j = 0; j < i; j++)
                sum += L[i, j] * y[j];
            y[i] = (b[i] - sum) / L[i, i];
        }

        // Rozwiązanie U * x = y
        double[] x = new double[n];
        for (int i = n - 1; i >= 0; i--)
        {
            double sum = 0;
            for (int j = i + 1; j < n; j++)
                sum += U[i, j] * x[j];
            x[i] = y[i] - sum;
        }

        return x;
    }

    // Funkcja do wyświetlania macierzy
    static void PrintMatrix(double[,] matrix)
    {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write($"{matrix[i, j],8:F3} ");
            }
            Console.WriteLine();
        }
    }
}