示例#1
0
        static void Main()
        {
            try
            {
                //SVD: анализ с унитарными преобразованиями
                var SVD_Thread = new Thread(() =>
                {
                    //Excel
                    var Excel_WR = new Excel_Reader_Writer();

                    //плотная матрица из файла Excel
                    var A = Excel_WR.Read_Matrix("C:\\Users\\Жопчики\\Desktop\\Даша\\projects-with-git\\чм 4 лаба\\SVD\\Com_Methods\\Com_Methods\\Data\\Excel_Data\\2a.xlsx");



                    //открываем Excel
                    //Excel_WR.Write_Matrix(A, "Matrix A");

                    //Binary_Reader_Writer.Save_Object(A, "C:\\Users\\Жопчики\\Desktop\\Даша\\projects-with-git\\чм 4 лаба\\SVD\\Com_Methods\\Com_Methods\\Data\\Original.bin");

                    var SVD = new SVD(A);
                    SVD.Reduction_SVD(1e-15);

                    Matrix Res = SVD.U * SVD.Sigma * SVD.V.Transpose_Matrix();
                    // Excel_WR.Write_Matrix(SVD.U * SVD.Sigma * SVD.V.Transpose_Matrix(), "Compression Matrix");
                    //double qmax = 0;
                    //for (int i = 0; i < A.M; i++)
                    //    for (int j = 0; j < A.N; j++)
                    //    {
                    //        if (A.Elem[i][j] > CONST.EPS)
                    //        {
                    //            double q = Math.Abs(A.Elem[i][j] - Res.Elem[i][j]) / Math.Abs(A.Elem[i][j]);
                    //            if (qmax < q) qmax = q;
                    //        }
                    //    }
                    //Console.WriteLine("Quality:"+qmax);

                    // Binary_Reader_Writer.Save_ObjectThree(SVD.Sigma, SVD.U, SVD.V, "C:\\Users\\Жопчики\\Desktop\\Даша\\projects-with-git\\чм 4 лаба\\SVD\\Com_Methods\\Com_Methods\\Data\\SVD.bin");

                    Console.WriteLine("\nMatrix U:");
                    SVD.U.Console_Write_Matrix();

                    Console.WriteLine("\nMatrix Sigma (size {0}):", SVD.Sigma.M);
                    for (int i = 0; i < SVD.Sigma.M; i++)
                    {
                        Console.WriteLine(SVD.Sigma.Elem[i][i]);
                    }

                    Console.WriteLine("\nMatrix V:");
                    SVD.V.Console_Write_Matrix();

                    Console.WriteLine("\nMatrix A = U * Sigma * Vt:");
                    (SVD.U * SVD.Sigma * SVD.V.Transpose_Matrix()).Console_Write_Matrix();

                    //ранг матрицы
                    Console.WriteLine("\nrk(A) = " + SVD.Rank());

                    //определитель матрицы
                    Console.WriteLine("\n|det(A)| = " + SVD.Abs_Det());

                    // число обусловленности
                    Console.WriteLine("\nCond(A) = " + SVD.Cond());

                    Eigenvalue_Problem problem = new Eigenvalue_Problem();
                    List <double> lyambdaMax   = new List <double> ();
                    lyambdaMax = problem.Find_Eigenvalues_QR_Iterations(A, QR_Decomposition.QR_Algorithm.Householder);
                    double max = 0;
                    for (int i = 0; i < Res.M; i++)
                    {
                        if (lyambdaMax[i] > max)
                        {
                            max = lyambdaMax[i];
                        }
                    }
                    //число обусловленности
                    Console.WriteLine("\nCondInfinity(A) = " + A.Cond_InfinityNorm());

                    Console.WriteLine("\nCond2(A) = " + Math.Sqrt(max));

                    // решение СЛАУ
                    var X_True = new Vector(A.N);
                    for (int i = 0; i < A.N; i++)
                    {
                        X_True.Elem[i] = 1.0;
                    }
                    var F = A * X_True;
                    var X = SVD.Start_Solver(F);
                    Console.WriteLine("\nResult:");
                    foreach (var el in X.Elem)
                    {
                        Console.WriteLine(el);
                    }
                    //норма невязки ||Ax - f||
                    Console.WriteLine("\nRelative_Discrepancy: {0}", Tools.Relative_Discrepancy(A, X, F));
                });

                //время работы программы
                Console.WriteLine("\n" + Tools.Measurement_Time(SVD_Thread));
            }
            catch (Exception E)
            {
                Console.WriteLine("\n*** Error! ***");
                Console.WriteLine("Method:  {0}", E.TargetSite);
                Console.WriteLine("Message: {0}\n", E.Message);
            }
        }
示例#2
0
        public List <double> Eigenvalues(QR_Decomposition.QR_Algorithm Method)
        {
            if (N != M)
            {
                throw new Exception("Eigenvalues: invalid size of matrix...");
            }

            //создадим копию данной матрицы, чтобы не изменять её
            Matrix T = new Matrix(N, N);

            T.Copy(this);
            List <double> RES = new List <double>();


            //приведём матрицу к верхней форме Хессенберга
            T.Hessenberg_Matrix();
            int t = 1;

            //QR-итерации
            while (T.M != 1)
            {
                Console.WriteLine("Iteration {0} ", t);
                T.Console_Write_Matrix();
                Console.WriteLine(" ");

                for (int i = T.M - 1; i > 0; i--)
                {
                    //если элемент А[i][i-1] == 0, то A[i][i] - собственное значение
                    if (Math.Abs(T.Elem[i][i - 1]) < 1e-6)
                    {
                        RES.Add(T.Elem[i][i]);
                        //исключаем i-ые строку и столбец
                        T.Delete_Row_Column(i);
                        i = T.M;
                    }
                }

                if (T.M == 1)
                {
                    break;
                }

                //прямой сдвиг
                double shift = Eigenvalue_Problem.Rayleigh_Shift(T);
                Eigenvalue_Problem.Shift(T, -shift);

                var QR = new QR_Decomposition(T, Method);

                T = QR.R * QR.Q;

                Eigenvalue_Problem.Shift(T, shift);

                //аварийное завершение цикла
                t++;
                if (t == 100)
                {
                    break;
                }
            }

            //дополняем список последним оставшимся собственным значением
            RES.Add(T.Elem[0][0]);

            //сортируем по возрастанию и формируем результат
            RES.Sort((double X, double Y) => { if (X > Y)
                                               {
                                                   return(0);
                                               }
                                               return(1); });

            return(RES);
        }