Data Analysis Mathematics Linear Algebra Statistics
New Version 7.0!  QuickStart Samples

# Iterative Sparse Solvers QuickStart Sample (C#)

Illustrates the use of iterative sparse solvers and preconditioners for efficiently solving large, sparse systems of linear equations in C#.

```using System;

namespace Extreme.Numerics.QuickStart.CSharp
{
using Extreme.Mathematics;
// Sparse matrices are in the Extreme.Mathematics.LinearAlgebra
// namespace
using Extreme.Mathematics.LinearAlgebra;
using Extreme.Mathematics.LinearAlgebra.IterativeSolvers;
using Extreme.Mathematics.LinearAlgebra.IterativeSolvers.Preconditioners;
using Extreme.Mathematics.LinearAlgebra.IO;

/// <summary>
/// Illustrates the use of iterative sparse solvers for efficiently
/// solving large, sparse systems of linear equations using the
/// iterative sparse solver and preconditioner classes from the
/// Extreme.Mathematics.LinearAlgebra.IterativeSolvers namespace of
/// the Extreme Optimization Numerical Libraries for .NET.
/// </summary>
class IterativeSparseSolvers
{
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
// This QuickStart Sample illustrates how to solve sparse linear systems
// using iterative solvers.

// IterativeSparseSolver is the base class for all
// iterative solver classes:

//
// Non-symmetric systems
//

Console.WriteLine("Non-symmetric systems");

// We load a sparse matrix and right-hand side from a data file:

Console.WriteLine("Solve Ax = b");
Console.WriteLine("A is {0}x{1} with {2} nonzeros.", A.RowCount, A.ColumnCount, A.NonzeroCount);

// Some solvers are suitable for symmetric matrices only.
// Our matrix is not symmetric, so we need a solver that
// can handle this:

solver.Solve(b);
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.SolutionReport.Error);

// Using a preconditioner can improve convergence. You can use
// one of the predefined preconditioners, or supply your own.

// With incomplete LU preconditioner
solver.Preconditioner = new IncompleteLUPreconditioner<double>(A);
solver.Solve(b);
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.EstimatedError);

//
// Symmetrical systems
//

Console.WriteLine("Symmetric systems");

// In this example we solve the Laplace equation on a rectangular grid
// with Dirichlet boundary conditions.

// We create 100 divisions in each direction, giving us 99 interior points
// in each direction:
int nx = 99;
int ny = 99;

// The boundary conditions are just some arbitrary functions.
var left = Vector.Create(ny, i => { double x = (i / (nx - 1.0)); return x * x; });
var right = Vector.Create(ny, i => { double x = (i / (nx - 1.0)); return 1 - x; });
var top = Vector.Create(nx, i => { double x = (i / (nx - 1.0)); return Elementary.SinPi(5 * x); });
var bottom = Vector.Create(nx, i => { double x = (i / (nx - 1.0)); return Elementary.CosPi(5 * x); });

// We discretize the Laplace operator using the 5 point stencil.
var laplacian = Matrix.CreateSparse<double>(nx * ny, nx * ny, 5 * nx * ny);
var rhs = Vector.Create<double>(nx * ny);
for (int j = 0; j < ny; j++) {
for (int i = 0; i < nx; i++) {
int ix = j * nx + i;
if (j > 0)
laplacian[ix, ix - nx] = 0.25;
if (i > 0)
laplacian[ix, ix - 1] = 0.25;
laplacian[ix, ix] = -1.0;
if (i + 1 < nx)
laplacian[ix, ix + 1] = 0.25;
if (j + 1 < ny)
laplacian[ix, ix + nx] = 0.25;
}
}
// We build up the right-hand sides using the boundary conditions:
for (int i = 0; i < nx; i++) {
rhs[i] = -0.25 * top[i];
rhs[nx * (ny - 1) + i] = -0.25 * bottom[i];
}
for (int j = 0; j < ny; j++) {
rhs[j * nx] -= 0.25 * left[j];
rhs[j * nx + nx - 1] -= 0.25 * right[j];
}

// Finally, we create an iterative solver suitable for
// symmetric systems...
solver = new QuasiMinimalResidualSolver<double>(laplacian);
// and solve using the right-hand side we just calculated:
solver.Solve(rhs);

Console.WriteLine("Solve Ax = b");
Console.WriteLine("A is {0}x{1} with {2} nonzeros.", A.RowCount, A.ColumnCount, A.NonzeroCount);
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.EstimatedError);

Console.Write("Press Enter key to exit...");