Вычислить определитель матрицы используя метод Гаусса

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Laba_2
{
    class Program
    {
        static public void Metod_Gayssa()
        {
            int N = Convert.ToInt32(Console.ReadLine()); //размер массива
 
            double[,] A = new double[N, N];
           
 
            double detA, k, buf;
 
            int max, j, z=0, p, s, zam,c=0,r;
 
            max = 1; //максимальный элемент в первой строке
 
            detA = 1; //Определитель
 
            zam = 0; // Число замен
            for ( c = 0; c < N; c++)
                for ( r = 0; r < N; r++)
                {
                    
                    A[c, r] = Convert.ToInt32(Console.ReadLine()); //Считываем массив
 
                }
 
            for ( c = 0; c < N - 2; c++)
            {
                for (z = 0; z < N - 2; z++)
                {
                    max = z;
                }
 
                for (j = z + 2; j < N; j++)
                {
                    if ((Math.Abs(A[c, j])) > (Math.Abs(A[c, max]))) //Выбор главного элемента
                        max = j;
                }
            }
//перестановка строк
            for (p = 0; p < N; p++)
            {
                buf = A[p, z]; A[p, z] = A[p, max]; buf = A[p, max];
            }
 
            for (r = c ; r < N; r++)
            {
                k = A[c, r] / A[c, c];
 
                for (s = 0; s < N; s++)
                    A[s, r] = A[s, r] - A[s, c] * k;
            }
 
            if (c != max)
            {
                zam ++;
            }
 
            for (c = 0; c < N; c++)
            {
                detA = detA * A[c, c];
 
                if (zam % 2 != 0)
 
                    detA = (-1) * detA;
 
            }
 
            Console.WriteLine(detA);
        }
 
 
 
        static void Main(string[] args)
        {
            Metod_Gayssa();
            Console.ReadLine();
        }
    }
 
}

using System;
using System.Text;
 
namespace Gauss
{
    class Matrix
    {
        private readonly double[,] _a;
        public int Length { get; private set; }
 
        public Matrix(double[,] a)
        {
            _a = a;
            Length = a.GetLength(0);
        }
 
        public Matrix(int n) :this(new double[n,n])
        {
        }
 
        public void Generate()
        {
            var r = new Random();
            for (int i = 0; i < Length; i++)
                for (int j = 0; j < Length; j++)
                    _a[i, j] = (r.Next() % 1000) / 100.0;
        }
 
        public string PrintMatrix()
        {
            var result = new StringBuilder(Length*7);
            for (int i = 0; i < Length; i++)
            {
                for (int j = 0; j < Length; j++)
                    result.AppendFormat("{0,-7}", _a[i, j]);
                result.AppendLine();
            }
            return result.ToString();
        }
 
        public unsafe double Determinant
        {
            get
            {
                var temp = new double[_a.Length];
                Buffer.BlockCopy(_a, 0, temp, 0, temp.Length * sizeof(double));
                fixed (double* pm = &temp[0]) return _Det(pm, Length); ;
            }
        }
 
 
        unsafe double _Det(double* rmX, int n)
        {
            double* mtx_u_ii, mtx_ii_j;
            double* mtx_end = rmX + n * (n - 1), mtx_u_ii_j = null;
            double val, det = 1;
            int d = 0;
            // rmX указывает на (i,i) элемент на каждом шаге и называется ведущим
            for (double* mtx_ii_end = rmX + n; rmX < mtx_end; rmX += n + 1, mtx_ii_end += n, d++)
            {
                // Ищем максимальный элемент в столбце(под ведущим) 
                {
                    //Ищем максимальный элемент и его позицию
                    val = Math.Abs(*(mtx_ii_j = rmX));
                    for (mtx_u_ii = rmX + n; mtx_u_ii < mtx_end; mtx_u_ii += n)
                    {
                        if (val < Math.Abs(*mtx_u_ii))
                            val = Math.Abs(*(mtx_ii_j = mtx_u_ii));
                    }
                    //Если максимальный эдемент = 0 -> матрица вырожденная
                    if (Math.Abs(val - 0) < double.Epsilon) return double.NaN;
                    //Если ведущий элемент не является максимальным - делаем перестановку строк и меняем знак определителя
                    if (mtx_ii_j != rmX)
                    {
                        det = -det;
                        for (mtx_u_ii = rmX; mtx_u_ii < mtx_ii_end; mtx_ii_j++, mtx_u_ii++)
                        {
                            val = *mtx_u_ii;
                            *mtx_u_ii = *mtx_ii_j;
                            *mtx_ii_j = val;
                        }
                    }
                }
                //Обнуляем элементы под ведущим
                for (mtx_u_ii = rmX + n, mtx_u_ii_j = mtx_end + n; mtx_u_ii < mtx_u_ii_j; mtx_u_ii += d)
                {
                    val = *(mtx_u_ii++) / *rmX;
                    for (mtx_ii_j = rmX + 1; mtx_ii_j < mtx_ii_end; mtx_u_ii++, mtx_ii_j++)
                        *mtx_u_ii -= *mtx_ii_j * val;
                }
                det *= *rmX;
            }
            return det * *rmX;
        }
 
        public double this[int i, int j]
        {
            get { return _a[i, j]; }
            set { _a[i, j] = value; }
        }
    }
}

using System;
 
namespace Gauss
{
    class Program
    {
        static void Main()
        {
            var d = new double[,] {{1, 20, 3}, {4, 5, 6}, {7, 200, 9}};
            var matrix = new Matrix(d);
            var x = matrix.Determinant;
            Console.WriteLine(matrix.PrintMatrix());
            Console.WriteLine(x);
            Console.ReadKey();
        }
    }
}