求逆矩阵代码

using System;
using System.Text.RegularExpressions;

namespace CodeS
{
    class Program_3
    {
        static void Inverse(double [] Metrix, int n)
        {
            int i, j, k;
            string str = "";
            for(k=0; k<n; k++)
            {
                for(i=0; i<n; i++)
                {
                    if(i != k)
                    {
                        str = "/ : " + -Metrix[i*n+k] + "/" + Metrix[k*n+k] + " = ";
                        Metrix[i*n+k] = - Metrix[i*n+k] / Metrix[k*n+k];
                        str += Metrix[i*n+k] + "[" + (i*n+k) + "]";
                        Console.WriteLine(str);
                    }
                }
                str = " 1/ : " + Metrix[k*n+k] + " = ";
                Metrix[k*n+k] = 1 / Metrix[k*n+k];
                str += Metrix[k*n+k] + "[" + (k*n+k) + "]";
                Console.WriteLine(str);
        
                for(i=0; i<n; i++)
                {
                    if(i != k)
                    {
                        for(j=0; j<n; j++)
                        {
                            if(j != k)
                            {
                                str = "* : " + Metrix[k*n+j] + "*" + Metrix[i*n+k] + " = ";
                                double t = Metrix[k*n+j] * Metrix[i*n+k];
                                Console.WriteLine(str);
                                str = "+ : " + Metrix[i*n+j] + "+" + t + " = ";
                                Metrix[i*n+j] += t;
                                str += Metrix[i*n+j] + "[" + (i*n+j) + "]";
                                Console.WriteLine(str);
                            }
                        }
                    }
                }
        
                for(j=0; j<n; j++)
                {
                    if(j != k)
                        {
                            str = "* : " + Metrix[k*n+j] + "*" + Metrix[k*n+k] + " = ";
                            Metrix[k*n+j] *= Metrix[k*n+k];
                            str += Metrix[k*n+j] + "[" + (k*n+j) + "]";
                            Console.WriteLine(str);

                        }
                        
                }
            }
        }

        static void InverseEx(int [] Metrix1, int [] Metrix2, int n)
        {
            int i, j, k;
            for(k=0; k<n; k++)
            {
                for(i=0; i<n; i++)
                {
                    if(i != k)
                    {
                        DoDiv(ref Metrix1[i*n+k], ref Metrix2[i*n+k], Metrix1[k*n+k], Metrix2[k*n+k], (i*n+k));
                        Metrix1[i*n+k] = -Metrix1[i*n+k];
                        // Metrix[i*n+k] = -Metrix[i*n+k] / Metrix[k*n+k];
                    }
                }
                //Metrix[k*n+k] = 1 / Metrix[k*n+k];
                DoDivOne(ref Metrix1[k*n+k], ref Metrix2[k*n+k]);
        
                for(i=0; i<n; i++)
                {
                    if(i != k)
                    {
                        for(j=0; j<n; j++)
                        {
                            if(j != k)
                            {
                                int temp1 = 1;
                                int temp2 = 1;
                                DoMulti(ref temp1, ref temp2, Metrix1[i*n+k],Metrix2[i*n+k], (k*n+j));
                                DoMulti(ref temp1, ref temp2, Metrix1[k*n+j],Metrix2[k*n+j], (k*n+j));
                                DoAdd(ref Metrix1[i*n+j], ref Metrix2[i*n+j], temp1, temp2, (i*n+j));
                                // double t = Metrix[k*n+j] * Metrix[i*n+k];
                                // Metrix[i*n+j] += t;
                            }
                        }
                    }
                }
        
                for(j=0; j<n; j++)
                {
                    if(j != k)
                        DoMulti(ref Metrix1[k*n+j], ref Metrix2[k*n+j], Metrix1[k*n+k],Metrix2[k*n+k], (k*n+j));
                        //Metrix[k*n+j] *= Metrix[k*n+k];
                }
            }
        }

        // 分数简化
        static void SimpleFenShu(ref int fenzi, ref int fenmu)
        {
            int temp = Math.Min(fenzi, fenmu);
            if (temp > 1)
            {
                for(int i = 2; i <= temp; )
                {
                    if(temp > 1 && fenzi % i == 0 && fenmu % i == 0)
                    {
                        fenzi = fenzi / i;
                        fenmu = fenmu / i;
                        i = 2;
                        temp = Math.Min(fenzi, fenmu);
                    }
                    else
                        i ++;
                }
            }
            if (fenzi == 0)
                fenmu = 1;
            if (fenmu < 0)
            {
                fenzi = -fenzi;
                fenmu = -fenmu;
            }
        }

        // 分数加法
        static void DoAdd(ref int fenzi1, ref int fenmu1, int fenzi2, int fenmu2, int index)
        {
            if (fenzi1 == 0)
            {
                fenzi1 = fenzi2;
                fenmu1 = fenmu2;
            }
            else if (fenzi2 == 0)
            {

            }
            else
            {
                fenzi1 = fenzi1 * fenmu2 + fenzi2 * fenmu1;
                fenmu1 = fenmu1 * fenmu2;
            }
            SimpleFenShu(ref fenzi1, ref fenmu1);
        }

        // 分数乘法
        static void DoMulti(ref int fenzi1, ref int fenmu1, int fenzi2, int fenmu2, int index)
        {
            fenzi1 = fenzi1 * fenzi2;
            fenmu1 = fenmu1 * fenmu2;
            SimpleFenShu(ref fenzi1, ref fenmu1);
        }

        static void DoDiv(ref int fenzi1, ref int fenmu1, int fenzi2, int fenmu2, int index)
        {
            fenzi1 = fenzi1 * fenmu2;
            fenmu1 = fenzi2 * fenmu1;
            SimpleFenShu(ref fenzi1, ref fenmu1);
        }

        static void DoDivOne(ref int fenzi1, ref int fenmu1)
        {
            int temp = fenzi1;
            fenzi1 = fenmu1;
            fenmu1 = temp;
        }


        static void Main(string[] args)
        {

            double [] Metrix = new double[9] {1,1,1,2,3,2,3,8,2};
            Inverse(Metrix, 3);

            int [] Metrix1 = new int[9] {1,1,1,2,3,2,3,8,2};
            int [] Metrix2 = new int[9] {1,1,1,1,1,1,1,1,1};
            InverseEx(Metrix1, Metrix2, 3);
        }
    }
}