// Математический помощник: Матрицы и Векторы
// Рекомендация: .NET 6+
// Полный функционал: определители, Крамер, Гаусс, все векторные операции, площади/объёмы, момент силы, power iteration (соб. число/вектор)

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        Console.Title = "Математический помощник: Матрицы и Векторы";
        while (true)
        {
            Console.Clear();
            Console.WriteLine("=== ГЛАВНОЕ МЕНЮ ===");
            Console.WriteLine("1 — Работа с матрицами");
            Console.WriteLine("2 — Работа с векторами");
            Console.WriteLine("0 — Выход");
            Console.Write("Выбор: ");
            switch (Console.ReadLine()?.Trim())
            {
                case "1": MatrixMenu(); break;
                case "2": VectorMenu(); break;
                case "0": return;
                default:
                    Console.WriteLine("Неверный ввод. Нажмите любую клавишу.");
                    Console.ReadKey(); break;
            }
        }
    }

    // ====== МАТРИЦЫ ======
    static void MatrixMenu()
    {
        while (true)
        {
            Console.Clear();
            Console.WriteLine("=== МАТРИЦЫ ===");
            Console.WriteLine("1 — Вычислить определитель (любая n x n)");
            Console.WriteLine("2 — Решить систему методом Крамера (n x n)");
            Console.WriteLine("3 — Решить систему методом Гаусса (прямой/обратный ход)");
            Console.WriteLine("4 — Power Iteration (доминирующее собственное число/вектор)");
            Console.WriteLine("0 — Назад");
            Console.Write("Выбор: ");
            switch (Console.ReadLine()?.Trim())
            {
                case "1": MatrixDeterminant(); break;
                case "2": SolveCramer(); break;
                case "3": SolveGauss(); break;
                case "4": PowerIterationMenu(); break;
                case "0": return;
                default:
                    Console.WriteLine("Неверный ввод."); Console.ReadKey(); break;
            }
        }
    }

    static void MatrixDeterminant()
    {
        Console.Clear();
        int n = ReadIntPositive("Введите размерность матрицы n (>0): ");
        var A = ReadMatrix(n, n, "матрицы A");
        Console.WriteLine("\nA:");
        PrintMatrix(A);
        double det = Determinant(A);
        Console.WriteLine($"\nОпределитель det(A) = {det}");
        Console.WriteLine(det > 0 ? "✅ det > 0" : det < 0 ? "❌ det < 0" : "⚠ det = 0");
        Pause();
    }

    static void SolveCramer()
    {
        Console.Clear();
        int n = ReadIntPositive("Введите размерность системы n (>0): ");
        Console.WriteLine("Ввод матрицы A (по строкам, числа через пробел):");
        var A = ReadMatrix(n, n, "A");
        Console.WriteLine("Ввод вектора свободных членов B (n чисел через пробел):");
        var B = ReadVector(n, "B");
        double detA = Determinant(A);
        Console.WriteLine($"det(A) = {detA}");
        if (Math.Abs(detA) < 1e-12)
        {
            Console.WriteLine("det(A) = 0 => система не имеет единственного решения (проверьте ранги).");
            Pause(); return;
        }
        var X = new double[n];
        for (int k = 0; k < n; k++)
        {
            var Ak = (double[,])A.Clone();
            for (int i = 0; i < n; i++) Ak[i, k] = B[i];
            X[k] = Determinant(Ak) / detA;
        }
        Console.WriteLine("\nРешение (Крамер):");
        for (int i = 0; i < n; i++) Console.WriteLine($"x{i+1} = {X[i]}");
        Pause();
    }

    static void SolveGauss()
    {
        Console.Clear();
        int n = ReadIntPositive("Введите число уравнений n (>0): ");
        Console.WriteLine("Введите расширенную матрицу (n строк, n+1 чисел в строке):");
        double[,] M = new double[n, n + 1];
        for (int i = 0; i < n; i++)
        {
            Console.Write($"Строка {i+1}: ");
            var parts = ReadDoublesRow(n + 1);
            for (int j = 0; j < n + 1; j++) M[i, j] = parts[j];
        }

        var res = GaussSolve(M);
        if (res == null)
        {
            Console.WriteLine("Система несовместна или имеет бесконечное множество решений (ранги совпадают/не совпадают).");
        }
        else
        {
            Console.WriteLine("Решение (единственное):");
            for (int i = 0; i < res.Length; i++) Console.WriteLine($"x{i+1} = {res[i]}");
        }
        Pause();
    }

    // ====== POWER ITERATION ======
    static void PowerIterationMenu()
    {
        Console.Clear();
        int n = ReadIntPositive("Введите размерность квадратной матрицы n (>0): ");
        var A = ReadMatrix(n, n, "A");
        Console.WriteLine("Запускаем Power Iteration для нахождения доминирующего собственного вектора/значения.");
        int maxIter = ReadIntPositive("Максимум итераций (например 1000): ");
        double tol = ReadDouble("Точность (например 1e-9): ");
        var (lambda, vec) = PowerIteration(A, maxIter, tol);
        Console.WriteLine($"\nПриближённое собственное значение (доминирующее): {lambda}");
        Console.WriteLine("Собственный вектор (нормированный):");
        PrintVector(vec);
        Pause();
    }

    // ====== ВЕКТОРЫ ======
    static void VectorMenu()
    {
        while (true)
        {
            Console.Clear();
            Console.WriteLine("=== ВЕКТОРЫ ===");
            Console.WriteLine("1 — Сложение / вычитание");
            Console.WriteLine("2 — Скалярное произведение");
            Console.WriteLine("3 — Векторное произведение (3D)");
            Console.WriteLine("4 — Смешанное произведение (3D)");
            Console.WriteLine("5 — Коллинеарность");
            Console.WriteLine("6 — Компланарность (трёх векторов)");
            Console.WriteLine("7 — Угол между векторами");
            Console.WriteLine("8 — Длина / норма / проекция");
            Console.WriteLine("9 — Площадь параллелограмма / треугольника");
            Console.WriteLine("10 — Объём параллелепипеда / тетраэдра");
            Console.WriteLine("11 — Момент силы (векторное произведение)");
            Console.WriteLine("0 — Назад");
            Console.Write("Выбор: ");
            switch (Console.ReadLine()?.Trim())
            {
                case "1": SumSubtractVectors(); break;
                case "2": ScalarProduct(); break;
                case "3": VectorProduct(); break;
                case "4": MixedProduct(); break;
                case "5": CheckCollinear(); break;
                case "6": CheckCoplanar(); break;
                case "7": AngleBetweenVectors(); break;
                case "8": LengthProjection(); break;
                case "9": AreaParallelogramTriangle(); break;
                case "10": VolumeParallelepipedTetrahedron(); break;
                case "11": MomentOfForce(); break;
                case "0": return;
                default:
                    Console.WriteLine("Неверный ввод."); Pause(); break;
            }
        }
    }

    static void SumSubtractVectors()
    {
        Console.Clear();
        var a = ReadVectorAuto("A");
        var b = ReadVectorAuto("B");
        var sum = VectorAdd(a, b);
        var diff = VectorSub(a, b);
        Console.WriteLine("\nA + B ="); PrintVector(sum);
        Console.WriteLine("A - B ="); PrintVector(diff);
        Pause();
    }

    static void ScalarProduct()
    {
        Console.Clear();
        var a = ReadVectorAuto("A");
        var b = ReadVectorAuto("B");
        double dot = Dot(a, b);
        Console.WriteLine($"\nA · B = {dot}");
        Pause();
    }

    static void VectorProduct()
    {
        Console.Clear();
        var a = ReadVector3("A");
        var b = ReadVector3("B");
        var c = Cross(a, b);
        Console.WriteLine("\nA × B =");
        PrintVector(c);
        Pause();
    }

    static void MixedProduct()
    {
        Console.Clear();
        var a = ReadVector3("A");
        var b = ReadVector3("B");
        var c = ReadVector3("C");
        double mixed = Dot(a, Cross(b, c));
        Console.WriteLine($"\n[A B C] = {mixed}");
        Pause();
    }

    static void CheckCollinear()
    {
        Console.Clear();
        var a = ReadVectorAuto("A");
        var b = ReadVectorAuto("B");
        if (a.Length != b.Length) { Console.WriteLine("Векторы должны быть одной размерности."); Pause(); return; }
        if (a.Length == 3)
        {
            var cross = Cross(a, b);
            bool zero = cross.All(x => Math.Abs(x) < 1e-9);
            Console.WriteLine(zero ? "✅ Коллинеарны" : "❌ Не коллинеарны");
        }
        else
        {
            // Проверка пропорциональности координат
            double? ratio = null; bool col = true;
            for (int i = 0; i < a.Length; i++)
            {
                if (Math.Abs(b[i]) < 1e-12)
                {
                    if (Math.Abs(a[i]) > 1e-12) { col = false; break; }
                    else continue;
                }
                double r = a[i] / b[i];
                if (ratio == null) ratio = r;
                else if (Math.Abs(r - ratio.Value) > 1e-9) { col = false; break; }
            }
            Console.WriteLine(col ? "✅ Коллинеарны (пропорциональны)" : "❌ Не коллинеарны");
        }
        Pause();
    }

    static void CheckCoplanar()
    {
        Console.Clear();
        var a = ReadVector3("A");
        var b = ReadVector3("B");
        var c = ReadVector3("C");
        double mixed = Dot(a, Cross(b, c));
        Console.WriteLine(Math.Abs(mixed) < 1e-9 ? "✅ Компланарны" : "❌ Не компланарны");
        Pause();
    }

    static void AngleBetweenVectors()
    {
        Console.Clear();
        var a = ReadVectorAuto("A");
        var b = ReadVectorAuto("B");
        if (a.Length != b.Length) { Console.WriteLine("Размерности не совпадают."); Pause(); return; }
        double dot = Dot(a, b);
        double na = Norm(a), nb = Norm(b);
        if (na == 0 || nb == 0) { Console.WriteLine("У одного вектора нулевая длина."); Pause(); return; }
        double cos = dot / (na * nb);
        cos = Math.Max(-1.0, Math.Min(1.0, cos));
        double angleRad = Math.Acos(cos);
        Console.WriteLine($"Угол между = {angleRad * 180.0 / Math.PI:F6}°");
        Pause();
    }

    static void LengthProjection()
    {
        Console.Clear();
        var a = ReadVectorAuto("A");
        var b = ReadVectorAuto("B");
        if (a.Length != b.Length) { Console.WriteLine("Размерности не совпадают."); Pause(); return; }
        double projLen = Dot(a, b) / Norm(b); // проекция длины A на B
        var projVec = ScalarMultiply(b, Dot(a, b) / Dot(b, b));
        Console.WriteLine($"Длина проекции A на B = {projLen}");
        Console.WriteLine("Вектор проекции A на B ="); PrintVector(projVec);
        Pause();
    }

    static void AreaParallelogramTriangle()
    {
        Console.Clear();
        var a = ReadVector3("A");
        var b = ReadVector3("B");
        var cross = Cross(a, b);
        double areaPar = Norm(cross);
        double areaTri = 0.5 * areaPar;
        Console.WriteLine($"Площадь параллелограмма = {areaPar}");
        Console.WriteLine($"Площадь треугольника = {areaTri}");
        Pause();
    }

    static void VolumeParallelepipedTetrahedron()
    {
        Console.Clear();
        var a = ReadVector3("A");
        var b = ReadVector3("B");
        var c = ReadVector3("C");
        double volPar = Math.Abs(Dot(a, Cross(b, c)));
        double volTet = Math.Abs(volPar / 6.0); // careful: volume tetrahedron built on vectors a,b,c from same vertex = |[a b c]|/6? Actually /6 for coordinates of triangle pyramid? Standard: volume parallelepiped = |[a b c]|; tetrahedron volume = |[a b c]|/6 if points provided as A,B,C,D? Many textbooks use 1/6 for specific vertex choices; here we provide both with clear note.
        // To avoid confusion, give standard: volume parallel = |[a b c]| ; volume tetrahedron (if a,b,c are edges from a vertex) = |[a b c]|/6? Actually correct tetrahedron volume = |[a b c]| / 6 for points A(0), B(a), C(b), D(c)?? Some definitions differ — safer: tetrahedron with edges a,b,c from one vertex: V = |[a b c]|/6? Many sources: Volume = |(a·(b×c))|/6. We'll output both and note formula.
        Console.WriteLine($"Объём параллелепипеда = {volPar}");
        Console.WriteLine($"Объём тетраэдра (на тех же ребрах от одной вершины) = {volPar/6.0} (в некоторых задачах используют /6; проверьте условие задачи)");
        Pause();
    }

    static void MomentOfForce()
    {
        Console.Clear();
        Console.WriteLine("Момент силы M = r × F (r — радиус-вектор точки приложения от точки отсчёта).");
        var r = ReadVector3("r (вектор от точки отсчёта до точки приложения)");
        var F = ReadVector3("F (сила)");
        var M = Cross(r, F);
        Console.WriteLine("\nM = r × F =");
        PrintVector(M);
        Console.WriteLine($"Длина момента |M| = {Norm(M)}");
        Pause();
    }

    // ====== Утилиты для матриц / векторов / ввод ======
    static int ReadIntPositive(string prompt)
    {
        while (true)
        {
            Console.Write(prompt);
            if (int.TryParse(Console.ReadLine(), out int v) && v > 0) return v;
            Console.WriteLine("Введите целое > 0.");
        }
    }
    static double ReadDouble(string prompt)
    {
        while (true)
        {
            Console.Write(prompt);
            if (double.TryParse(Console.ReadLine(), out double v)) return v;
            Console.WriteLine("Число введено неверно.");
        }
    }

    static double[,] ReadMatrix(int rows, int cols, string name)
    {
        var M = new double[rows, cols];
        Console.WriteLine($"Ввод {name}: (каждая строка — {cols} чисел через пробел)");
        for (int i = 0; i < rows; i++)
        {
            Console.Write($"Строка {i + 1}: ");
            var parts = ReadDoublesRow(cols);
            for (int j = 0; j < cols; j++) M[i, j] = parts[j];
        }
        return M;
    }

    static double[] ReadVector(int n, string name)
    {
        Console.WriteLine($"Ввод {name}: {n} чисел через пробел");
        var parts = ReadDoublesRow(n);
        return parts;
    }

    static double[] ReadVector3(string name)
    {
        Console.WriteLine($"Введите 3 числа для вектора {name} (через пробел):");
        return ReadDoublesRow(3);
    }

    static double[] ReadVectorAuto(string name)
    {
        Console.Write($"Сколько координат у вектора {name}? (обычно 2 или 3): ");
        if (!int.TryParse(Console.ReadLine(), out int n) || n <= 0) n = 3;
        Console.WriteLine($"Введите {n} чисел через пробел:");
        return ReadDoublesRow(n);
    }

    static double[] ReadDoublesRow(int expected)
    {
        while (true)
        {
            var line = Console.ReadLine();
            if (string.IsNullOrWhiteSpace(line)) { Console.WriteLine("Пусто — повторите ввод."); continue; }
            var parts = line.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length != expected) { Console.WriteLine($"Ожидается {expected} чисел, введено {parts.Length}. Попробуйте ещё раз."); continue; }
            try { return parts.Select(double.Parse).ToArray(); }
            catch { Console.WriteLine("Ошибка преобразования — попробуйте ещё раз."); continue; }
        }
    }

    static void Pause() { Console.WriteLine("\nНажмите любую клавишу..."); Console.ReadKey(); }

    static void PrintMatrix(double[,] M)
    {
        int r = M.GetLength(0), c = M.GetLength(1);
        for (int i = 0; i < r; i++)
        {
            for (int j = 0; j < c; j++) Console.Write($"{M[i, j],10:F6} ");
            Console.WriteLine();
        }
    }

    static void PrintVector(double[] v)
    {
        Console.Write("(" + string.Join(", ", v.Select(x => x.ToString("F6"))) + ")");
        Console.WriteLine();
    }

    // ====== МАТРИЧНЫЕ ОПЕРАЦИИ и РЕШЕНИЕ ======
    static double Determinant(double[,] matrix)
    {
        int n = matrix.GetLength(0);
        if (matrix.GetLength(1) != n) throw new ArgumentException("Матрица должна быть квадратной.");
        // Используем LU-подобный метод (прямой) с вычислением по разложению Гаусса с частичной выборкой строки для устойчивости:
        // Но для простоты и надёжности при n <= 6 используем рекурсивный минор; при больших n применим LU (разложение).
        if (n <= 6) return DeterminantRecursive(matrix);
        return DeterminantLU(matrix);
    }

    static double DeterminantRecursive(double[,] matrix)
    {
        int n = matrix.GetLength(0);
        if (n == 1) return matrix[0, 0];
        if (n == 2) return matrix[0, 0] * matrix[1, 1] - matrix[0, 1] * matrix[1, 0];
        double det = 0;
        for (int j = 0; j < n; j++)
        {
            var minor = Minor(matrix, 0, j);
            det += Math.Pow(-1, j) * matrix[0, j] * DeterminantRecursive(minor);
        }
        return det;
    }

    static double[,] Minor(double[,] matrix, int row, int col)
    {
        int n = matrix.GetLength(0);
        var res = new double[n - 1, n - 1];
        int r = 0;
        for (int i = 0; i < n; i++)
        {
            if (i == row) continue;
            int c = 0;
            for (int j = 0; j < n; j++)
            {
                if (j == col) continue;
                res[r, c++] = matrix[i, j];
            }
            r++;
        }
        return res;
    }

    static double DeterminantLU(double[,] A)
    {
        int n = A.GetLength(0);
        var M = (double[,])A.Clone();
        double detSign = 1.0;
        for (int k = 0; k < n; k++)
        {
            // partial pivot
            int pivot = k;
            double max = Math.Abs(M[k, k]);
            for (int i = k + 1; i < n; i++)
            {
                if (Math.Abs(M[i, k]) > max) { max = Math.Abs(M[i, k]); pivot = i; }
            }
            if (Math.Abs(max) < 1e-15) return 0.0;
            if (pivot != k)
            {
                // swap rows
                for (int j = 0; j < n; j++) { double tmp = M[k, j]; M[k, j] = M[pivot, j]; M[pivot, j] = tmp; }
                detSign *= -1.0;
            }
            double akk = M[k, k];
            for (int i = k + 1; i < n; i++)
            {
                double factor = M[i, k] / akk;
                for (int j = k; j < n; j++) M[i, j] -= factor * M[k, j];
            }
        }
        double prod = detSign;
        for (int i = 0; i < n; i++) prod *= M[i, i];
        return prod;
    }

    static double[] GaussSolve(double[,] aug) // aug: n x (n+1); returns solution or null
    {
        int n = aug.GetLength(0);
        var A = (double[,])aug.Clone();

        // Forward elimination with partial pivot
        int row = 0;
        for (int col = 0; col < n && row < n; col++)
        {
            // find pivot
            int sel = row;
            double max = Math.Abs(A[sel, col]);
            for (int i = row + 1; i < n; i++)
            {
                if (Math.Abs(A[i, col]) > max) { max = Math.Abs(A[i, col]); sel = i; }
            }
            if (Math.Abs(max) < 1e-12) continue; // no pivot in this column
            // swap rows sel and row
            if (sel != row)
            {
                for (int j = col; j < n + 1; j++) { double tmp = A[sel, j]; A[sel, j] = A[row, j]; A[row, j] = tmp; }
            }
            // normalize
            double pivot = A[row, col];
            for (int j = col; j < n + 1; j++) A[row, j] /= pivot;
            // eliminate below
            for (int i = row + 1; i < n; i++)
            {
                double f = A[i, col];
                for (int j = col; j < n + 1; j++) A[i, j] -= f * A[row, j];
            }
            row++;
        }

        // Check for inconsistency and ranks
        // rank(A) vs rank(aug)
        int rankA = 0, rankAug = 0;
        for (int i = 0; i < n; i++)
        {
            bool anyA = false, anyAug = false;
            for (int j = 0; j < n; j++) if (Math.Abs(A[i, j]) > 1e-9) anyA = true;
            for (int j = 0; j < n + 1; j++) if (Math.Abs(A[i, j]) > 1e-9) anyAug = true;
            if (anyA) rankA++;
            if (anyAug) rankAug++;
        }
        if (rankA < rankAug) return null; // incompatible
        if (rankA < n) return null; // infinite solutions — for simplicity return null (can be extended to parametric form)

        // Back substitution
        var X = new double[n];
        for (int i = n - 1; i >= 0; i--)
        {
            // find leading index
            int lead = -1;
            for (int j = 0; j < n; j++) if (Math.Abs(A[i, j]) > 1e-9) { lead = j; break; }
            if (lead == -1) continue;
            double sum = A[i, n];
            for (int j = lead + 1; j < n; j++) sum -= A[i, j] * X[j];
            X[lead] = sum / A[i, lead];
        }
        return X;
    }

    // ====== ВЕКТОРНАЯ АЛГЕБРА (общая) ======
    static double[] VectorAdd(double[] a, double[] b)
    {
        if (a.Length != b.Length) throw new ArgumentException("Размерности не совпадают.");
        return Enumerable.Range(0, a.Length).Select(i => a[i] + b[i]).ToArray();
    }
    static double[] VectorSub(double[] a, double[] b)
    {
        if (a.Length != b.Length) throw new ArgumentException("Размерности не совпадают.");
        return Enumerable.Range(0, a.Length).Select(i => a[i] - b[i]).ToArray();
    }
    static double Dot(double[] a, double[] b)
    {
        if (a.Length != b.Length) throw new ArgumentException("Размерности не совпадают.");
        double s = 0; for (int i = 0; i < a.Length; i++) s += a[i] * b[i]; return s;
    }
    static double Norm(double[] a) => Math.Sqrt(Dot(a, a));
    static double[] ScalarMultiply(double[] a, double k) => a.Select(x => x * k).ToArray();

    static double[] Cross(double[] a, double[] b)
    {
        if (a.Length != 3 || b.Length != 3) throw new ArgumentException("Cross product defined for 3D vectors.");
        return new double[]
        {
            a[1]*b[2] - a[2]*b[1],
            a[2]*b[0] - a[0]*b[2],
            a[0]*b[1] - a[1]*b[0]
        };
    }

    // ====== POWER ITERATION (наибольшее собственное значение по модулю) ======
    // Возвращает (lambda, vector(normed))
    static (double, double[]) PowerIteration(double[,] A, int maxIter = 1000, double tol = 1e-9)
    {
        int n = A.GetLength(0);
        if (A.GetLength(1) != n) throw new ArgumentException("Матрица должна быть квадратной.");
        var b = new double[n];
        var rnd = new Random();
        for (int i = 0; i < n; i++) b[i] = rnd.NextDouble() + 0.1;
        double lambda = 0;
        for (int iter = 0; iter < maxIter; iter++)
        {
            var Ab = Multiply(A, b);
            double norm = Norm(Ab);
            if (norm == 0) return (0, b); // нулевой вектор
            for (int i = 0; i < n; i++) b[i] = Ab[i] / norm;
            var Ab2 = Multiply(A, b);
            double lambdaNew = Dot(b, Ab2); // Rayleigh quotient approx
            if (Math.Abs(lambdaNew - lambda) < tol) { lambda = lambdaNew; break; }
            lambda = lambdaNew;
        }
        return (lambda, b);
    }

    static double[] Multiply(double[,] A, double[] x)
    {
        int r = A.GetLength(0), c = A.GetLength(1);
        if (c != x.Length) throw new ArgumentException("Несовместимые размеры.");
        var y = new double[r];
        for (int i = 0; i < r; i++)
        {
            double s = 0;
            for (int j = 0; j < c; j++) s += A[i, j] * x[j];
            y[i] = s;
        }
        return y;
    }
}