Example #1
0
 private static void swapRows(MyMatrix <T> matrix, int row1, int row2)
 {
     if (row1 == row2)
     {
         return;
     }
     for (int i = 0; i < matrix.columnCount; i++)
     {
         T tmp = matrix[row1, i];
         matrix[row1, i] = matrix[row2, i];
         matrix[row2, i] = tmp;
     }
     return;
 }
Example #2
0
        private static MyMatrix <T> countVariables(MyMatrix <T> AB)
        {
            int          n = AB.rowCount;
            MyMatrix <T> X = new MyMatrix <T>(AB.rowCount, 1);

            for (int i = n - 1; i >= 0; i--)
            {
                X[i, 0] = (dynamic)AB[i, n] / AB[i, i];
                for (int k = i - 1; k >= 0; k--)
                {
                    AB[k, n] -= (dynamic)AB[k, i] * X[i, 0];
                }
            }
            return(X);
        }
Example #3
0
        private MyMatrix <T> resultByQueue(MyMatrix <T> vector, List <int> queue)
        {
            MyMatrix <T> tmp = new MyMatrix <T>(vector.rowCount, 1);

            for (int i = 0; i < vector.rowCount; i++)
            {
                for (int j = 0; j < vector.columnCount; j++)
                {
                    tmp[i, j] = vector[i, j];
                }
            }
            for (int i = 0; i < vector.rowCount; i++)
            {
                vector[queue[i], 0] = tmp[i, 0];
            }
            return(vector);
        }
Example #4
0
        private static void swapColumns(MyMatrix <T> matrix, int column1, int column2, List <int> queue)
        {
            if (column1 == column2)
            {
                return;
            }
            int tmp = queue[column1];

            queue[column1] = queue[column2];
            queue[column2] = tmp;
            for (int i = 0; i < matrix.rowCount; i++)
            {
                T Tmp = matrix[i, column1];
                matrix[i, column1] = matrix[i, column2];
                matrix[i, column2] = Tmp;
            }
            return;
        }
Example #5
0
        public static MyMatrix <T> operator +(MyMatrix <T> a, MyMatrix <T> b)
        {
            if (a.rowCount != b.rowCount || a.columnCount != b.columnCount)
            {
                Console.WriteLine("Matrices sizes are incorrect for operation : a + b!");
                return(null);
            }

            MyMatrix <T> c = new MyMatrix <T>(a.rowCount, a.columnCount);

            for (int i = 0; i < a.rowCount; i++)
            {
                for (int j = 0; j < a.columnCount; j++)
                {
                    c.matrix[i, j] = (dynamic)a.matrix[i, j] + (dynamic)b.matrix[i, j];
                }
            }
            return(c);
        }
Example #6
0
        public Fraction countDiffWithSameType(MyMatrix <T> matrix)
        {
            if (rowCount != matrix.rowCount)
            {
                throw new Exception("Wrong vector sizes!");
            }
            if (columnCount != matrix.columnCount)
            {
                throw new Exception("Wrong Matrices sizes!");
            }
            Fraction[,] thisTmp   = new Fraction[rowCount, columnCount];
            Fraction[,] matrixTmp = new Fraction[rowCount, columnCount];
            for (int i = 0; i < rowCount; i++)
            {
                for (int j = 0; j < columnCount; j++)
                {
                    if (typeof(T) == typeof(Fraction))
                    {
                        thisTmp[i, j]   = new Fraction((dynamic)this[i, j]);
                        matrixTmp[i, j] = new Fraction((dynamic)matrix[i, j]);
                    }
                    else
                    {
                        thisTmp[i, j]   = new Fraction(this[i, j].ToString());
                        matrixTmp[i, j] = new Fraction(matrix[i, j].ToString());
                    }
                }
            }
            Fraction sum = default(Fraction);

            for (int i = 0; i < rowCount; i++)
            {
                for (int j = 0; j < columnCount; j++)
                {
                    sum += Fraction.fracABS(thisTmp[i, j] - matrixTmp[i, j]);
                }
            }
            int      count = rowCount * columnCount;
            Fraction div   = new Fraction(count.ToString());

            return(sum / div);
        }
Example #7
0
        public static MyMatrix <T> operator *(MyMatrix <T> a, MyMatrix <T> b)
        {
            if (a.columnCount != b.rowCount)
            {
                Console.WriteLine("Matrices sizes are incorrect for operation : a * b!");
                return(null);
            }
            MyMatrix <T> c = new MyMatrix <T>(a.rowCount, b.columnCount);

            for (int i = 0; i < a.rowCount; i++)
            {
                for (int j = 0; j < b.columnCount; j++)
                {
                    c.matrix[i, j] = default(T);
                    for (int k = 0; k < b.rowCount; k++)
                    {
                        c.matrix[i, j] += (dynamic)a.matrix[i, k] * (dynamic)b.matrix[k, j];
                    }
                }
            }
            return(c);
        }
Example #8
0
        private static void findBiggestValue(MyMatrix <T> AB, int index, List <int> queue)
        {
            //size :  n x (n+1) / 'AB' Matrix
            T   max         = AB[index, index];
            int rowIndex    = index;
            int columnIndex = index;

            for (int i = index; i < AB.rowCount; i++)
            {
                for (int j = index; j < AB.columnCount - 1; j++)   //columnCount - 1 , to only look at nxn matrix
                {
                    if ((dynamic)ABS(AB[i, j]) > max)
                    {
                        max         = (dynamic)ABS(AB[i, j]);
                        rowIndex    = i;
                        columnIndex = j;
                    }
                }
            }
            swapRows(AB, index, rowIndex);
            swapColumns(AB, index, columnIndex, queue);
        }
Example #9
0
        public static MyMatrix <T> gauss(MyMatrix <T> AB, int version)
        {
            if (AB.rowCount != AB.columnCount - 1)
            {
                throw new Exception("Matrix N x (N+1) is required for Gaussian Eliminations!");
            }
            int        n     = AB.rowCount;
            List <int> queue = new List <int>();

            if (version == 1)   //base
            {
                for (int i = 0; i < n; i++)
                {
                    for (int k = i + 1; k < n; k++)
                    {
                        T c = (dynamic)((dynamic)default(T) - AB[k, i]) / AB[i, i];
                        for (int j = i; j < n + 1; j++)
                        {
                            if (i == j)
                            {
                                AB[k, j] = default(T);
                            }
                            else
                            {
                                AB[k, j] += c * (dynamic)AB[i, j];
                            }
                        }
                    }
                }
            }
            else if (version == 2)   //partional
            {
                for (int i = 0; i < n; i++)
                {
                    T   max    = ABS(AB[i, i]);
                    int maxRow = i;
                    for (int k = i + 1; k < n; k++)
                    {
                        if ((dynamic)ABS(AB[k, i]) > max)
                        {
                            max    = ABS(AB[k, i]);
                            maxRow = k;
                        }
                    }
                    for (int k = i; k < n + 1; k++)
                    {
                        T tmp = (dynamic)AB[maxRow, k];
                        AB[maxRow, k] = AB[i, k];
                        AB[i, k]      = tmp;
                    }

                    for (int k = i + 1; k < n; k++)
                    {
                        T c = ((dynamic)default(T) - AB[k, i]) / AB[i, i];
                        for (int j = i; j < n + 1; j++)
                        {
                            if (i == j)
                            {
                                AB[k, j] = default(T);
                            }
                            else
                            {
                                AB[k, j] += (dynamic)c * AB[i, j];
                            }
                        }
                    }
                }
            }
            else if (version == 3)   //full
            {
                for (int i = 0; i < n; i++)
                {
                    queue.Add(i);
                }
                for (int i = 0; i < n; i++)
                {
                    findBiggestValue(AB, i, queue);
                    for (int k = i + 1; k < n; k++)
                    {
                        T c = ((dynamic)default(T) - AB[k, i]) / AB[i, i];
                        for (int j = i; j < n + 1; j++)
                        {
                            if (i == j)
                            {
                                AB[k, j] = default(T);
                            }
                            else
                            {
                                AB[k, j] += (dynamic)c * AB[i, j];
                            }
                        }
                    }
                }
            }
            else
            {
                throw new Exception("Unknown Gauss elimination version! 1 - base, 2 - partial, 3 - full");
            }
            MyMatrix <T> X = countVariables(AB);

            if (version == 3)
            {
                X.resultByQueue(X, queue);
            }
            return(X);
        }
Example #10
0
        public static void getInfo()
        {
            Console.WriteLine("GETTING INFORMATION :" + DateTime.Now.ToString());
            int size = retrieveSize("size.txt");

            double[,] sumOperationTimes  = new double[3, 6];
            double[,] sumOperationErrors = new double[3, 6];
            double[] sumEigenOperationTimes  = new double[5];
            string[] avgEigenOperationErrors = new string[2];
            avgEigenOperationErrors[0] = retrieveError(gaussErrDir + "\\" + "GaussPartialError.txt");
            avgEigenOperationErrors[1] = retrieveError(gaussErrDir + "\\" + "GaussFullError.txt");

            for (int c = 0; c < countOfVersions; c++)
            {
                double[,] operationTimes  = new double[3, 6];
                double[,] operationErrors = new double[3, 6];
                double[] eigenOperationTimes  = new double[5];
                double[] eigenOperationErrors = new double[2];
                string   filePath             = genDir + "\\" + valuesDir + (c + 1) + "\\";
                Console.WriteLine("\n\n\nOpening directory : " + filePath);
                MyMatrix <double>[]   matricesDouble   = new MyMatrix <double> [countOfMatrices];
                MyMatrix <double>     vectorDouble     = new MyMatrix <double>(convertToDouble(loadMatrix(filePath + "vector.txt", size, 1)));
                MyMatrix <float>[]    matricesFloat    = new MyMatrix <float> [countOfMatrices];
                MyMatrix <float>      vectorFloat      = new MyMatrix <float>(convertToFloat(loadMatrix(filePath + "vector.txt", size, 1)));
                MyMatrix <Fraction>[] matricesFraction = new MyMatrix <Fraction> [countOfMatrices];
                MyMatrix <Fraction>   vectorFraction   = new MyMatrix <Fraction>(convertToFraction(loadMatrix(filePath + "vector.txt", size, 1)));
                for (int i = 0; i < countOfMatrices; i++)
                {
                    matricesDouble[i]   = new MyMatrix <double>(convertToDouble(loadMatrix(filePath + "matrix" + (i + 1) + ".txt", size, size)));
                    matricesFloat[i]    = new MyMatrix <float>(convertToFloat(loadMatrix(filePath + "matrix" + (i + 1) + ".txt", size, size)));
                    matricesFraction[i] = new MyMatrix <Fraction>(convertToFraction(loadMatrix(filePath + "matrix" + (i + 1) + ".txt", size, size)));
                }
                MyMatrix <Fraction> AXeigenFraction   = new MyMatrix <Fraction>(convertToFraction(loadMatrix(filePath + "AX.txt", size, 1)));
                MyMatrix <Fraction> ABCXeigenFraction = new MyMatrix <Fraction>(convertToFraction(loadMatrix(filePath + "ABCX.txt", size, 1)));
                MyMatrix <Fraction> ABCeigenFraction  = new MyMatrix <Fraction>(convertToFraction(loadMatrix(filePath + "ABC.txt", size, size)));
                eigenOperationTimes[0] = retrieveTime(filePath + "AX.txt");
                eigenOperationTimes[1] = retrieveTime(filePath + "ABCX.txt");
                eigenOperationTimes[2] = retrieveTime(filePath + "ABC.txt");
                eigenOperationTimes[3] = retrieveTime(filePath + "partial.txt");
                eigenOperationTimes[4] = retrieveTime(filePath + "full.txt");
                Console.WriteLine("\nOPERATIONS OF MATRICES\n");
                //-----------------------------------------------AX-----------------------------------------------
                Console.WriteLine("A * X\n");
                //FLOAT
                Stopwatch        stopWatch = new Stopwatch();
                MyMatrix <float> AXfloat;
                stopWatch.Start();
                AXfloat = matricesFloat[0] * vectorFloat;
                stopWatch.Stop();
                operationTimes[0, 0] = stopWatch.ElapsedMilliseconds;
                Fraction AXfloatError = AXfloat.countDiffWithFrac(AXeigenFraction);
                operationErrors[0, 0] = AXfloatError.ToDouble();
                Console.WriteLine("A * X FLOAT : ");
                Console.WriteLine("err : " + AXfloatError.ToDouble());
                Console.WriteLine("time : " + operationTimes[0, 0] + " ms");
                Console.WriteLine("----------------------------");
                //DOUBLE
                MyMatrix <double> AXdouble;
                stopWatch.Restart();
                AXdouble = matricesDouble[0] * vectorDouble;
                stopWatch.Stop();
                operationTimes[1, 0] = stopWatch.ElapsedMilliseconds;
                Fraction AXdoubleError = AXdouble.countDiffWithFrac(AXeigenFraction);
                operationErrors[1, 0] = AXdoubleError.ToDouble();
                Console.WriteLine("A * X DOUBLE : ");
                Console.WriteLine("err : " + AXdoubleError.ToDouble());
                Console.WriteLine("time : " + operationTimes[1, 0] + " ms");
                Console.WriteLine("----------------------------");
                //FRACTION
                //MyMatrix<Fraction> AXfraction;
                //stopWatch.Restart();
                //AXfraction = matricesFraction[0] * vectorFraction;
                //stopWatch.Stop();
                //operationTimes[2, 0] = stopWatch.ElapsedMilliseconds;
                //Fraction AXfractionError = AXfraction.countDiffWithFrac(AXeigenFraction)
                //operationErrors[2, 0] = AXfractionError.ToDouble();
                //Console.WriteLine("A * X FRACTION : ");
                //Console.WriteLine("err : " + AXfractionError.ToDouble());
                //Console.WriteLine("time : " + operationTimes[2, 0] + " ms");
                //Console.WriteLine("----------------------------");
                //-----------------------------------------------(A+B+C) * X-----------------------------------------------
                Console.WriteLine("(A+B+C) * X\n");
                //FLOAT
                MyMatrix <float> ABCXfloat;
                stopWatch.Restart();
                ABCXfloat = (matricesFloat[0] + matricesFloat[1] + matricesFloat[2]) * vectorFloat;
                stopWatch.Stop();
                operationTimes[0, 1] = stopWatch.ElapsedMilliseconds;
                Fraction ABCXfloatError = ABCXfloat.countDiffWithFrac(ABCXeigenFraction);
                operationErrors[0, 1] = ABCXfloatError.ToDouble();
                Console.WriteLine("(A+B+C) * X FLOAT : ");
                Console.WriteLine("err : " + ABCXfloatError.ToDouble());
                Console.WriteLine("time : " + operationTimes[0, 1] + " ms");
                Console.WriteLine("----------------------------");
                //DOUBLE
                MyMatrix <double> ABCXdouble;
                stopWatch.Restart();
                ABCXdouble = (matricesDouble[0] + matricesDouble[1] + matricesDouble[2]) * vectorDouble;
                stopWatch.Stop();
                operationTimes[1, 1] = stopWatch.ElapsedMilliseconds;
                Fraction ABCXdoubleError = ABCXdouble.countDiffWithFrac(ABCXeigenFraction);
                operationErrors[1, 1] = ABCXdoubleError.ToDouble();
                Console.WriteLine("(A+B+C) * X DOUBLE : ");
                Console.WriteLine("err : " + ABCXdoubleError.ToDouble());
                Console.WriteLine("time : " + operationTimes[1, 1] + " ms");
                Console.WriteLine("----------------------------");
                //FRACTION
                //MyMatrix<Fraction> ABCXfraction;
                //stopWatch.Restart();
                //ABCXfraction = (matricesFraction[0] + matricesFraction[1] + matricesFraction[2]) * vectorFraction;
                //stopWatch.Stop();
                //operationTimes[2, 1] = stopWatch.ElapsedMilliseconds;
                //Fraction ABCXfractionError = ABCXfraction.countDiffWithFrac(ABCXeigenFraction);
                //operationErrors[2, 1] = ABCXfractionError.ToDouble();
                //Console.WriteLine("(A+B+C) * X FRACTION : ");
                //Console.WriteLine("err : " + ABCXfractionError.ToDouble());
                //Console.WriteLine("time : " + operationTimes[2, 1] + " ms");
                //Console.WriteLine("----------------------------");

                //-----------------------------------------------A * B * C-----------------------------------------------
                Console.WriteLine("A * B * C\n");
                //FLOAT
                MyMatrix <float> ABCfloat;
                stopWatch.Restart();
                ABCfloat = matricesFloat[0] * matricesFloat[1] * matricesFloat[2];
                stopWatch.Stop();
                operationTimes[0, 2] = stopWatch.ElapsedMilliseconds;
                Fraction ABCfloatError = ABCfloat.countDiffWithFrac(ABCeigenFraction);
                operationErrors[0, 2] = ABCfloatError.ToDouble();
                Console.WriteLine("A * B * C FLOAT : ");
                Console.WriteLine("err : " + ABCfloatError.ToDouble());
                Console.WriteLine("time : " + operationTimes[0, 2] + " ms");
                Console.WriteLine("----------------------------");
                //DOUBLE
                MyMatrix <double> ABCdouble;
                stopWatch.Restart();
                ABCdouble = matricesDouble[0] * matricesDouble[1] * matricesDouble[2];
                stopWatch.Stop();
                operationTimes[1, 2] = stopWatch.ElapsedMilliseconds;
                Fraction ABCdoubleError = ABCdouble.countDiffWithFrac(ABCeigenFraction);
                operationErrors[1, 2] = ABCdoubleError.ToDouble();
                Console.WriteLine("A * B * C DOUBLE : ");
                Console.WriteLine("err : " + ABCdoubleError.ToDouble());
                Console.WriteLine("time : " + operationTimes[1, 2] + " ms");
                Console.WriteLine("----------------------------");
                //FRACTION
                //MyMatrix<Fraction> ABCfraction;
                //stopWatch.Restart();
                //ABCfraction = matricesFraction[0] * matricesFraction[1] * matricesFraction[2];
                //stopWatch.Stop();
                //operationTimes[2, 2] = stopWatch.ElapsedMilliseconds;
                //Fraction ABCfractionError = ABCfraction.countDiffWithFrac(ABCeigenFraction);
                //operationErrors[2, 2] = ABCfractionError.ToDouble();
                //Console.WriteLine("A * B * C FRACTION : ");
                //Console.WriteLine("err : " + ABCfractionError.ToDouble());
                //Console.WriteLine("time : " + operationTimes[2, 2] + " ms");
                //Console.WriteLine("----------------------------");


                //END OF MATRICES OPERATIONS...
                MyMatrix <float>    somewhatVectorFloat;
                MyMatrix <double>   somewhatVectorDouble;
                MyMatrix <Fraction> somewhatVectorFraction;

                Console.WriteLine("\nGAUSS ELIMINATIONS\n");

                //-----------------------------------------------GAUSS BASE-----------------------------------------------
                Console.WriteLine("GAUSS BASE\n");
                //FLOAT
                MyMatrix <float> gaussBaseResultFloat;
                MyMatrix <float> ABForGaussBaseFloat = MyMatrix <float> .matrixJoinVector(matricesFloat[0], vectorFloat);

                stopWatch.Restart();
                gaussBaseResultFloat = MyMatrix <float> .gauss(ABForGaussBaseFloat, 1);

                stopWatch.Stop();
                operationTimes[0, 3] = stopWatch.ElapsedMilliseconds;
                somewhatVectorFloat  = matricesFloat[0] * gaussBaseResultFloat;
                Fraction gaussBaseFloatError = somewhatVectorFloat.countDiffWithSameType(vectorFloat);
                operationErrors[0, 3] = gaussBaseFloatError.ToDouble();
                Console.WriteLine("GAUSS BASE FLOAT : ");
                Console.WriteLine("err : " + gaussBaseFloatError.ToDouble());
                Console.WriteLine("time : " + operationTimes[0, 3] + " ms");
                Console.WriteLine("----------------------------");

                //DOUBLE
                MyMatrix <double> gaussBaseResultDouble;
                MyMatrix <double> ABForGaussBaseDouble = MyMatrix <double> .matrixJoinVector(matricesDouble[0], vectorDouble);

                stopWatch.Restart();
                gaussBaseResultDouble = MyMatrix <double> .gauss(ABForGaussBaseDouble, 1);

                stopWatch.Stop();
                operationTimes[1, 3] = stopWatch.ElapsedMilliseconds;
                somewhatVectorDouble = matricesDouble[0] * gaussBaseResultDouble;
                Fraction gaussBaseDoubleError = somewhatVectorDouble.countDiffWithSameType(vectorDouble);
                operationErrors[1, 3] = gaussBaseDoubleError.ToDouble();
                Console.WriteLine("GAUSS BASE DOUBLE : ");
                Console.WriteLine("err : " + gaussBaseDoubleError.ToDouble());
                Console.WriteLine("time : " + operationTimes[1, 3] + " ms");
                Console.WriteLine("----------------------------");

                //FRACTION
                //MyMatrix<Fraction> gaussBaseResultFraction;
                //MyMatrix<Fraction> ABForGaussBaseFraction = MyMatrix<Fraction>.matrixJoinVector(matricesFraction[0], vectorFraction);
                //stopWatch.Restart();
                //gaussBaseResultFraction = MyMatrix<Fraction>.gauss(ABForGaussBaseFraction, 1);
                //stopWatch.Stop();
                //operationTimes[2, 3] = stopWatch.ElapsedMilliseconds;
                //somewhatVectorFraction = matricesFraction[0] * gaussBaseResultFraction;
                //Fraction gaussBaseFractionError = somewhatVectorFraction.countDiffWithSameType(vectorFraction);
                //operationErrors[2, 3] = gaussBaseFractionError.ToDouble();
                //Console.WriteLine("GAUSS BASE FRACTION : ");
                //Console.WriteLine("err : " + gaussBaseFractionError.ToDouble());
                //Console.WriteLine("time : " + operationTimes[2, 3] + " ms");
                //Console.WriteLine("----------------------------");

                //-----------------------------------------------GAUSS PARTIAL-----------------------------------------------
                Console.WriteLine("GAUSS PARTIAL\n");
                //FLOAT
                MyMatrix <float> gaussPartialResultFloat;
                MyMatrix <float> ABForGaussPartialFloat = MyMatrix <float> .matrixJoinVector(matricesFloat[0], vectorFloat);

                stopWatch.Restart();
                gaussPartialResultFloat = MyMatrix <float> .gauss(ABForGaussPartialFloat, 2);

                stopWatch.Stop();
                operationTimes[0, 4] = stopWatch.ElapsedMilliseconds;
                somewhatVectorFloat  = matricesFloat[0] * gaussPartialResultFloat;
                Fraction gaussPartialFloatError = somewhatVectorFloat.countDiffWithSameType(vectorFloat);
                operationErrors[0, 4] = gaussPartialFloatError.ToDouble();
                Console.WriteLine("GAUSS PARTIAL FLOAT : ");
                Console.WriteLine("err : " + gaussPartialFloatError.ToDouble());
                Console.WriteLine("time : " + operationTimes[0, 4] + " ms");
                Console.WriteLine("----------------------------");

                //DOUBLE
                MyMatrix <double> gaussPartialResultDouble;
                MyMatrix <double> ABForGaussPartialDouble = MyMatrix <double> .matrixJoinVector(matricesDouble[0], vectorDouble);

                stopWatch.Restart();
                gaussPartialResultDouble = MyMatrix <double> .gauss(ABForGaussPartialDouble, 2);

                stopWatch.Stop();
                operationTimes[1, 4] = stopWatch.ElapsedMilliseconds;
                somewhatVectorDouble = matricesDouble[0] * gaussPartialResultDouble;
                Fraction gaussPartialDoubleError = somewhatVectorDouble.countDiffWithSameType(vectorDouble);
                operationErrors[1, 4] = gaussPartialDoubleError.ToDouble();
                Console.WriteLine("GAUSS PARTIAL DOUBLE : ");
                Console.WriteLine("err : " + gaussPartialDoubleError.ToDouble());
                Console.WriteLine("time : " + operationTimes[1, 4] + " ms");
                Console.WriteLine("----------------------------");

                //FRACTION
                //MyMatrix<Fraction> gaussPartialResultFraction;
                //MyMatrix<Fraction> ABForGaussPartialFraction = MyMatrix<Fraction>.matrixJoinVector(matricesFraction[0], vectorFraction);
                //stopWatch.Restart();
                //gaussPartialResultFraction = MyMatrix<Fraction>.gauss(ABForGaussPartialFraction, 2);
                //stopWatch.Stop();
                //operationTimes[2, 4] = stopWatch.ElapsedMilliseconds;
                //somewhatVectorFraction = matricesFraction[0] * gaussPartialResultFraction;
                //Fraction gaussPartialFractionError = somewhatVectorFraction.countDiffWithSameType(vectorFraction);
                //operationErrors[2, 4] = gaussPartialFractionError.ToDouble();
                //Console.WriteLine("GAUSS PARTIAL FRACTION : ");
                //Console.WriteLine("err : " + gaussPartialFractionError.ToDouble());
                //Console.WriteLine("time : " + operationTimes[2, 4] + " ms");
                //Console.WriteLine("----------------------------");

                //-----------------------------------------------GAUSS FULL-----------------------------------------------
                Console.WriteLine("GAUSS FULL\n");
                //FLOAT
                MyMatrix <float> gaussFullResultFloat;
                MyMatrix <float> ABForGaussFullFloat = MyMatrix <float> .matrixJoinVector(matricesFloat[0], vectorFloat);

                stopWatch.Restart();
                gaussFullResultFloat = MyMatrix <float> .gauss(ABForGaussFullFloat, 3);

                stopWatch.Stop();
                operationTimes[0, 5] = stopWatch.ElapsedMilliseconds;
                somewhatVectorFloat  = matricesFloat[0] * gaussFullResultFloat;
                Fraction gaussFullFloatError = somewhatVectorFloat.countDiffWithSameType(vectorFloat);
                operationErrors[0, 5] = gaussFullFloatError.ToDouble();
                Console.WriteLine("GAUSS FULL FLOAT : ");
                Console.WriteLine("err : " + gaussFullFloatError.ToDouble());
                Console.WriteLine("time : " + operationTimes[0, 5] + " ms");
                Console.WriteLine("----------------------------");

                //DOUBLE
                MyMatrix <double> gaussFullResultDouble;
                MyMatrix <double> ABForGaussFullDouble = MyMatrix <double> .matrixJoinVector(matricesDouble[0], vectorDouble);

                stopWatch.Restart();
                gaussFullResultDouble = MyMatrix <double> .gauss(ABForGaussFullDouble, 3);

                stopWatch.Stop();
                operationTimes[1, 5] = stopWatch.ElapsedMilliseconds;
                somewhatVectorDouble = matricesDouble[0] * gaussFullResultDouble;
                Fraction gaussFullDoubleError = somewhatVectorDouble.countDiffWithSameType(vectorDouble);
                operationErrors[1, 5] = gaussFullDoubleError.ToDouble();
                Console.WriteLine("GAUSS FULL DOUBLE : ");
                Console.WriteLine("err : " + gaussFullDoubleError.ToDouble());
                Console.WriteLine("time : " + operationTimes[1, 5] + " ms");
                Console.WriteLine("----------------------------");

                //FRACTION
                //MyMatrix<Fraction> gaussFullResultFraction;
                //MyMatrix<Fraction> ABForGaussFullFraction = MyMatrix<Fraction>.matrixJoinVector(matricesFraction[0], vectorFraction);
                //stopWatch.Restart();
                //gaussFullResultFraction = MyMatrix<Fraction>.gauss(ABForGaussFullFraction,3);
                //stopWatch.Stop();
                //operationTimes[2, 5] = stopWatch.ElapsedMilliseconds;
                //somewhatVectorFraction = matricesFraction[0] * gaussFullResultFraction;
                //Fraction gaussFullFractionError = somewhatVectorFraction.countDiffWithSameType(vectorFraction);
                //operationErrors[2, 5] = gaussFullFractionError.ToDouble();
                //Console.WriteLine("GAUSS FULL FRACTION : ");
                //Console.WriteLine("err : " + gaussFullFractionError.ToDouble());
                //Console.WriteLine("time : " + operationTimes[2, 5] + " ms");
                //Console.WriteLine("----------------------------");

                //-----------------------------------------------GAUSS EIGEN-----------------------------------------------
                //EIGEN PARTIAL
                Console.WriteLine("GAUSS PARTIAL EIGEN : ");
                Console.WriteLine("avg err : " + avgEigenOperationErrors[0]);
                Console.WriteLine("time : " + eigenOperationTimes[3] + " sec");
                Console.WriteLine("----------------------------");
                //EIGEN FULL
                Console.WriteLine("GAUSS FULL EIGEN : ");
                Console.WriteLine("avg err : " + avgEigenOperationErrors[1]);
                Console.WriteLine("time : " + eigenOperationTimes[4] + " sec");
                Console.WriteLine("----------------------------");
                for (int i = 0; i < 3; i++)
                {
                    for (int j = 0; j < 6; j++)
                    {
                        sumOperationTimes[i, j]  += operationTimes[i, j];
                        sumOperationErrors[i, j] += operationErrors[i, j];
                    }
                }
                for (int i = 0; i < 5; i++)
                {
                    sumEigenOperationTimes[i] += eigenOperationTimes[i];
                }
            }
            Console.WriteLine("\n\nSUCCESS : COUNTING AVERAGE VALUES FOR ERRORS AND TIMES FOR " + countOfVersions + " VERSIONS FOR SIZE " + size);

            double[,] avgOperationTimes  = new double[3, 6];
            double[,] avgOperationErrors = new double[3, 6];
            double[] avgEigenOperationTimes = new double[5];
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    avgOperationTimes[i, j]  = sumOperationTimes[i, j] / countOfVersions;
                    avgOperationErrors[i, j] = sumOperationErrors[i, j] / countOfVersions;
                }
            }
            for (int i = 0; i < 5; i++)
            {
                avgEigenOperationTimes[i] = sumEigenOperationTimes[i] / countOfVersions;
            }

            string opAX           = operationsOnMatrixInfo(size, 0, 0, avgOperationErrors, avgOperationTimes, avgEigenOperationTimes);
            string opABCX         = operationsOnMatrixInfo(size, 1, 1, avgOperationErrors, avgOperationTimes, avgEigenOperationTimes);
            string opABC          = operationsOnMatrixInfo(size, 2, 2, avgOperationErrors, avgOperationTimes, avgEigenOperationTimes);
            string opGaussBase    = operationsOnGaussBaseInfo(size, 3, avgOperationErrors, avgOperationTimes);
            string opGaussPartial = operationsOnGaussFullPartialInfo(size, 4, 0, 3, avgOperationErrors, avgOperationTimes, avgEigenOperationTimes, avgEigenOperationErrors);
            string opGaussFull    = operationsOnGaussFullPartialInfo(size, 5, 1, 4, avgOperationErrors, avgOperationTimes, avgEigenOperationTimes, avgEigenOperationErrors);

            if (!Directory.Exists("Results" + size))
            {
                Console.WriteLine("Creating directory : Results" + size);
                DirectoryInfo di = Directory.CreateDirectory("Results" + size);
            }
            File.WriteAllText("Results" + size + "\\" + "AXresult" + size + ".txt", opAX);
            File.WriteAllText("Results" + size + "\\" + "ABCXresult" + size + ".txt", opABCX);
            File.WriteAllText("Results" + size + "\\" + "ABCresult" + size + ".txt", opABC);
            File.WriteAllText("Results" + size + "\\" + "GaussBaseResult" + size + ".txt", opGaussBase);
            File.WriteAllText("Results" + size + "\\" + "GaussPartialResult" + size + ".txt", opGaussPartial);
            File.WriteAllText("Results" + size + "\\" + "GaussFullResult" + size + ".txt", opGaussFull);
        }