public void Run(SparseMatrix A, int m, bool symmetric) { var solver = new Spectra(A, symmetric) { Tolerance = 1e-6, ComputeEigenVectors = true, ArnoldiCount = m * 3 }; var timer = Stopwatch.StartNew(); var result = solver.SolveStandard(m, 0.0); //var result = solver.SolveStandard(m, Spectrum.SmallestMagnitude); //var result = solver.SolveStandard(m, 8.0); //var result = solver.SolveStandard(m, Spectrum.LargestMagnitude); timer.Stop(); Display.Time(timer.ElapsedTicks); result.EnsureSuccess(); if (Helper.CheckResiduals(A, result, symmetric, false)) { Display.Ok("OK"); } else { Display.Warning("residual error too large"); } }
/// <summary> /// Example program that illustrates how to solve a real symmetric standard eigenvalue /// problem in shift and invert mode. /// </summary> /// <remarks> /// MODULE LSymShf.cc /// /// In this example we try to solve A*x = x*lambda in shift and invert mode, where A is /// derived from the central difference discretization of the one-dimensional Laplacian /// on [0, 1] with zero Dirichlet boundary conditions. /// /// The SuperLU package is called to solve some linear systems involving (A-sigma*I). /// This is needed to implement the shift and invert strategy. /// </remarks> static void LSymShf() { int n = 100; // Dimension of the problem. // Creating a 100x100 matrix. var A = Symmetrize(Generate.SymmetricMatrixB(n)); // Defining what we need: the four eigenvectors of A nearest to 1.0. var prob = new Spectra(A, true) { ComputeEigenVectors = true }; // Finding eigenvalues and eigenvectors. var result = prob.SolveStandard(4, 1.0); // Printing solution. Solution.Symmetric(A, (SpectraResult)result, true); }
/// <summary> /// Example program that illustrates how to solve a real symmetric standard eigenvalue /// problem in regular mode. /// </summary> /// <remarks> /// MODULE LSymReg.cc /// /// In this example we try to solve A*x = x*lambda in regular mode, where A is derived /// from the standard central difference discretization of the 2-dimensional Laplacian /// on the unit square with zero Dirichlet boundary conditions. /// </remarks> static void LSymReg() { int nx = 10; // Creating a 100x100 matrix. var A = Symmetrize(Generate.SymmetricMatrixA(nx)); // Defining what we need: the four eigenvectors of A with smallest magnitude. var prob = new Spectra(A, true) { ComputeEigenVectors = true }; // Finding eigenvalues and eigenvectors. var result = prob.SolveStandard(2, Spectrum.SmallestMagnitude); // Printing solution. Solution.Symmetric(A, (SpectraResult)result, false); }
/// <summary> /// Example program that illustrates how to solve a real nonsymmetric standard eigenvalue /// problem in shift and invert mode. /// </summary> /// <remarks> /// MODULE LNSymShf.cc /// /// In this example we try to solve A*x = x*lambda in shift and invert mode, where A is /// derived from 2-D Brusselator Wave Model. The shift is a real number. /// /// The SuperLU package is called to solve some linear systems involving (A-sigma*I). /// </remarks> static void LNSymShf() { int n = 200; // Dimension of the problem. // Creating a 200x200 matrix. var A = Generate.BrusselatorMatrix(1.0, 0.004, 0.008, 2.0, 5.45, n); // Defining what we need: the four eigenvectors of BWM nearest to 0.0. var prob = new Spectra(A) { ComputeEigenVectors = true, ArnoldiCount = 30 }; // Finding eigenvalues and eigenvectors. var result = prob.SolveStandard(4, 0.0, Spectrum.LargestMagnitude); // Printing solution. Solution.General(A, (SpectraResult)result, true); }
/// <summary> /// Example program that illustrates how to solve a real nonsymmetric standard eigenvalue /// problem in regular mode. /// </summary> /// <remarks> /// MODULE LNSymReg.cc /// /// In this example we try to solve A*x = x*lambda in regular mode, where A is derived from /// the standard central difference discretization of the 2-dimensional convection-diffusion /// operator /// (Laplacian u) + rho*(du/dx) /// on a unit square with zero Dirichlet boundary conditions. /// </remarks> static void LNSymReg() { int nx = 10; // Creating a 100x100 matrix. var A = Generate.BlockTridMatrix(nx); // Defining what we need: the four eigenvectors of A with largest magnitude. var prob = new Spectra(A) { ComputeEigenVectors = true }; // Finding eigenvalues and eigenvectors. var result = prob.SolveStandard(4, Spectrum.LargestMagnitude); // Printing solution. Solution.General(A, (SpectraResult)result, false); }