/// <summary>
/// Example program that illustrates how to solve a nonsymmetric generalized eigenvalue
/// problem in complex shift and invert mode (taking the real part of OP*x).
/// </summary>
/// <remarks>
/// MODULE LNSymGSC.cc
///
/// In this example we try to solve A*x = B*x*lambda in complex shift and inverse mode,
/// where A is the tridiagonal matrix with 2 on the diagonal, -2 on the subdiagonal and
/// 3 on the superdiagonal, and B is the tridiagonal matrix with 4 on the diagonal and
/// 1 on the off-diagonals. The shift is a complex number.
///
/// The SuperLU package is called to solve some complex linear systems involving (A-sigma*B).
/// </remarks>
static void LNSymGSC()
{
int n = 100; // Dimension of the problem.
// Creating matrices A and B.
var A = Generate.NonSymMatrixE(n);
var B = Generate.NonSymMatrixF(n);
// Defining what we need: the four eigenvectors nearest to 0.4 + 0.6i.
var prob = new Arpack(A, B)
{
ComputeEigenVectors = true
};
// Finding eigenvalues and eigenvectors.
var result = prob.SolveGeneralized(4, 0.4, 0.6, 'R');
// Printing solution.
Solution.General(A, B, (ArpackResult)result, true, true);
}
/// <summary>
/// Example program that illustrates how to solve a real symmetric generalized eigenvalue
/// problem in Cayley mode.
/// </summary>
/// <remarks>
/// MODULE LSymGCay.cc
///
/// In this example we try to solve A*x = B*x*lambda in Cayley mode, where A and B are obtained
/// from the finite element discretization of the 1-dimensional discrete Laplacian
/// d^2u / dx^2
/// on the interval [0,1] with zero Dirichlet boundary conditions using piecewise linear elements.
///
/// The SuperLU package is called to solve some linear systems involving (A-sigma*B).
/// </remarks>
static void LSymGCay()
{
int n = 100; // Dimension of the problem.
// Creating matrices A and B.
var A = Generate.SymmetricMatrixC(n);
var B = Generate.SymmetricMatrixD(n);
// Defining what we need: the four eigenvectors nearest to 150.0.
var prob = new Arpack(A, B, true)
{
ComputeEigenVectors = true
};
// Finding eigenvalues and eigenvectors.
var result = prob.SolveGeneralized(4, 150.0, ShiftMode.Cayley);
// Printing solution.
Solution.Symmetric(A, B, (ArpackResult)result, ShiftMode.Cayley);
}
/// <summary>
/// Example program that illustrates how to solve a real symmetric generalized eigenvalue
/// problem in regular mode.
/// </summary>
/// <remarks>
/// MODULE LSymGReg.cc
///
/// In this example we try to solve A*x = B*x*lambda in regular mode, where A and B are obtained
/// from the finite element discretization of the 1-dimensional discrete Laplacian
/// d^2u / dx^2
/// on the interval [0,1] with zero Dirichlet boundary conditions using piecewise linear elements.
///
/// The SuperLU package is called to solve some linear systems involving B.
/// </remarks>
static void LSymGReg()
{
int n = 100; // Dimension of the problem.
// Creating matrices A and B.
var A = Generate.SymmetricMatrixC(n);
var B = Generate.SymmetricMatrixD(n);
// Defining what we need: the four eigenvectors with largest magnitude.
var prob = new Arpack(A, B, true)
{
ComputeEigenVectors = true
};
// Finding eigenvalues and eigenvectors.
var result = prob.SolveGeneralized(4, Spectrum.LargestMagnitude);
// Printing solution.
Solution.Symmetric(A, B, (ArpackResult)result, ShiftMode.None);
}
/// <summary>
/// Example program that illustrates how to solve a real nonsymmetric generalized eigenvalue
/// problem in real shift and invert mode.
/// </summary>
/// <remarks>
/// MODULE LNSymGSh.cc
///
/// In this example we try to solve A*x = B*x*lambda in shift and inverse mode, where A and B
/// are derived from the finite element discretization of the 1-dimensional convection-diffusion
/// operator
/// (d^2u / dx^2) + rho*(du/dx)
/// on the interval [0,1] with zero Dirichlet boundary conditions using linear elements.
/// The shift sigma is a real number.
///
/// The SuperLU package is called to solve some linear systems involving (A-sigma*B).
/// </remarks>
static void LNSymGSh()
{
int n = 100; // Dimension of the problem.
double rho = 10.0; // A parameter used in StiffnessMatrix.
// Creating matrices A and B.
var A = Generate.StiffnessMatrix(n, rho);
var B = Generate.MassMatrix(n);
// Defining what we need: the four eigenvectors nearest to 1.0.
var prob = new Arpack(A, B)
{
ComputeEigenVectors = true
};
// Finding eigenvalues and eigenvectors.
var result = prob.SolveGeneralized(4, 1.0);
// Printing solution.
Solution.General(A, B, (ArpackResult)result, true);
}
/// <summary>
/// Example program that illustrates how to solve a complex generalized eigenvalue
/// problem in regular mode.
/// </summary>
/// <remarks>
/// MODULE LCompGRe.cc
///
/// In this example we try to solve A*x = B*x*lambda in regular mode, where A and B are
/// derived from the finite element discretization of the 1-dimensional convection-diffusion
/// operator
/// (d^2u/dx^2) + rho*(du/dx)
///
/// on the interval [0,1], with zero boundary conditions, using piecewise linear elements.
/// </remarks>
static void LCompGRe()
{
int n = 100; // Dimension of the problem.
Complex rho = 10.0;
// Creating complex matrices A and B.
var A = Generate.CompMatrixE(n, rho);
var B = Generate.CompMatrixF(n);
// Defining what we need: the four eigenvectors with largest magnitude.
var dprob = new Arpack(A, B)
{
ComputeEigenVectors = true
};
// Finding eigenvalues and eigenvectors.
var result = dprob.SolveGeneralized(4, Spectrum.LargestMagnitude);
// Printing solution.
Solution.Print(A, B, (ArpackResult)result, false);
}
/// <summary>
/// Example program that illustrates how to solve a complex generalized eigenvalue
/// problem in shift and invert mode.
/// </summary>
/// <remarks>
/// MODULE LCompGSh.cc
///
/// In this example we try to solve A*x = B*x*lambda in shift and invert mode, where A and B
/// are derived from a finite element discretization of a 1-dimensional convection-diffusion
/// operator
/// (d^2u/dx^2) + rho*(du/dx)
///
/// on the interval [0,1], with zero boundary conditions, using piecewise linear elements.
/// </remarks>
static void LCompGSh()
{
int n = 100; // Dimension of the problem.
Complex rho = 10.0;
// Creating complex matrices A and B.
var A = Generate.CompMatrixE(n, rho);
var B = Generate.CompMatrixF(n);
// Defining what we need: the four eigenvectors nearest to sigma.
var dprob = new Arpack(A, B)
{
ComputeEigenVectors = true
};
// Finding eigenvalues and eigenvectors.
var result = dprob.SolveGeneralized(4, new Complex(1.0, 0.0));
// Printing solution.
Solution.Print(A, B, (ArpackResult)result, true);
}