Программа решает слау методом Гаусса: показывать ошибку при вводе некорректных данных - C# - Ответ 3125334

using System;
using System.Collections;
using System.Data;
using System.Threading;
 
namespace Gauss
{
    public class GaussSolutionNotFound : Exception {
        public GaussSolutionNotFound(string msg)
            : base("Программа неможет решить  СЛАУ : \r\n" + msg) {
        }
    }
 
    public class LinearSystem {
        private double[,] initial_a_matrix;
        private double[,] a_matrix;  // матрица A
        private double[] x_vector;   // вектор неизвестных x
        private double[] initial_b_vector;
        private double[] b_vector;   // вектор b
        private double[] u_vector;   // вектор невязки U
        private double eps;          // порядок точности для сравнения вещественных чисел 
        private int size;            // размерность задачи
        private int TCount = 2;      // количество потоков
        private bool IsDone = false;
 
 
        public LinearSystem(double[,] a_matrix, double[] b_vector)
            : this(a_matrix, b_vector, 0.0001) {
        }
        public LinearSystem(double[,] a_matrix, double[] b_vector, double eps) {
            if (a_matrix == null || b_vector == null)
                throw new ArgumentNullException("Один из параметров равен null.");
 
            int b_length = b_vector.Length;
            int a_length = a_matrix.Length;
            if (a_length != b_length * b_length)
                throw new ArgumentException(@"Количество строк и столбцов в матрице A должно совпадать с количеством элементров в векторе B.");
 
            this.initial_a_matrix = a_matrix;  // запоминаем исходную матрицу
            this.a_matrix = (double[,])a_matrix.Clone(); // с её копией будем производить вычисления
            this.initial_b_vector = b_vector;  // запоминаем исходный вектор
            this.b_vector = (double[])b_vector.Clone();  // с его копией будем производить вычисления
            this.x_vector = new double[b_length];
            this.u_vector = new double[b_length];
            this.size = b_length;
            this.eps = eps;
            //Jacobi(size, a_matrix, b_vector, ref x_vector);
        }
 
        public double[] XVector {
            get {
                while (!IsDone) { }
                return x_vector;
            }
        }
 
        public double[] UVector {
            get {
                return u_vector;
            }
        }
 
        // инициализация массива индексов столбцов
        private int[] InitIndex() {
            int[] index = new int[size];
            for (int i = 0; i < index.Length; ++i)
                index[i] = i;
            return index;
        }
 
        // поиск главного элемента в матрице
        private double FindR(int row, int[] index) {
            int max_index = row;
            double max = a_matrix[row, index[max_index]];
            double max_abs = Math.Abs(max);
            //if(row < size - 1)
            for (int cur_index = row + 1; cur_index < size; ++cur_index) {
                double cur = a_matrix[row, index[cur_index]];
                double cur_abs = Math.Abs(cur);
                if (cur_abs > max_abs) {
                    max_index = cur_index;
                    max = cur;
                    max_abs = cur_abs;
                }
            }
 
            if (max_abs < eps) {
                if (Math.Abs(b_vector[row]) > eps)
                    throw new GaussSolutionNotFound("система не совместима.");
                else
                    throw new GaussSolutionNotFound("Система уравнений имеет множество решений.");
            }
 
            // меняем местами индексы столбцов
            int temp = index[row];
            index[row] = index[max_index];
            index[max_index] = temp;
 
            return max;
        }
 
        void Jacobi(int N, double[,] A, double[] F, ref double[] X)
        // N - размерность матрицы; A[N][N] - матрица коэффициентов, F[N] - столбец свободных членов,
        // X[N] - начальное приближение, ответ записывается также в X[N];
        {
            double[] TempX = new double[N];
            double norm; // норма, определяемая как наибольшая разность компонент столбца иксов соседних итераций.
            do
            {
                for (int i = 0; i < N; i++)
                {
                    TempX[i] = -F[i];
                    for (int g = 0; g < N; g++)
                    {
                        if (i != g)
                            TempX[i] += A[i,g] * X[g];
                    }
                    TempX[i] /= -A[i,i];
                }
                norm = Math.Abs(X[0] - TempX[0]);
                for (int h = 0; h < N; h++)
                {
                    if (Math.Abs(X[h] - TempX[h]) > norm)
                        norm = Math.Abs(X[h] - TempX[h]);
                    X[h] = TempX[h];
                }
            } while (norm > eps);
        }
 
        public void Solve() {
            int[] index = InitIndex();
            ForwardStroke(index);
            BackwardStroke(index);
            Discrepancy();
            IsDone = true;
        }
 
 
 
        private void ForwardStroke(int[] index) {
            // перемещаемся по каждой строке сверху вниз
            for (int i = 0; i < size; ++i) {
                // 1) выбор главного элемента
                double r = FindR(i, index);
 
                // 2) преобразование текущей строки матрицы A
                for (int j = 0; j < size; ++j)
                    a_matrix[i, j] /= r;
 
                // 3) преобразование i-го элемента вектора b
                b_vector[i] /= r;
 
                // 4) Вычитание текущей строки из всех нижерасположенных строк
                for (int k = i + 1; k < size; ++k) {
                    double p = a_matrix[k, index[i]];
                    for (int j = i; j < size; ++j)
                        a_matrix[k, index[j]] -= a_matrix[i, index[j]] * p;
                    b_vector[k] -= b_vector[i] * p;
                    a_matrix[k, index[i]] = 0.0;
                }
            }
        }
 
        private void BackwardStroke(int[] index) {
            // перемещаемся по каждой строке снизу вверх
            for (int i = size - 1; i >= 0; --i) {
                // 1) задаётся начальное значение элемента x
                double x_i = b_vector[i];
 
                // 2) корректировка этого значения
                for (int j = i + 1; j < size; ++j)
                    x_i -= x_vector[index[j]] * a_matrix[i, index[j]];
                x_vector[index[i]] = x_i;
            }
        }
 
        // Вычисление невязки решения
        // U = b - x * A
        // x - решение уравнения, полученное методом Гаусса
        private void Discrepancy() {
            for (int i = 0; i < size; ++i) {
                double actual_b_i = 0.0;   // результат перемножения i-строки 
                // исходной матрицы на вектор x
                for (int j = 0; j < size; ++j)
                    actual_b_i += initial_a_matrix[i, j] * x_vector[j];
                // i-й элемент вектора невязки
                u_vector[i] = initial_b_vector[i] - actual_b_i;
            }
        }
    }
}