Browse Source
Added optimized versions of L1, Frobenius, and infinity norms to the dense and sparse matrices Added a TransposeAndMultiply method to Matrix DenseMatrix, and SparseMatrix Ported the Gram-Schmidt QR factorization from dnAnalytics Ported the diagonal matrix from dnAnalytics Ported the iterative solvers from dnAnalyticspull/36/head
Marcus Cuda
16 years ago
76 changed files with 15427 additions and 1078 deletions
File diff suppressed because it is too large
@ -0,0 +1,284 @@ |
|||
// <copyright file="GramSchmidt.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Factorization |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// <para>A class which encapsulates the functionality of the QR decomposition Modified Gram-Schmidt Orthogonalization.</para>
|
|||
/// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal mxn matrix and R is an nxn upper triangular matrix.</para>
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The computation of the QR decomposition is done at construction time by modified Gram-Schmidt Orthogonalization.
|
|||
/// </remarks>
|
|||
public class GramSchmidt : QR |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="GramSchmidt"/> class. This object creates an orthogonal matrix
|
|||
/// using the modified Gram-Schmidt method.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix to factor.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> row count is less then column count</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is rank deficient</exception>
|
|||
public GramSchmidt(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount < matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
MatrixQ = matrix.Clone(); |
|||
MatrixR = matrix.CreateMatrix(matrix.ColumnCount, matrix.ColumnCount); |
|||
|
|||
for (var k = 0; k < MatrixQ.ColumnCount; k++) |
|||
{ |
|||
var norm = MatrixQ.Column(k).Norm(2); |
|||
if (norm == 0.0) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixNotRankDeficient); |
|||
} |
|||
|
|||
MatrixR.At(k, k, norm); |
|||
for (var i = 0; i < MatrixQ.RowCount; i++) |
|||
{ |
|||
MatrixQ.At(i, k, MatrixQ.At(i, k) / norm); |
|||
} |
|||
|
|||
for (var j = k + 1; j < MatrixQ.ColumnCount; j++) |
|||
{ |
|||
var dot = MatrixQ.Column(k).DotProduct(MatrixQ.Column(j)); |
|||
MatrixR.At(k, j, dot); |
|||
for (var i = 0; i < MatrixQ.RowCount; i++) |
|||
{ |
|||
var value = MatrixQ.At(i, j) - (MatrixQ.At(i, k) * dot); |
|||
MatrixQ.At(i, j, value); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the matrix is full rank or not.
|
|||
/// </summary>
|
|||
/// <value><c>true</c> if the matrix is full rank; otherwise <c>false</c>.</value>
|
|||
public override bool IsFullRank |
|||
{ |
|||
get |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the determinant of the matrix for which the QR matrix was computed.
|
|||
/// </summary>
|
|||
public override double Determinant |
|||
{ |
|||
get |
|||
{ |
|||
if (MatrixQ.RowCount != MatrixQ.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare); |
|||
} |
|||
|
|||
var det = 1.0; |
|||
for (var i = 0; i < MatrixR.ColumnCount; i++) |
|||
{ |
|||
det *= MatrixR.At(i, i); |
|||
if (Math.Abs(MatrixR.At(i, i)).AlmostEqualInDecimalPlaces(0.0, 15)) |
|||
{ |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
return Math.Abs(det); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>AX = B</b>, with A QR factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side <see cref="Matrix"/>, <b>B</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>X</b>.</param>
|
|||
public override void Solve(Matrix input, Matrix result) |
|||
{ |
|||
// Check for proper arguments.
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// The solution X should have the same number of columns as B
|
|||
if (input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
// The dimension compatibility conditions for X = A\B require the two matrices A and B to have the same number of rows
|
|||
if (MatrixQ.RowCount != input.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension); |
|||
} |
|||
|
|||
// The solution X row dimension is equal to the column dimension of A
|
|||
if (MatrixQ.ColumnCount != result.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
var inputCopy = input.Clone(); |
|||
|
|||
// Compute Y = transpose(Q)*B
|
|||
var column = new double[MatrixQ.RowCount]; |
|||
for (var j = 0; j < input.ColumnCount; j++) |
|||
{ |
|||
for (var k = 0; k < MatrixQ.RowCount; k++) |
|||
{ |
|||
column[k] = inputCopy.At(k, j); |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixQ.ColumnCount; i++) |
|||
{ |
|||
double s = 0; |
|||
for (var k = 0; k < MatrixQ.RowCount; k++) |
|||
{ |
|||
s += MatrixQ.At(k, i) * column[k]; |
|||
} |
|||
|
|||
inputCopy.At(i, j, s); |
|||
} |
|||
} |
|||
|
|||
// Solve R*X = Y;
|
|||
for (var k = MatrixQ.ColumnCount - 1; k >= 0; k--) |
|||
{ |
|||
for (var j = 0; j < input.ColumnCount; j++) |
|||
{ |
|||
inputCopy.At(k, j, inputCopy.At(k, j) / MatrixR.At(k, k)); |
|||
} |
|||
|
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
for (var j = 0; j < input.ColumnCount; j++) |
|||
{ |
|||
inputCopy.At(i, j, inputCopy.At(i, j) - (inputCopy.At(k, j) * MatrixR.At(i, k))); |
|||
} |
|||
} |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixR.ColumnCount; i++) |
|||
{ |
|||
for (var j = 0; j < input.ColumnCount; j++) |
|||
{ |
|||
result.At(i, j, inputCopy.At(i, j)); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>Ax = b</b>, with A QR factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side vector, <b>b</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>x</b>.</param>
|
|||
public override void Solve(Vector input, Vector result) |
|||
{ |
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// Ax=b where A is an m x n matrix
|
|||
// Check that b is a column vector with m entries
|
|||
if (MatrixQ.RowCount != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Check that x is a column vector with n entries
|
|||
if (MatrixQ.ColumnCount != result.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
var inputCopy = input.Clone(); |
|||
|
|||
// Compute Y = transpose(Q)*B
|
|||
var column = new double[MatrixQ.RowCount]; |
|||
for (var k = 0; k < MatrixQ.RowCount; k++) |
|||
{ |
|||
column[k] = inputCopy[k]; |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixQ.ColumnCount; i++) |
|||
{ |
|||
double s = 0; |
|||
for (var k = 0; k < MatrixQ.RowCount; k++) |
|||
{ |
|||
s += MatrixQ.At(k, i) * column[k]; |
|||
} |
|||
|
|||
inputCopy[i] = s; |
|||
} |
|||
|
|||
// Solve R*X = Y;
|
|||
for (var k = MatrixQ.ColumnCount - 1; k >= 0; k--) |
|||
{ |
|||
inputCopy[k] /= MatrixR.At(k, k); |
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
inputCopy[i] -= inputCopy[k] * MatrixR.At(i, k); |
|||
} |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixR.ColumnCount; i++) |
|||
{ |
|||
result[i] = inputCopy[i]; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,223 @@ |
|||
// <copyright file="SparseCholesky.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Factorization |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// <para>A class which encapsulates the functionality of a Cholesky factorization for soarse matrices.</para>
|
|||
/// <para>For a symmetric, positive definite matrix A, the Cholesky factorization
|
|||
/// is an lower triangular matrix L so that A = L*L'.</para>
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The computation of the Cholesky factorization is done at construction time. If the matrix is not symmetric
|
|||
/// or positive definite, the constructor will throw an exception.
|
|||
/// </remarks>
|
|||
public class SparseCholesky : Cholesky |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="SparseCholesky"/> class. This object will compute the
|
|||
/// Cholesky factorization when the constructor is called and cache it's factorization.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix to factor.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not a square matrix.</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not positive definite.</exception>
|
|||
public SparseCholesky(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare); |
|||
} |
|||
|
|||
// Create a new matrix for the Cholesky factor, then perform factorization (while overwriting).
|
|||
CholeskyFactor = matrix.Clone(); |
|||
for (var j = 0; j < CholeskyFactor.RowCount; j++) |
|||
{ |
|||
var d = 0.0; |
|||
for (var k = 0; k < j; k++) |
|||
{ |
|||
var s = 0.0; |
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
s += CholeskyFactor.At(k, i) * CholeskyFactor.At(j, i); |
|||
} |
|||
|
|||
s = (matrix.At(j, k) - s) / CholeskyFactor.At(k, k); |
|||
CholeskyFactor.At(j, k, s); |
|||
d += s * s; |
|||
} |
|||
|
|||
d = matrix.At(j, j) - d; |
|||
if (d <= 0.0) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixPositiveDefinite); |
|||
} |
|||
|
|||
CholeskyFactor.At(j, j, Math.Sqrt(d)); |
|||
for (var k = j + 1; k < CholeskyFactor.RowCount; k++) |
|||
{ |
|||
CholeskyFactor.At(j, k, 0.0); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>AX = B</b>, with A Cholesky factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side <see cref="Matrix"/>, <b>B</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>X</b>.</param>
|
|||
public override void Solve(Matrix input, Matrix result) |
|||
{ |
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// Check for proper dimensions.
|
|||
if (result.RowCount != input.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension); |
|||
} |
|||
|
|||
if (result.ColumnCount != input.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
if (input.RowCount != CholeskyFactor.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
input.CopyTo(result); |
|||
var order = CholeskyFactor.RowCount; |
|||
|
|||
for (var c = 0; c < result.ColumnCount; c++) |
|||
{ |
|||
// Solve L*Y = B;
|
|||
double sum; |
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
sum = result.At(i, c); |
|||
for (var k = i - 1; k >= 0; k--) |
|||
{ |
|||
sum -= CholeskyFactor.At(i, k) * result.At(k, c); |
|||
} |
|||
|
|||
result.At(i, c, sum / CholeskyFactor.At(i, i)); |
|||
} |
|||
|
|||
// Solve L'*X = Y;
|
|||
for (var i = order - 1; i >= 0; i--) |
|||
{ |
|||
sum = result.At(i, c); |
|||
for (var k = i + 1; k < order; k++) |
|||
{ |
|||
sum -= CholeskyFactor.At(k, i) * result.At(k, c); |
|||
} |
|||
|
|||
result.At(i, c, sum / CholeskyFactor.At(i, i)); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>Ax = b</b>, with A Cholesky factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side vector, <b>b</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>x</b>.</param>
|
|||
public override void Solve(Vector input, Vector result) |
|||
{ |
|||
// Check for proper arguments.
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// Check for proper dimensions.
|
|||
if (input.Count != result.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
if (input.Count != CholeskyFactor.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
input.CopyTo(result); |
|||
var order = CholeskyFactor.RowCount; |
|||
|
|||
// Solve L*Y = B;
|
|||
double sum; |
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
sum = result[i]; |
|||
for (var k = i - 1; k >= 0; k--) |
|||
{ |
|||
sum -= CholeskyFactor.At(i, k) * result[k]; |
|||
} |
|||
|
|||
result[i] = sum / CholeskyFactor.At(i, i); |
|||
} |
|||
|
|||
// Solve L'*X = Y;
|
|||
for (var i = order - 1; i >= 0; i--) |
|||
{ |
|||
sum = result[i]; |
|||
for (var k = i + 1; k < order; k++) |
|||
{ |
|||
sum -= CholeskyFactor.At(k, i) * result[k]; |
|||
} |
|||
|
|||
result[i] = sum / CholeskyFactor.At(i, i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,300 @@ |
|||
// <copyright file="SparseLU.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Factorization |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// <para>A class which encapsulates the functionality of an LU factorization.</para>
|
|||
/// <para>For a matrix A, the LU factorization is a pair of lower triangular matrix L and
|
|||
/// upper triangular matrix U so that A = L*U.</para>
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The computation of the LU factorization is done at construction time.
|
|||
/// </remarks>
|
|||
public class SparseLU : LU |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="SparseLU"/> class. This object will compute the
|
|||
/// LU factorization when the constructor is called and cache it's factorization.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix to factor.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not a square matrix.</exception>
|
|||
public SparseLU(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare); |
|||
} |
|||
|
|||
// Create an array for the pivot indices.
|
|||
var order = matrix.RowCount; |
|||
Factors = matrix.Clone(); |
|||
Pivots = new int[order]; |
|||
|
|||
// Initialize the pivot matrix to the identity permutation.
|
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
Pivots[i] = i; |
|||
} |
|||
|
|||
var vectorLUcolj = new double[order]; |
|||
for (var j = 0; j < order; j++) |
|||
{ |
|||
// Make a copy of the j-th column to localize references.
|
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
vectorLUcolj[i] = Factors.At(i, j); |
|||
} |
|||
|
|||
// Apply previous transformations.
|
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
var kmax = Math.Min(i, j); |
|||
var s = 0.0; |
|||
for (var k = 0; k < kmax; k++) |
|||
{ |
|||
s += Factors.At(i, k) * vectorLUcolj[k]; |
|||
} |
|||
|
|||
vectorLUcolj[i] -= s; |
|||
Factors.At(i, j, vectorLUcolj[i]); |
|||
} |
|||
|
|||
// Find pivot and exchange if necessary.
|
|||
var p = j; |
|||
for (var i = j + 1; i < order; i++) |
|||
{ |
|||
if (Math.Abs(vectorLUcolj[i]) > Math.Abs(vectorLUcolj[p])) |
|||
{ |
|||
p = i; |
|||
} |
|||
} |
|||
|
|||
if (p != j) |
|||
{ |
|||
for (var k = 0; k < order; k++) |
|||
{ |
|||
var temp = Factors.At(p, k); |
|||
Factors.At(p, k, Factors.At(j, k)); |
|||
Factors.At(j, k, temp); |
|||
} |
|||
|
|||
Pivots[j] = p; |
|||
} |
|||
|
|||
// Compute multipliers.
|
|||
if (j < order & Factors.At(j, j) != 0.0) |
|||
{ |
|||
for (var i = j + 1; i < order; i++) |
|||
{ |
|||
Factors.At(i, j, (Factors.At(i, j) / Factors.At(j, j))); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <c>AX = B</c>, with A LU factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side <see cref="Matrix"/>, <c>B</c>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <c>X</c>.</param>
|
|||
public override void Solve(Matrix input, Matrix result) |
|||
{ |
|||
// Check for proper arguments.
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// Check for proper dimensions.
|
|||
if (result.RowCount != input.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension); |
|||
} |
|||
|
|||
if (result.ColumnCount != input.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
if (input.RowCount != Factors.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
// Copy the contents of input to result.
|
|||
input.CopyTo(result); |
|||
for (var i = 0; i < Pivots.Length; i++) |
|||
{ |
|||
if (Pivots[i] == i) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
var p = Pivots[i]; |
|||
for (var j = 0; j < result.ColumnCount; j++) |
|||
{ |
|||
var temp = result.At(p, j); |
|||
result.At(p, j, result.At(i, j)); |
|||
result.At(i, j, temp); |
|||
} |
|||
} |
|||
|
|||
var order = Factors.RowCount; |
|||
|
|||
// Solve L*Y = P*B
|
|||
for (var k = 0; k < order; k++) |
|||
{ |
|||
for (var i = k + 1; i < order; i++) |
|||
{ |
|||
for (var j = 0; j < result.ColumnCount; j++) |
|||
{ |
|||
var temp = result.At(k, j) * Factors.At(i, k); |
|||
result.At(i, j, result.At(i, j) - temp); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Solve U*X = Y;
|
|||
for (var k = order - 1; k >= 0; k--) |
|||
{ |
|||
for (var j = 0; j < result.ColumnCount; j++) |
|||
{ |
|||
result.At(k, j, (result.At(k, j) / Factors.At(k, k))); |
|||
} |
|||
|
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
for (var j = 0; j < result.ColumnCount; j++) |
|||
{ |
|||
var temp = result.At(k, j) * Factors.At(i, k); |
|||
result.At(i, j, result.At(i, j) - temp); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <c>Ax = b</c>, with A LU factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side vector, <c>b</c>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <c>x</c>.</param>
|
|||
public override void Solve(Vector input, Vector result) |
|||
{ |
|||
// Check for proper arguments.
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// Check for proper dimensions.
|
|||
if (input.Count != result.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
if (input.Count != Factors.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
// Copy the contents of input to result.
|
|||
input.CopyTo(result); |
|||
for (var i = 0; i < Pivots.Length; i++) |
|||
{ |
|||
if (Pivots[i] == i) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
var p = Pivots[i]; |
|||
var temp = result[p]; |
|||
result[p] = result[i]; |
|||
result[i] = temp; |
|||
} |
|||
|
|||
var order = Factors.RowCount; |
|||
|
|||
// Solve L*Y = P*B
|
|||
for (var k = 0; k < order; k++) |
|||
{ |
|||
for (var i = k + 1; i < order; i++) |
|||
{ |
|||
result[i] -= result[k] * Factors.At(i, k); |
|||
} |
|||
} |
|||
|
|||
// Solve U*X = Y;
|
|||
for (var k = order - 1; k >= 0; k--) |
|||
{ |
|||
result[k] /= Factors.At(k, k); |
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
result[i] -= result[k] * Factors.At(i, k); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the inverse of this matrix. The inverse is calculated using LU decomposition.
|
|||
/// </summary>
|
|||
/// <returns>The inverse of this matrix.</returns>
|
|||
public override Matrix Inverse() |
|||
{ |
|||
var order = Factors.RowCount; |
|||
var inverse = Factors.CreateMatrix(order, order); |
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
inverse.At(i, i, 1.0); |
|||
} |
|||
|
|||
return Solve(inverse); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,332 @@ |
|||
// <copyright file="SparseQR.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Factorization |
|||
{ |
|||
using System; |
|||
using System.Linq; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// <para>A class which encapsulates the functionality of the QR decomposition.</para>
|
|||
/// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
|
|||
/// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
|
|||
/// (also called right triangular matrix).</para>
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The computation of the QR decomposition is done at construction time by Householder transformation.
|
|||
/// </remarks>
|
|||
public class SparseQR : QR |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="SparseQR"/> class. This object will compute the
|
|||
/// QR factorization when the constructor is called and cache it's factorization.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix to factor.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
|
|||
public SparseQR(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount < matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
MatrixR = matrix.Clone(); |
|||
MatrixQ = matrix.CreateMatrix(matrix.RowCount, matrix.RowCount); |
|||
|
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
MatrixQ.At(i, i, 1.0); |
|||
} |
|||
|
|||
var minmn = Math.Min(matrix.RowCount, matrix.ColumnCount); |
|||
var u = new double[minmn][]; |
|||
for (var i = 0; i < minmn; i++) |
|||
{ |
|||
u[i] = GenerateColumn(MatrixR, i, matrix.RowCount - 1, i); |
|||
ComputeQR(u[i], MatrixR, i, matrix.RowCount - 1, i + 1, matrix.ColumnCount - 1); |
|||
} |
|||
|
|||
for (var i = minmn - 1; i >= 0; i--) |
|||
{ |
|||
ComputeQR(u[i], MatrixQ, i, matrix.RowCount - 1, i, matrix.RowCount - 1); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Generate column from initial matrix to work array
|
|||
/// </summary>
|
|||
/// <param name="a">Initial matrix</param>
|
|||
/// <param name="rowStart">The firts row</param>
|
|||
/// <param name="rowEnd">The last row</param>
|
|||
/// <param name="column">Column index</param>
|
|||
/// <returns>Generated vector</returns>
|
|||
private static double[] GenerateColumn(Matrix a, int rowStart, int rowEnd, int column) |
|||
{ |
|||
var ru = rowEnd - rowStart + 1; |
|||
var u = new double[ru]; |
|||
|
|||
for (var i = rowStart; i <= rowEnd; i++) |
|||
{ |
|||
u[i - rowStart] = a.At(i, rowStart); |
|||
a.At(i, rowStart, 0.0); |
|||
} |
|||
|
|||
var norm = u.Sum(t => t * t); |
|||
norm = Math.Sqrt(norm); |
|||
|
|||
if (rowStart == rowEnd || norm == 0) |
|||
{ |
|||
a.At(rowStart, column, -u[0]); |
|||
u[0] = Math.Sqrt(2.0); |
|||
return u; |
|||
} |
|||
|
|||
var scale = 1.0 / norm; |
|||
if (u[0] < 0.0) |
|||
{ |
|||
scale *= -1.0; |
|||
} |
|||
|
|||
a.At(rowStart, column, -1.0 / scale); |
|||
|
|||
for (var i = 0; i < ru; i++) |
|||
{ |
|||
u[i] *= scale; |
|||
} |
|||
|
|||
u[0] += 1.0; |
|||
var s = Math.Sqrt(1.0 / u[0]); |
|||
|
|||
for (var i = 0; i < ru; i++) |
|||
{ |
|||
u[i] *= s; |
|||
} |
|||
|
|||
return u; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Perform calculation of Q or R
|
|||
/// </summary>
|
|||
/// <param name="u">Work array</param>
|
|||
/// <param name="a">Q or R matrices</param>
|
|||
/// <param name="rowStart">The first row</param>
|
|||
/// <param name="rowEnd">The last row</param>
|
|||
/// <param name="columnStart">The first column</param>
|
|||
/// <param name="columnEnd">The last column</param>
|
|||
private static void ComputeQR(double[] u, Matrix a, int rowStart, int rowEnd, int columnStart, int columnEnd) |
|||
{ |
|||
if (rowEnd < rowStart || columnEnd < columnStart) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var v = new double[columnEnd - columnStart + 1]; |
|||
for (var j = columnStart; j <= columnEnd; j++) |
|||
{ |
|||
v[j - columnStart] = 0.0; |
|||
} |
|||
|
|||
for (var i = rowStart; i <= rowEnd; i++) |
|||
{ |
|||
for (var j = columnStart; j <= columnEnd; j++) |
|||
{ |
|||
v[j - columnStart] = v[j - columnStart] + (u[i - rowStart] * a.At(i, j)); |
|||
} |
|||
} |
|||
|
|||
for (var i = rowStart; i <= rowEnd; i++) |
|||
{ |
|||
for (var j = columnStart; j <= columnEnd; j++) |
|||
{ |
|||
a.At(i, j, a.At(i, j) - (u[i - rowStart] * v[j - columnStart])); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>AX = B</b>, with A QR factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side <see cref="Matrix"/>, <b>B</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>X</b>.</param>
|
|||
public override void Solve(Matrix input, Matrix result) |
|||
{ |
|||
// Check for proper arguments.
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// The solution X should have the same number of columns as B
|
|||
if (input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
// The dimension compatibility conditions for X = A\B require the two matrices A and B to have the same number of rows
|
|||
if (MatrixR.RowCount != input.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension); |
|||
} |
|||
|
|||
// The solution X row dimension is equal to the column dimension of A
|
|||
if (MatrixR.ColumnCount != result.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
var inputCopy = input.Clone(); |
|||
|
|||
// Compute Y = transpose(Q)*B
|
|||
var bn = inputCopy.ColumnCount; |
|||
var column = new double[MatrixR.RowCount]; |
|||
for (var j = 0; j < bn; j++) |
|||
{ |
|||
for (var k = 0; k < MatrixR.RowCount; k++) |
|||
{ |
|||
column[k] = inputCopy.At(k, j); |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixR.RowCount; i++) |
|||
{ |
|||
double s = 0; |
|||
for (var k = 0; k < MatrixR.RowCount; k++) |
|||
{ |
|||
s += MatrixQ.At(k, i) * column[k]; |
|||
} |
|||
|
|||
inputCopy.At(i, j, s); |
|||
} |
|||
} |
|||
|
|||
// Solve R*X = Y;
|
|||
for (var k = MatrixR.ColumnCount - 1; k >= 0; k--) |
|||
{ |
|||
for (var j = 0; j < bn; j++) |
|||
{ |
|||
inputCopy.At(k, j, inputCopy.At(k, j) / MatrixR.At(k, k)); |
|||
} |
|||
|
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
for (var j = 0; j < bn; j++) |
|||
{ |
|||
inputCopy.At(i, j, inputCopy.At(i, j) - (inputCopy.At(k, j) * MatrixR.At(i, k))); |
|||
} |
|||
} |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixR.ColumnCount; i++) |
|||
{ |
|||
for (var j = 0; j < inputCopy.ColumnCount; j++) |
|||
{ |
|||
result.At(i, j, inputCopy.At(i, j)); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>Ax = b</b>, with A QR factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side vector, <b>b</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>x</b>.</param>
|
|||
public override void Solve(Vector input, Vector result) |
|||
{ |
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
// Ax=b where A is an m x n matrix
|
|||
// Check that b is a column vector with m entries
|
|||
if (MatrixR.RowCount != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Check that x is a column vector with n entries
|
|||
if (MatrixR.ColumnCount != result.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
var inputCopy = input.Clone(); |
|||
|
|||
// Compute Y = transpose(Q)*B
|
|||
var column = new double[MatrixR.RowCount]; |
|||
for (var k = 0; k < MatrixR.RowCount; k++) |
|||
{ |
|||
column[k] = inputCopy[k]; |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixR.RowCount; i++) |
|||
{ |
|||
double s = 0; |
|||
for (var k = 0; k < MatrixR.RowCount; k++) |
|||
{ |
|||
s += MatrixQ.At(k, i) * column[k]; |
|||
} |
|||
|
|||
inputCopy[i] = s; |
|||
} |
|||
|
|||
// Solve R*X = Y;
|
|||
for (var k = MatrixR.ColumnCount - 1; k >= 0; k--) |
|||
{ |
|||
inputCopy[k] /= MatrixR.At(k, k); |
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
inputCopy[i] -= inputCopy[k] * MatrixR.At(i, k); |
|||
} |
|||
} |
|||
|
|||
for (var i = 0; i < MatrixR.ColumnCount; i++) |
|||
{ |
|||
result[i] = inputCopy[i]; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,923 @@ |
|||
// <copyright file="SparseSvd.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Factorization |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="Matrix"/>.</para>
|
|||
/// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
|
|||
/// Then there exists a factorization of the form M = UΣVT where:
|
|||
/// - U is an m-by-m unitary matrix;
|
|||
/// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
|
|||
/// - VT denotes transpose of V, an n-by-n unitary matrix;
|
|||
/// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
|
|||
/// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
|
|||
/// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The computation of the singular value decomposition is done at construction time.
|
|||
/// </remarks>
|
|||
public class SparseSvd : Svd |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="SparseSvd"/> class. This object will compute the
|
|||
/// the singular value decomposition when the constructor is called and cache it's decomposition.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix to factor.</param>
|
|||
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <b>null</b>.</exception>
|
|||
/// <exception cref="ArgumentException">If SVD algorithm failed to converge with matrix <paramref name="matrix"/>.</exception>
|
|||
public SparseSvd(Matrix matrix, bool computeVectors) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
ComputeVectors = computeVectors; |
|||
var nm = Math.Min(matrix.RowCount + 1, matrix.ColumnCount); |
|||
var matrixCopy = matrix.Clone(); |
|||
|
|||
VectorS = matrixCopy.CreateVector(nm); |
|||
MatrixU = matrixCopy.CreateMatrix(matrixCopy.RowCount, matrixCopy.RowCount); |
|||
MatrixVT = matrixCopy.CreateMatrix(matrixCopy.ColumnCount, matrixCopy.ColumnCount); |
|||
|
|||
const int Maxiter = 1000; |
|||
var e = new double[matrixCopy.ColumnCount]; |
|||
var work = new double[matrixCopy.RowCount]; |
|||
|
|||
int i, j; |
|||
int l, lp1; |
|||
var cs = 0.0; |
|||
var sn = 0.0; |
|||
double t; |
|||
|
|||
var ncu = matrixCopy.RowCount; |
|||
|
|||
// Reduce matrixCopy to bidiagonal form, storing the diagonal elements
|
|||
// In s and the super-diagonal elements in e.
|
|||
var nct = Math.Min(matrixCopy.RowCount - 1, matrixCopy.ColumnCount); |
|||
var nrt = Math.Max(0, Math.Min(matrixCopy.ColumnCount - 2, matrixCopy.RowCount)); |
|||
var lu = Math.Max(nct, nrt); |
|||
for (l = 0; l < lu; l++) |
|||
{ |
|||
lp1 = l + 1; |
|||
if (l < nct) |
|||
{ |
|||
// Compute the transformation for the l-th column and place the l-th diagonal in VectorS[l].
|
|||
var xnorm = Dnrm2Column(matrixCopy, matrixCopy.RowCount, l, l); |
|||
VectorS[l] = xnorm; |
|||
if (VectorS[l] != 0.0) |
|||
{ |
|||
if (matrixCopy.At(l, l) != 0.0) |
|||
{ |
|||
VectorS[l] = Dsign(VectorS[l], matrixCopy.At(l, l)); |
|||
} |
|||
|
|||
DscalColumn(matrixCopy, matrixCopy.RowCount, l, l, 1.0 / VectorS[l]); |
|||
matrixCopy.At(l, l, (1.0 + matrixCopy.At(l, l))); |
|||
} |
|||
|
|||
VectorS[l] = -VectorS[l]; |
|||
} |
|||
|
|||
for (j = lp1; j < matrixCopy.ColumnCount; j++) |
|||
{ |
|||
if (l < nct) |
|||
{ |
|||
if (VectorS[l] != 0.0) |
|||
{ |
|||
// Apply the transformation.
|
|||
t = -Ddot(matrixCopy, matrixCopy.RowCount, l, j, l) / matrixCopy.At(l, l); |
|||
for (var ii = l; ii < matrixCopy.RowCount; ii++) |
|||
{ |
|||
matrixCopy.At(ii, j, matrixCopy.At(ii, j) + (t * matrixCopy.At(ii, l))); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Place the l-th row of matrixCopy into e for the
|
|||
// Subsequent calculation of the row transformation.
|
|||
e[j] = matrixCopy.At(l, j); |
|||
} |
|||
|
|||
if (ComputeVectors && l < nct) |
|||
{ |
|||
// Place the transformation in u for subsequent back multiplication.
|
|||
for (i = l; i < matrixCopy.RowCount; i++) |
|||
{ |
|||
MatrixU.At(i, l, matrixCopy.At(i, l)); |
|||
} |
|||
} |
|||
|
|||
if (l >= nrt) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
// Compute the l-th row transformation and place the l-th super-diagonal in e(l).
|
|||
var enorm = Dnrm2Vector(e, lp1); |
|||
e[l] = enorm; |
|||
if (e[l] != 0.0) |
|||
{ |
|||
if (e[lp1] != 0.0) |
|||
{ |
|||
e[l] = Dsign(e[l], e[lp1]); |
|||
} |
|||
|
|||
DscalVector(e, lp1, 1.0 / e[l]); |
|||
e[lp1] = 1.0 + e[lp1]; |
|||
} |
|||
|
|||
e[l] = -e[l]; |
|||
if (lp1 < matrixCopy.RowCount && e[l] != 0.0) |
|||
{ |
|||
// Apply the transformation.
|
|||
for (i = lp1; i < matrixCopy.RowCount; i++) |
|||
{ |
|||
work[i] = 0.0; |
|||
} |
|||
|
|||
for (j = lp1; j < matrixCopy.ColumnCount; j++) |
|||
{ |
|||
for (var ii = lp1; ii < matrixCopy.RowCount; ii++) |
|||
{ |
|||
work[ii] += e[j] * matrixCopy.At(ii, j); |
|||
} |
|||
} |
|||
|
|||
for (j = lp1; j < matrixCopy.ColumnCount; j++) |
|||
{ |
|||
var ww = -e[j] / e[lp1]; |
|||
for (var ii = lp1; ii < matrixCopy.RowCount; ii++) |
|||
{ |
|||
matrixCopy.At(ii, j, matrixCopy.At(ii, j) + (ww * work[ii])); |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (ComputeVectors) |
|||
{ |
|||
// Place the transformation in v for subsequent back multiplication.
|
|||
for (i = lp1; i < matrixCopy.ColumnCount; i++) |
|||
{ |
|||
MatrixVT.At(i, l, e[i]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Set up the final bidiagonal matrixCopy or order m.
|
|||
var m = Math.Min(matrixCopy.ColumnCount, matrixCopy.RowCount + 1); |
|||
var nctp1 = nct + 1; |
|||
var nrtp1 = nrt + 1; |
|||
if (nct < matrixCopy.ColumnCount) |
|||
{ |
|||
VectorS[nctp1 - 1] = matrixCopy.At((nctp1 - 1), (nctp1 - 1)); |
|||
} |
|||
|
|||
if (matrixCopy.RowCount < m) |
|||
{ |
|||
VectorS[m - 1] = 0.0; |
|||
} |
|||
|
|||
if (nrtp1 < m) |
|||
{ |
|||
e[nrtp1 - 1] = matrixCopy.At((nrtp1 - 1), (m - 1)); |
|||
} |
|||
|
|||
e[m - 1] = 0.0; |
|||
|
|||
// If required, generate u.
|
|||
if (ComputeVectors) |
|||
{ |
|||
for (j = nctp1 - 1; j < ncu; j++) |
|||
{ |
|||
for (i = 0; i < matrixCopy.RowCount; i++) |
|||
{ |
|||
MatrixU.At(i, j, 0.0); |
|||
} |
|||
|
|||
MatrixU.At(j, j, 1.0); |
|||
} |
|||
|
|||
for (l = nct - 1; l >= 0; l--) |
|||
{ |
|||
if (VectorS[l] != 0.0) |
|||
{ |
|||
for (j = l + 1; j < ncu; j++) |
|||
{ |
|||
t = -Ddot(MatrixU, matrixCopy.RowCount, l, j, l) / MatrixU.At(l, l); |
|||
for (var ii = l; ii < matrixCopy.RowCount; ii++) |
|||
{ |
|||
MatrixU.At(ii, j, MatrixU.At(ii, j) + (t * MatrixU.At(ii, l))); |
|||
} |
|||
} |
|||
|
|||
DscalColumn(MatrixU, matrixCopy.RowCount, l, l, -1.0); |
|||
MatrixU.At(l, l, 1.0 + MatrixU.At(l, l)); |
|||
for (i = 0; i < l; i++) |
|||
{ |
|||
MatrixU.At(i, l, 0.0); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
for (i = 0; i < matrixCopy.RowCount; i++) |
|||
{ |
|||
MatrixU.At(i, l, 0.0); |
|||
} |
|||
|
|||
MatrixU.At(l, l, 1.0); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// If it is required, generate v.
|
|||
if (ComputeVectors) |
|||
{ |
|||
for (l = matrixCopy.ColumnCount - 1; l >= 0; l--) |
|||
{ |
|||
lp1 = l + 1; |
|||
if (l < nrt) |
|||
{ |
|||
if (e[l] != 0.0) |
|||
{ |
|||
for (j = lp1; j < matrixCopy.ColumnCount; j++) |
|||
{ |
|||
t = -Ddot(MatrixVT, matrixCopy.ColumnCount, l, j, lp1) / MatrixVT.At(lp1, l); |
|||
for (var ii = l; ii < matrixCopy.ColumnCount; ii++) |
|||
{ |
|||
MatrixVT.At(ii, j, MatrixVT.At(ii, j) + (t * MatrixVT.At(ii, l))); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
for (i = 0; i < matrixCopy.ColumnCount; i++) |
|||
{ |
|||
MatrixVT.At(i, l, 0.0); |
|||
} |
|||
|
|||
MatrixVT.At(l, l, 1.0); |
|||
} |
|||
} |
|||
|
|||
// Transform s and e so that they are double .
|
|||
for (i = 0; i < m; i++) |
|||
{ |
|||
double r; |
|||
if (VectorS[i] != 0.0) |
|||
{ |
|||
t = VectorS[i]; |
|||
r = VectorS[i] / t; |
|||
VectorS[i] = t; |
|||
if (i < m - 1) |
|||
{ |
|||
e[i] = e[i] / r; |
|||
} |
|||
|
|||
if (ComputeVectors) |
|||
{ |
|||
DscalColumn(MatrixU, matrixCopy.RowCount, i, 0, r); |
|||
} |
|||
} |
|||
|
|||
// Exit
|
|||
if (i == m - 1) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (e[i] != 0.0) |
|||
{ |
|||
t = e[i]; |
|||
r = t / e[i]; |
|||
e[i] = t; |
|||
VectorS[i + 1] = VectorS[i + 1] * r; |
|||
if (ComputeVectors) |
|||
{ |
|||
DscalColumn(MatrixVT, matrixCopy.ColumnCount, i + 1, 0, r); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Main iteration loop for the singular values.
|
|||
var mn = m; |
|||
var iter = 0; |
|||
|
|||
while (m > 0) |
|||
{ |
|||
// Quit if all the singular values have been found. If too many iterations have been performed,
|
|||
// throw exception that Convergence Failed
|
|||
if (iter >= Maxiter) |
|||
{ |
|||
throw new ArgumentException(Resources.ConvergenceFailed); |
|||
} |
|||
|
|||
// This section of the program inspects for negligible elements in the s and e arrays. On
|
|||
// completion the variables kase and l are set as follows.
|
|||
// Kase = 1 if VectorS[m] and e[l-1] are negligible and l < m
|
|||
// Kase = 2 if VectorS[l] is negligible and l < m
|
|||
// Kase = 3 if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
|
|||
// Лase = 4 if e[m-1] is negligible (convergence).
|
|||
double ztest; |
|||
double test; |
|||
for (l = m - 2; l >= 0; l--) |
|||
{ |
|||
test = Math.Abs(VectorS[l]) + Math.Abs(VectorS[l + 1]); |
|||
ztest = test + Math.Abs(e[l]); |
|||
if (ztest.AlmostEqualInDecimalPlaces(test, 15)) |
|||
{ |
|||
e[l] = 0.0; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
int kase; |
|||
if (l == m - 2) |
|||
{ |
|||
kase = 4; |
|||
} |
|||
else |
|||
{ |
|||
int ls; |
|||
for (ls = m - 1; ls > l; ls--) |
|||
{ |
|||
test = 0.0; |
|||
if (ls != m - 1) |
|||
{ |
|||
test = test + Math.Abs(e[ls]); |
|||
} |
|||
|
|||
if (ls != l + 1) |
|||
{ |
|||
test = test + Math.Abs(e[ls - 1]); |
|||
} |
|||
|
|||
ztest = test + Math.Abs(VectorS[ls]); |
|||
if (ztest.AlmostEqualInDecimalPlaces(test, 15)) |
|||
{ |
|||
VectorS[ls] = 0.0; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (ls == l) |
|||
{ |
|||
kase = 3; |
|||
} |
|||
else if (ls == m - 1) |
|||
{ |
|||
kase = 1; |
|||
} |
|||
else |
|||
{ |
|||
kase = 2; |
|||
l = ls; |
|||
} |
|||
} |
|||
|
|||
l = l + 1; |
|||
|
|||
// Perform the task indicated by kase.
|
|||
int k; |
|||
double f; |
|||
switch (kase) |
|||
{ |
|||
// Deflate negligible VectorS[m].
|
|||
case 1: |
|||
f = e[m - 2]; |
|||
e[m - 2] = 0.0; |
|||
double t1; |
|||
for (var kk = l; kk < m - 1; kk++) |
|||
{ |
|||
k = m - 2 - kk + l; |
|||
t1 = VectorS[k]; |
|||
Drotg(ref t1, ref f, ref cs, ref sn); |
|||
VectorS[k] = t1; |
|||
if (k != l) |
|||
{ |
|||
f = -sn * e[k - 1]; |
|||
e[k - 1] = cs * e[k - 1]; |
|||
} |
|||
|
|||
if (ComputeVectors) |
|||
{ |
|||
Drot(MatrixVT, matrixCopy.ColumnCount, k, m - 1, cs, sn); |
|||
} |
|||
} |
|||
|
|||
break; |
|||
|
|||
// Split at negligible VectorS[l].
|
|||
case 2: |
|||
f = e[l - 1]; |
|||
e[l - 1] = 0.0; |
|||
for (k = l; k < m; k++) |
|||
{ |
|||
t1 = VectorS[k]; |
|||
Drotg(ref t1, ref f, ref cs, ref sn); |
|||
VectorS[k] = t1; |
|||
f = -sn * e[k]; |
|||
e[k] = cs * e[k]; |
|||
if (ComputeVectors) |
|||
{ |
|||
Drot(MatrixU, matrixCopy.RowCount, k, l - 1, cs, sn); |
|||
} |
|||
} |
|||
|
|||
break; |
|||
|
|||
// Perform one qr step.
|
|||
case 3: |
|||
// Calculate the shift.
|
|||
var scale = 0.0; |
|||
scale = Math.Max(scale, Math.Abs(VectorS[m - 1])); |
|||
scale = Math.Max(scale, Math.Abs(VectorS[m - 2])); |
|||
scale = Math.Max(scale, Math.Abs(e[m - 2])); |
|||
scale = Math.Max(scale, Math.Abs(VectorS[l])); |
|||
scale = Math.Max(scale, Math.Abs(e[l])); |
|||
var sm = VectorS[m - 1] / scale; |
|||
var smm1 = VectorS[m - 2] / scale; |
|||
var emm1 = e[m - 2] / scale; |
|||
var sl = VectorS[l] / scale; |
|||
var el = e[l] / scale; |
|||
var b = (((smm1 + sm) * (smm1 - sm)) + (emm1 * emm1)) / 2.0; |
|||
var c = (sm * emm1) * (sm * emm1); |
|||
var shift = 0.0; |
|||
if (b != 0.0 || c != 0.0) |
|||
{ |
|||
shift = Math.Sqrt((b * b) + c); |
|||
if (b < 0.0) |
|||
{ |
|||
shift = -shift; |
|||
} |
|||
|
|||
shift = c / (b + shift); |
|||
} |
|||
|
|||
f = ((sl + sm) * (sl - sm)) + shift; |
|||
var g = sl * el; |
|||
|
|||
// Chase zeros.
|
|||
for (k = l; k < m - 1; k++) |
|||
{ |
|||
Drotg(ref f, ref g, ref cs, ref sn); |
|||
if (k != l) |
|||
{ |
|||
e[k - 1] = f; |
|||
} |
|||
|
|||
f = (cs * VectorS[k]) + (sn * e[k]); |
|||
e[k] = (cs * e[k]) - (sn * VectorS[k]); |
|||
g = sn * VectorS[k + 1]; |
|||
VectorS[k + 1] = cs * VectorS[k + 1]; |
|||
if (ComputeVectors) |
|||
{ |
|||
Drot(MatrixVT, matrixCopy.ColumnCount, k, k + 1, cs, sn); |
|||
} |
|||
|
|||
Drotg(ref f, ref g, ref cs, ref sn); |
|||
VectorS[k] = f; |
|||
f = (cs * e[k]) + (sn * VectorS[k + 1]); |
|||
VectorS[k + 1] = (-sn * e[k]) + (cs * VectorS[k + 1]); |
|||
g = sn * e[k + 1]; |
|||
e[k + 1] = cs * e[k + 1]; |
|||
if (ComputeVectors && k < matrixCopy.RowCount) |
|||
{ |
|||
Drot(MatrixU, matrixCopy.RowCount, k, k + 1, cs, sn); |
|||
} |
|||
} |
|||
|
|||
e[m - 2] = f; |
|||
iter = iter + 1; |
|||
break; |
|||
|
|||
// Convergence.
|
|||
case 4: |
|||
// Make the singular value positive
|
|||
if (VectorS[l] < 0.0) |
|||
{ |
|||
VectorS[l] = -VectorS[l]; |
|||
if (ComputeVectors) |
|||
{ |
|||
DscalColumn(MatrixVT, matrixCopy.ColumnCount, l, 0, -1.0); |
|||
} |
|||
} |
|||
|
|||
// Order the singular value.
|
|||
while (l != mn - 1) |
|||
{ |
|||
if (VectorS[l] >= VectorS[l + 1]) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
t = VectorS[l]; |
|||
VectorS[l] = VectorS[l + 1]; |
|||
VectorS[l + 1] = t; |
|||
if (ComputeVectors && l < matrixCopy.ColumnCount) |
|||
{ |
|||
Dswap(MatrixVT, matrixCopy.ColumnCount, l, l + 1); |
|||
} |
|||
|
|||
if (ComputeVectors && l < matrixCopy.RowCount) |
|||
{ |
|||
Dswap(MatrixU, matrixCopy.RowCount, l, l + 1); |
|||
} |
|||
|
|||
l = l + 1; |
|||
} |
|||
|
|||
iter = 0; |
|||
m = m - 1; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (ComputeVectors) |
|||
{ |
|||
MatrixVT = MatrixVT.Transpose(); |
|||
} |
|||
|
|||
// Adjust the size of s if rows < columns. We are using ported copy of linpack's svd code and it uses
|
|||
// a singular vector of length mRows+1 when mRows < mColumns. The last element is not used and needs to be removed.
|
|||
// we should port lapack's svd routine to remove this problem.
|
|||
if (matrixCopy.RowCount < matrixCopy.ColumnCount) |
|||
{ |
|||
nm--; |
|||
var tmp = matrixCopy.CreateVector(nm); |
|||
for (i = 0; i < nm; i++) |
|||
{ |
|||
tmp[i] = VectorS[i]; |
|||
} |
|||
|
|||
VectorS = tmp; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates absolute value of <paramref name="z1"/> multiplied on signum function of <paramref name="z2"/>
|
|||
/// </summary>
|
|||
/// <param name="z1">Double value z1</param>
|
|||
/// <param name="z2">Double value z2</param>
|
|||
/// <returns>Result multiplication of signum function and absolute value</returns>
|
|||
private static double Dsign(double z1, double z2) |
|||
{ |
|||
return Math.Abs(z1) * (z2 / Math.Abs(z2)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Swap column <paramref name="columnA"/> and <paramref name="columnB"/>
|
|||
/// </summary>
|
|||
/// <param name="a">Source matrix</param>
|
|||
/// <param name="rowCount">The number of rows in <paramref name="a"/></param>
|
|||
/// <param name="columnA">Column A index to swap</param>
|
|||
/// <param name="columnB">Column B index to swap</param>
|
|||
private static void Dswap(Matrix a, int rowCount, int columnA, int columnB) |
|||
{ |
|||
for (var i = 0; i < rowCount; i++) |
|||
{ |
|||
var z = a.At(i, columnA); |
|||
a.At(i, columnA, a.At(i, columnB)); |
|||
a.At(i, columnB, z); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Scale column <paramref name="column"/> by <paramref name="z"/> starting from row <paramref name="rowStart"/>
|
|||
/// </summary>
|
|||
/// <param name="a">Source matrix</param>
|
|||
/// <param name="rowCount">The number of rows in <paramref name="a"/> </param>
|
|||
/// <param name="column">Column to scale</param>
|
|||
/// <param name="rowStart">Row to scale from</param>
|
|||
/// <param name="z">Scale value</param>
|
|||
private static void DscalColumn(Matrix a, int rowCount, int column, int rowStart, double z) |
|||
{ |
|||
for (var i = rowStart; i < rowCount; i++) |
|||
{ |
|||
a.At(i, column, a.At(i, column) * z); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Scale vector <paramref name="a"/> by <paramref name="z"/> starting from index <paramref name="start"/>
|
|||
/// </summary>
|
|||
/// <param name="a">Source vector</param>
|
|||
/// <param name="start">Row to scale from</param>
|
|||
/// <param name="z">Scale value</param>
|
|||
private static void DscalVector(double[] a, int start, double z) |
|||
{ |
|||
for (var i = start; i < a.Length; i++) |
|||
{ |
|||
a[i] = a[i] * z; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
|
|||
/// associated with the Givens rotation that zeros the y-coordinate of the point.
|
|||
/// </summary>
|
|||
/// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>
|
|||
/// <param name="db">Provides the y-coordinate of the point p. On exit contains the parameter z associated with the Givens rotation</param>
|
|||
/// <param name="c">Contains the parameter c associated with the Givens rotation</param>
|
|||
/// <param name="s">Contains the parameter s associated with the Givens rotation</param>
|
|||
/// <remarks>This is equivalent to the DROTG LAPACK routine.</remarks>
|
|||
private static void Drotg(ref double da, ref double db, ref double c, ref double s) |
|||
{ |
|||
double r, z; |
|||
|
|||
var roe = db; |
|||
var absda = Math.Abs(da); |
|||
var absdb = Math.Abs(db); |
|||
if (absda > absdb) |
|||
{ |
|||
roe = da; |
|||
} |
|||
|
|||
var scale = absda + absdb; |
|||
if (scale == 0.0) |
|||
{ |
|||
c = 1.0; |
|||
s = 0.0; |
|||
r = 0.0; |
|||
z = 0.0; |
|||
} |
|||
else |
|||
{ |
|||
var sda = da / scale; |
|||
var sdb = db / scale; |
|||
r = scale * Math.Sqrt((sda * sda) + (sdb * sdb)); |
|||
if (roe < 0.0) |
|||
{ |
|||
r = -r; |
|||
} |
|||
|
|||
c = da / r; |
|||
s = db / r; |
|||
z = 1.0; |
|||
if (absda > absdb) |
|||
{ |
|||
z = s; |
|||
} |
|||
|
|||
if (absdb >= absda && c != 0.0) |
|||
{ |
|||
z = 1.0 / c; |
|||
} |
|||
} |
|||
|
|||
da = r; |
|||
db = z; |
|||
} |
|||
|
|||
/// <summary>dded
|
|||
/// Calculate Norm 2 of the column <paramref name="column"/> in matrix <paramref name="a"/> starting from row <paramref name="rowStart"/>
|
|||
/// </summary>
|
|||
/// <param name="a">Source matrix</param>
|
|||
/// <param name="rowCount">The number of rows in <paramref name="a"/></param>
|
|||
/// <param name="column">Column index</param>
|
|||
/// <param name="rowStart">Start row index</param>
|
|||
/// <returns>Norm2 (Euclidean norm) of trhe column</returns>
|
|||
private static double Dnrm2Column(Matrix a, int rowCount, int column, int rowStart) |
|||
{ |
|||
double s = 0; |
|||
for (var i = rowStart; i < rowCount; i++) |
|||
{ |
|||
s += a.At(i, column) * a.At(i, column); |
|||
} |
|||
|
|||
return Math.Sqrt(s); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculate Norm 2 of the vector <paramref name="a"/> starting from index <paramref name="rowStart"/>
|
|||
/// </summary>
|
|||
/// <param name="a">Source vector</param>
|
|||
/// <param name="rowStart">Start index</param>
|
|||
/// <returns>Norm2 (Euclidean norm) of the vector</returns>
|
|||
private static double Dnrm2Vector(double[] a, int rowStart) |
|||
{ |
|||
double s = 0; |
|||
for (var i = rowStart; i < a.Length; i++) |
|||
{ |
|||
s += a[i] * a[i]; |
|||
} |
|||
|
|||
return Math.Sqrt(s); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculate dot product of <paramref name="columnA"/> and <paramref name="columnB"/>
|
|||
/// </summary>
|
|||
/// <param name="a">Source matrix</param>
|
|||
/// <param name="rowCount">The number of rows in <paramref name="a"/></param>
|
|||
/// <param name="columnA">Index of column A</param>
|
|||
/// <param name="columnB">Index of column B</param>
|
|||
/// <param name="rowStart">Starting row index</param>
|
|||
/// <returns>Dot product value</returns>
|
|||
private static double Ddot(Matrix a, int rowCount, int columnA, int columnB, int rowStart) |
|||
{ |
|||
var z = 0.0; |
|||
for (var i = rowStart; i < rowCount; i++) |
|||
{ |
|||
z += a.At(i, columnB) * a.At(i, columnA); |
|||
} |
|||
|
|||
return z; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>,
|
|||
/// each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i)
|
|||
/// </summary>
|
|||
/// <param name="a">Source matrix</param>
|
|||
/// <param name="rowCount">The number of rows in <paramref name="a"/></param>
|
|||
/// <param name="columnA">Index of column A</param>
|
|||
/// <param name="columnB">Index of column B</param>
|
|||
/// <param name="c">Scalar "c" value</param>
|
|||
/// <param name="s">Scalar "s" value</param>
|
|||
private static void Drot(Matrix a, int rowCount, int columnA, int columnB, double c, double s) |
|||
{ |
|||
for (var i = 0; i < rowCount; i++) |
|||
{ |
|||
var z = (c * a.At(i, columnA)) + (s * a.At(i, columnB)); |
|||
var tmp = (c * a.At(i, columnB)) - (s * a.At(i, columnA)); |
|||
a.At(i, columnB, tmp); |
|||
a.At(i, columnA, z); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>AX = B</b>, with A SVD factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side <see cref="Matrix"/>, <b>B</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>X</b>.</param>
|
|||
public override void Solve(Matrix input, Matrix result) |
|||
{ |
|||
// Check for proper arguments.
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (!ComputeVectors) |
|||
{ |
|||
throw new InvalidOperationException(Resources.SingularVectorsNotComputed); |
|||
} |
|||
|
|||
// The solution X should have the same number of columns as B
|
|||
if (input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
// The dimension compatibility conditions for X = A\B require the two matrices A and B to have the same number of rows
|
|||
if (MatrixU.RowCount != input.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension); |
|||
} |
|||
|
|||
// The solution X row dimension is equal to the column dimension of A
|
|||
if (MatrixVT.ColumnCount != result.RowCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension); |
|||
} |
|||
|
|||
var mn = Math.Min(MatrixU.RowCount, MatrixVT.ColumnCount); |
|||
var bn = input.ColumnCount; |
|||
|
|||
var tmp = new double[MatrixVT.ColumnCount]; |
|||
|
|||
for (var k = 0; k < bn; k++) |
|||
{ |
|||
for (var j = 0; j < MatrixVT.ColumnCount; j++) |
|||
{ |
|||
double value = 0; |
|||
if (j < mn) |
|||
{ |
|||
for (var i = 0; i < MatrixU.RowCount; i++) |
|||
{ |
|||
value += MatrixU.At(i, j) * input.At(i, k); |
|||
} |
|||
|
|||
value /= VectorS[j]; |
|||
} |
|||
|
|||
tmp[j] = value; |
|||
} |
|||
|
|||
for (var j = 0; j < MatrixVT.ColumnCount; j++) |
|||
{ |
|||
double value = 0; |
|||
for (var i = 0; i < MatrixVT.ColumnCount; i++) |
|||
{ |
|||
value += MatrixVT.At(i, j) * tmp[i]; |
|||
} |
|||
|
|||
result[j, k] = value; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves a system of linear equations, <b>Ax = b</b>, with A SVD factorized.
|
|||
/// </summary>
|
|||
/// <param name="input">The right hand side vector, <b>b</b>.</param>
|
|||
/// <param name="result">The left hand side <see cref="Matrix"/>, <b>x</b>.</param>
|
|||
public override void Solve(Vector input, Vector result) |
|||
{ |
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (!ComputeVectors) |
|||
{ |
|||
throw new InvalidOperationException(Resources.SingularVectorsNotComputed); |
|||
} |
|||
|
|||
// Ax=b where A is an m x n matrix
|
|||
// Check that b is a column vector with m entries
|
|||
if (MatrixU.RowCount != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Check that x is a column vector with n entries
|
|||
if (MatrixVT.ColumnCount != result.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
var mn = Math.Min(MatrixU.RowCount, MatrixVT.ColumnCount); |
|||
var tmp = new double[MatrixVT.ColumnCount]; |
|||
double value; |
|||
for (var j = 0; j < MatrixVT.ColumnCount; j++) |
|||
{ |
|||
value = 0; |
|||
if (j < mn) |
|||
{ |
|||
for (var i = 0; i < MatrixU.RowCount; i++) |
|||
{ |
|||
value += MatrixU.At(i, j) * input[i]; |
|||
} |
|||
|
|||
value /= VectorS[j]; |
|||
} |
|||
|
|||
tmp[j] = value; |
|||
} |
|||
|
|||
for (var j = 0; j < MatrixVT.ColumnCount; j++) |
|||
{ |
|||
value = 0; |
|||
for (int i = 0; i < MatrixVT.ColumnCount; i++) |
|||
{ |
|||
value += MatrixVT.At(i, j) * tmp[i]; |
|||
} |
|||
|
|||
result[j] = value; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,96 @@ |
|||
// <copyright file="IIterativeSolver.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers |
|||
{ |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// Defines the interface for <see cref="IIterativeSolver" /> classes that solve the matrix equation Ax = b in
|
|||
/// an iterative manner.
|
|||
/// </summary>
|
|||
public interface IIterativeSolver |
|||
{ |
|||
/// <summary>
|
|||
/// Stops the solve process.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that it may take an indetermined amount of time for the solver to actually stop the process.
|
|||
/// </remarks>
|
|||
void StopSolve(); |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IIterator" /> that will be used to track the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator.</param>
|
|||
void SetIterator(IIterator iterator); |
|||
|
|||
/// <summary>
|
|||
/// Gets the status of the iteration once the calculation is finished.
|
|||
/// </summary>
|
|||
ICalculationStatus IterationResult { get; } |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="vector">The solution vector, <c>b</c>.</param>
|
|||
/// <returns>The result vector, <c>x</c>.</returns>
|
|||
Vector Solve(Matrix matrix, Vector vector); |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution vector, <c>b</c></param>
|
|||
/// <param name="result">The result vector, <c>x</c></param>
|
|||
void Solve(Matrix matrix, Vector input, Vector result); |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <returns>The result matrix, <c>X</c>.</returns>
|
|||
Matrix Solve(Matrix matrix, Matrix input); |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <param name="result">The result matrix, <c>X</c></param>
|
|||
void Solve(Matrix matrix, Matrix input, Matrix result); |
|||
} |
|||
} |
|||
@ -0,0 +1,71 @@ |
|||
// <copyright file="IIterativeSolverSetup.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// Defines the interface for objects that can create an iterative solver with
|
|||
/// specific settings. This interface is used to pass iterative solver creation
|
|||
/// setup information around.
|
|||
/// </summary>
|
|||
public interface IIterativeSolverSetup |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the type of the solver that will be created by this setup object.
|
|||
/// </summary>
|
|||
Type SolverType { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets type of preconditioner, if any, that will be created by this setup object.
|
|||
/// </summary>
|
|||
Type PreconditionerType { get; } |
|||
|
|||
/// <summary>
|
|||
/// Creates a fully functional iterative solver with the default settings
|
|||
/// given by this setup.
|
|||
/// </summary>
|
|||
/// <returns>A new <see cref="IIterativeSolver"/>.</returns>
|
|||
IIterativeSolver CreateNew(); |
|||
|
|||
/// <summary>
|
|||
/// Gets the relative speed of the solver.
|
|||
/// </summary>
|
|||
/// <value>Returns a value between 0 and 1, inclusive.</value>
|
|||
double SolutionSpeed { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the relative reliability of the solver.
|
|||
/// </summary>
|
|||
/// <value>Returns a value between 0 and 1 inclusive.</value>
|
|||
double Reliability { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,108 @@ |
|||
// <copyright file="IIterator.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers |
|||
{ |
|||
using System; |
|||
using Status; |
|||
using StopCriterium; |
|||
|
|||
/// <summary>
|
|||
/// Defines the base interface for iterators that help control an iterative calculation.
|
|||
/// </summary>
|
|||
public interface IIterator |
|||
#if !SILVERLIGHT
|
|||
: ICloneable |
|||
#endif
|
|||
{ |
|||
/// <summary>
|
|||
/// Adds an <see cref="IIterationStopCriterium"/> to the internal collection of stop-criteria. Only a
|
|||
/// single stop criterium of each type can be stored.
|
|||
/// </summary>
|
|||
/// <param name="stopCriterium">The stop criterium to add.</param>
|
|||
/// <exception cref="ArgumentNullException">Thrown if <paramref name="stopCriterium"/> is <see langword="null" />.</exception>
|
|||
/// <exception cref="ArgumentException">Thrown if <paramref name="stopCriterium"/> is of the same type as an already stored criterium.</exception>
|
|||
void Add(IIterationStopCriterium stopCriterium); |
|||
|
|||
/// <summary>
|
|||
/// Removes the <see cref="IIterationStopCriterium"/> from the internal collection.
|
|||
/// </summary>
|
|||
/// <param name="stopCriterium">The stop criterium that must be removed.</param>
|
|||
void Remove(IIterationStopCriterium stopCriterium); |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the specific stop criterium is stored by the <see cref="IIterator"/>.
|
|||
/// </summary>
|
|||
/// <param name="stopCriterium">The stop criterium.</param>
|
|||
/// <returns><c>true</c> if the <see cref="IIterator"/> contains the stop criterium; otherwise <c>false</c>.</returns>
|
|||
bool Contains(IIterationStopCriterium stopCriterium); |
|||
|
|||
/// <summary>
|
|||
/// Indicates to the iterator that the iterative process has been cancelled.
|
|||
/// </summary>
|
|||
/// <remarks>Does not reset the stop-criteria.</remarks>
|
|||
void IterationCancelled(); |
|||
|
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <see cref="IIterator"/>. Status is set to <c>Status</c> field of current object.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual iterators may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector); |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
/// <remarks><see langword="null" /> is not a legal value. Status should be set in <see cref="DetermineStatus"/> implementation.</remarks>.
|
|||
ICalculationStatus Status { get; } |
|||
|
|||
/// <summary>
|
|||
/// Resets the <c>IIterator</c> to the pre-calculation state.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note to implementers: Invoking this method should not clear the user defined
|
|||
/// property values, only the state that is used to track the progress of the
|
|||
/// calculation.
|
|||
/// </remarks>
|
|||
void ResetToPrecalculationState(); |
|||
|
|||
#if SILVERLIGHT
|
|||
IIterator Clone(); |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,524 @@ |
|||
// <copyright file="BiCgStab.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative |
|||
{ |
|||
using System; |
|||
using Preconditioners; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// A Bi-Conjugate Gradient stabilized iterative matrix solver.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The Bi-Conjugate Gradient Stabilized (BiCGStab) solver is an 'improvement'
|
|||
/// of the standard Conjugate Gradient (CG) solver. Unlike the CG solver the
|
|||
/// BiCGStab can be used on non-symmetric matrices. <br/>
|
|||
/// Note that much of the success of the solver depends on the selection of the
|
|||
/// proper preconditioner.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The Bi-CGSTAB algorithm was taken from: <br/>
|
|||
/// Templates for the solution of linear systems: Building blocks
|
|||
/// for iterative methods
|
|||
/// <br/>
|
|||
/// Richard Barrett, Michael Berry, Tony F. Chan, James Demmel,
|
|||
/// June M. Donato, Jack Dongarra, Victor Eijkhout, Roldan Pozo,
|
|||
/// Charles Romine and Henk van der Vorst
|
|||
/// <br/>
|
|||
/// Url: <a href="http://www.netlib.org/templates/Templates.html">http://www.netlib.org/templates/Templates.html</a>
|
|||
/// <br/>
|
|||
/// Algorithm is described in Chapter 2, section 2.3.8, page 27
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The example code below provides an indication of the possible use of the
|
|||
/// solver.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
public sealed class BiCgStab : IIterativeSolver |
|||
{ |
|||
/// <summary>
|
|||
/// The status used if there is no status, i.e. the solver hasn't run yet and there is no
|
|||
/// iterator.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
|
|||
/// pre-conditioner will be used.
|
|||
/// </summary>
|
|||
private IPreConditioner _preconditioner; |
|||
|
|||
/// <summary>
|
|||
/// The iterative process controller.
|
|||
/// </summary>
|
|||
private IIterator _iterator; |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the user has stopped the solver.
|
|||
/// </summary>
|
|||
private bool _hasBeenStopped; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="BiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings and a default preconditioner.
|
|||
/// </remarks>
|
|||
public BiCgStab() : this(null, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="BiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// When using this constructor the solver will use a default preconditioner.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process. </param>
|
|||
public BiCgStab(IIterator iterator) : this(null, iterator) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="BiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings.
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
public BiCgStab(IPreConditioner preconditioner) : this(preconditioner, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="BiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation. </param>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process. </param>
|
|||
public BiCgStab(IPreConditioner preconditioner, IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="preconditioner">The preconditioner.</param>
|
|||
public void SetPreconditioner(IPreConditioner preconditioner) |
|||
{ |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator.</param>
|
|||
public void SetIterator(IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the status of the iteration once the calculation is finished.
|
|||
/// </summary>
|
|||
public ICalculationStatus IterationResult |
|||
{ |
|||
get |
|||
{ |
|||
return (_iterator != null) ? _iterator.Status : DefaultStatus; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stops the solve process.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that it may take an indetermined amount of time for the solver to actually stop the process.
|
|||
/// </remarks>
|
|||
public void StopSolve() |
|||
{ |
|||
_hasBeenStopped = true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
|
|||
/// <param name="vector">The solution <see cref="Vector"/>, <c>b</c>.</param>
|
|||
/// <returns>The result <see cref="Vector"/>, <c>x</c>.</returns>
|
|||
public Vector Solve(Matrix matrix, Vector vector) |
|||
{ |
|||
if (vector == null) |
|||
{ |
|||
throw new ArgumentNullException(); |
|||
} |
|||
|
|||
Vector result = new DenseVector(matrix.RowCount); |
|||
Solve(matrix, vector, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
|
|||
/// <param name="input">The solution <see cref="Vector"/>, <c>b</c>.</param>
|
|||
/// <param name="result">The result <see cref="Vector"/>, <c>x</c>.</param>
|
|||
public void Solve(Matrix matrix, Vector input, Vector result) |
|||
{ |
|||
// If we were stopped before, we are no longer
|
|||
// We're doing this at the start of the method to ensure
|
|||
// that we can use these fields immediately.
|
|||
_hasBeenStopped = false; |
|||
|
|||
// Parameters checks
|
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (result.Count != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Initialize the solver fields
|
|||
// Set the convergence monitor
|
|||
if (_iterator == null) |
|||
{ |
|||
_iterator = Iterator.CreateDefault(); |
|||
} |
|||
|
|||
if (_preconditioner == null) |
|||
{ |
|||
_preconditioner = new UnitPreconditioner(); |
|||
} |
|||
|
|||
_preconditioner.Initialize(matrix); |
|||
|
|||
// Compute r_0 = b - Ax_0 for some initial guess x_0
|
|||
// In this case we take x_0 = vector
|
|||
// This is basically a SAXPY so it could be made a lot faster
|
|||
Vector residuals = new DenseVector(matrix.RowCount); |
|||
CalculateTrueResidual(matrix, residuals, result, input); |
|||
|
|||
// Choose r~ (for example, r~ = r_0)
|
|||
var tempResiduals = residuals.Clone(); |
|||
var temp = result.Clone(); |
|||
|
|||
// create five temporary vectors needed to hold temporary
|
|||
// coefficients. All vectors are mangled in each iteration.
|
|||
// These are defined here to prevent stressing the garbage collector
|
|||
Vector vecP = new DenseVector(residuals.Count); |
|||
Vector vecPdash = new DenseVector(residuals.Count); |
|||
Vector nu = new DenseVector(residuals.Count); |
|||
Vector vecS = new DenseVector(residuals.Count); |
|||
Vector vecSdash = new DenseVector(residuals.Count); |
|||
Vector t = new DenseVector(residuals.Count); |
|||
|
|||
Vector mult = new DenseVector(residuals.Count); |
|||
|
|||
// create some temporary double variables that are needed
|
|||
// to hold values in between iterations
|
|||
double currentRho = 0; |
|||
double alpha = 0; |
|||
double omega = 0; |
|||
|
|||
var iterationNumber = 0; |
|||
while (ShouldContinue(iterationNumber, result, input, residuals)) |
|||
{ |
|||
// rho_(i-1) = r~^T r_(i-1) // dotproduct r~ and r_(i-1)
|
|||
var oldRho = currentRho; |
|||
currentRho = tempResiduals.DotProduct(residuals); |
|||
|
|||
// if (rho_(i-1) == 0) // METHOD FAILS
|
|||
// If rho is only 1 ULP from zero then we fail.
|
|||
if (currentRho.AlmostEqual(0, 1)) |
|||
{ |
|||
// Rho-type breakdown
|
|||
throw new Exception("Iterative solver experience a numerical break down"); |
|||
} |
|||
|
|||
if (iterationNumber != 0) |
|||
{ |
|||
// beta_(i-1) = (rho_(i-1)/rho_(i-2))(alpha_(i-1)/omega(i-1))
|
|||
var beta = (currentRho / oldRho) * (alpha / omega); |
|||
|
|||
// p_i = r_(i-1) + beta_(i-1)(p_(i-1) - omega_(i-1) * nu_(i-1))
|
|||
nu.Multiply(-omega, mult); |
|||
vecP.Add(mult); |
|||
|
|||
vecP.Multiply(beta); |
|||
vecP.Add(residuals); |
|||
} |
|||
else |
|||
{ |
|||
// p_i = r_(i-1)
|
|||
residuals.CopyTo(vecP); |
|||
} |
|||
|
|||
// SOLVE Mp~ = p_i // M = preconditioner
|
|||
_preconditioner.Approximate(vecP, vecPdash); |
|||
|
|||
// nu_i = Ap~
|
|||
matrix.Multiply(vecPdash, nu); |
|||
|
|||
// alpha_i = rho_(i-1)/ (r~^T nu_i) = rho / dotproduct(r~ and nu_i)
|
|||
alpha = currentRho * 1 / tempResiduals.DotProduct(nu); |
|||
|
|||
// s = r_(i-1) - alpha_i nu_i
|
|||
nu.Multiply(-alpha, mult); |
|||
residuals.Add(mult, vecS); |
|||
|
|||
// Check if we're converged. If so then stop. Otherwise continue;
|
|||
// Calculate the temporary result.
|
|||
// Be careful not to change any of the temp vectors, except for
|
|||
// temp. Others will be used in the calculation later on.
|
|||
// x_i = x_(i-1) + alpha_i * p^_i + s^_i
|
|||
vecPdash.Multiply(alpha, temp); |
|||
temp.Add(vecSdash); |
|||
temp.Add(result); |
|||
|
|||
// Check convergence and stop if we are converged.
|
|||
if (!ShouldContinue(iterationNumber, temp, input, vecS)) |
|||
{ |
|||
temp.CopyTo(result); |
|||
|
|||
// Calculate the true residual
|
|||
CalculateTrueResidual(matrix, residuals, result, input); |
|||
|
|||
// Now recheck the convergence
|
|||
if (!ShouldContinue(iterationNumber, result, input, residuals)) |
|||
{ |
|||
// We're all good now.
|
|||
return; |
|||
} |
|||
|
|||
// Continue the calculation
|
|||
iterationNumber++; |
|||
continue; |
|||
} |
|||
|
|||
// SOLVE Ms~ = s
|
|||
_preconditioner.Approximate(vecS, vecSdash); |
|||
|
|||
// temp = As~
|
|||
matrix.Multiply(vecSdash, t); |
|||
|
|||
// omega_i = temp^T s / temp^T temp
|
|||
omega = t.DotProduct(vecS) / t.DotProduct(t); |
|||
|
|||
// x_i = x_(i-1) + alpha_i p^ + omega_i s^
|
|||
vecSdash.Multiply(omega, mult); |
|||
result.Add(mult); |
|||
|
|||
vecPdash.Multiply(alpha, mult); |
|||
result.Add(mult); |
|||
|
|||
t.Multiply(-omega, residuals); |
|||
residuals.Add(vecS); |
|||
|
|||
// for continuation it is necessary that omega_i != 0.0
|
|||
// If omega is only 1 ULP from zero then we fail.
|
|||
if (omega.AlmostEqual(0, 1)) |
|||
{ |
|||
// Omega-type breakdown
|
|||
throw new Exception("Iterative solver experience a numerical break down"); |
|||
} |
|||
|
|||
if (!ShouldContinue(iterationNumber, result, input, residuals)) |
|||
{ |
|||
// Recalculate the residuals and go round again. This is done to ensure that
|
|||
// we have the proper residuals.
|
|||
// The residual calculation based on omega_i * s can be off by a factor 10. So here
|
|||
// we calculate the real residual (which can be expensive) but we only do it if we're
|
|||
// sufficiently close to the finish.
|
|||
CalculateTrueResidual(matrix, residuals, result, input); |
|||
} |
|||
|
|||
iterationNumber++; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax
|
|||
/// </summary>
|
|||
/// <param name="matrix">Instance of the <see cref="Matrix"/> A.</param>
|
|||
/// <param name="residual">Residual values in <see cref="Vector"/>.</param>
|
|||
/// <param name="x">Instance of the <see cref="Vector"/> x.</param>
|
|||
/// <param name="b">Instance of the <see cref="Vector"/> b.</param>
|
|||
private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b) |
|||
{ |
|||
// -Ax = residual
|
|||
matrix.Multiply(x, residual); |
|||
|
|||
// Do not use residual = residual.Negate() because it creates another object
|
|||
residual.Multiply(-1); |
|||
|
|||
// residual + b
|
|||
residual.Add(b); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determine if calculation should continue
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">Number of iterations passed</param>
|
|||
/// <param name="result">Result <see cref="Vector"/>.</param>
|
|||
/// <param name="source">Source <see cref="Vector"/>.</param>
|
|||
/// <param name="residuals">Residual <see cref="Vector"/>.</param>
|
|||
/// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
|
|||
private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals) |
|||
{ |
|||
if (_hasBeenStopped) |
|||
{ |
|||
_iterator.IterationCancelled(); |
|||
return true; |
|||
} |
|||
|
|||
_iterator.DetermineStatus(iterationNumber, result, source, residuals); |
|||
var status = _iterator.Status; |
|||
|
|||
// We stop if either:
|
|||
// - the user has stopped the calculation
|
|||
// - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
|
|||
return (!status.TerminatesCalculation) && (!_hasBeenStopped); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
|
|||
/// <param name="input">The solution <see cref="Matrix"/>, <c>B</c>.</param>
|
|||
/// <returns>The result <see cref="Matrix"/>, <c>X</c>.</returns>
|
|||
public Matrix Solve(Matrix matrix, Matrix input) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
var result = matrix.CreateMatrix(input.RowCount, input.ColumnCount); |
|||
Solve(matrix, input, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
|
|||
/// <param name="input">The solution <see cref="Matrix"/>, <c>B</c>.</param>
|
|||
/// <param name="result">The result <see cref="Matrix"/>, <c>X</c></param>
|
|||
public void Solve(Matrix matrix, Matrix input, Matrix result) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (matrix.RowCount != input.RowCount || input.RowCount != result.RowCount || input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
for (var column = 0; column < input.ColumnCount; column++) |
|||
{ |
|||
var solution = Solve(matrix, input.Column(column)); |
|||
foreach (var element in solution.GetIndexedEnumerator()) |
|||
{ |
|||
result.At(element.Key, column, element.Value); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,627 @@ |
|||
// <copyright file="CompositeSolver.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative |
|||
{ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
using System.Linq; |
|||
using System.Reflection; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// A composite matrix solver. The actual solver is made by a sequence of
|
|||
/// matrix solvers.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// Solver based on:<br />
|
|||
/// Faster PDE-based simulations using robust composite linear solvers<br />
|
|||
/// S. Bhowmicka, P. Raghavan a,*, L. McInnes b, B. Norris<br />
|
|||
/// Future Generation Computer Systems, Vol 20, 2004, pp 373–387<br />
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// Note that if an iterator is passed to this solver it will be used for all the sub-solvers.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
public sealed class CompositeSolver : IIterativeSolver |
|||
{ |
|||
#region Internal class - DoubleComparer
|
|||
/// <summary>
|
|||
/// An <c>IComparer</c> used to compare double precision floating points.
|
|||
/// </summary>
|
|||
/// NOTE: The instance of this class is used only in <see cref="SolverSetups"/>. If C# suppports interface inheritence
|
|||
/// NOTE: and methods in anonymous types, then this class should be deleted and anonymous type implemented with IComaprer support
|
|||
/// NOTE: in <see cref="SolverSetups"/> constructor
|
|||
public sealed class DoubleComparer : IComparer<double> |
|||
{ |
|||
/// <summary>
|
|||
/// Compares two double values based on the selected comparison method.
|
|||
/// </summary>
|
|||
/// <param name="x">The first double to compare.</param>
|
|||
/// <param name="y">The second double to compare.</param>
|
|||
/// <returns>
|
|||
/// A 32-bit signed integer that indicates the relative order of the objects being compared. The return
|
|||
/// value has the following meanings:
|
|||
/// Value Meaning Less than zero This object is less than the other parameter.
|
|||
/// Zero This object is equal to other.
|
|||
/// Greater than zero This object is greater than other.
|
|||
/// </returns>
|
|||
public int Compare(double x, double y) |
|||
{ |
|||
return x.CompareTo(y, 1); |
|||
} |
|||
} |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// The default status used if the solver is not running.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus NonRunningStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The default status used if the solver is running.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus RunningStatus = new CalculationRunning(); |
|||
|
|||
#if SILVERLIGHT
|
|||
private static readonly Dictionary<double, List<IIterativeSolverSetup>> SolverSetups = new Dictionary<double, List<IIterativeSolverSetup>>(); |
|||
#else
|
|||
/// <summary>
|
|||
/// The collection of iterative solver setups. Stored based on the
|
|||
/// ratio between the relative speed and relative accuracy.
|
|||
/// </summary>
|
|||
private static readonly SortedList<double, List<IIterativeSolverSetup>> SolverSetups = new SortedList<double, List<IIterativeSolverSetup>>(new DoubleComparer()); |
|||
#endif
|
|||
|
|||
#region Solver information loading methods
|
|||
|
|||
/// <summary>
|
|||
/// Loads all the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
|
|||
/// </summary>
|
|||
public static void LoadSolverInformation() |
|||
{ |
|||
LoadSolverInformation(new Type[0]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
|
|||
/// </summary>
|
|||
/// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
|
|||
public static void LoadSolverInformation(Type[] typesToExclude) |
|||
{ |
|||
LoadSolverInformationFromAssembly(Assembly.GetExecutingAssembly(), typesToExclude); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
|
|||
/// </summary>
|
|||
/// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
|
|||
public static void LoadSolverInformationFromAssembly(string assemblyLocation) |
|||
{ |
|||
LoadSolverInformationFromAssembly(assemblyLocation, new Type[0]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
|
|||
/// </summary>
|
|||
/// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
|
|||
/// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded. </param>
|
|||
public static void LoadSolverInformationFromAssembly(string assemblyLocation, params Type[] typesToExclude) |
|||
{ |
|||
if (assemblyLocation == null) |
|||
{ |
|||
throw new ArgumentNullException("assemblyLocation"); |
|||
} |
|||
|
|||
if (assemblyLocation.Length == 0) |
|||
{ |
|||
throw new ArgumentException(); |
|||
} |
|||
|
|||
if (!File.Exists(assemblyLocation)) |
|||
{ |
|||
throw new FileNotFoundException(); |
|||
} |
|||
|
|||
// Get the assembly name
|
|||
var assemblyFileName = Path.GetFileNameWithoutExtension(assemblyLocation); |
|||
|
|||
// Now load the assembly with an AssemblyName
|
|||
var assemblyName = new AssemblyName(assemblyFileName); |
|||
var assembly = Assembly.Load(assemblyName); |
|||
|
|||
// <ay throws:
|
|||
// ArgumentNullException --> Can't get this because we checked that the file exists.
|
|||
// FileNotFoundException --> Can't get this because we checked that the file exists.
|
|||
// FileLoadException
|
|||
// BadImageFormatException
|
|||
// Now we can load the solver information.
|
|||
LoadSolverInformationFromAssembly(assembly, typesToExclude); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
|
|||
/// </summary>
|
|||
/// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects. </param>
|
|||
public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName) |
|||
{ |
|||
LoadSolverInformationFromAssembly(assemblyName, new Type[0]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
|
|||
/// </summary>
|
|||
/// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
|
|||
/// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
|
|||
public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName, params Type[] typesToExclude) |
|||
{ |
|||
if (assemblyName == null) |
|||
{ |
|||
throw new ArgumentNullException("assemblyName"); |
|||
} |
|||
|
|||
var assembly = Assembly.Load(assemblyName); |
|||
|
|||
// May throw:
|
|||
// ArgumentNullException --> Can't get this because we checked it.
|
|||
// FileNotFoundException
|
|||
// FileLoadException
|
|||
// BadImageFormatException
|
|||
// Now we can load the solver information.
|
|||
LoadSolverInformationFromAssembly(assembly, typesToExclude); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
|
|||
/// </summary>
|
|||
/// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
|
|||
public static void LoadSolverInformationFromAssembly(Type typeInAssembly) |
|||
{ |
|||
LoadSolverInformationFromAssembly(typeInAssembly, new Type[0]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
|
|||
/// </summary>
|
|||
/// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
|
|||
/// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
|
|||
public static void LoadSolverInformationFromAssembly(Type typeInAssembly, params Type[] typesToExclude) |
|||
{ |
|||
if (typeInAssembly == null) |
|||
{ |
|||
throw new ArgumentNullException("typeInAssembly"); |
|||
} |
|||
|
|||
LoadSolverInformationFromAssembly(typeInAssembly.Assembly, typesToExclude); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
|
|||
/// </summary>
|
|||
/// <param name="assembly">The assembly which will be searched for setup objects.</param>
|
|||
public static void LoadSolverInformationFromAssembly(Assembly assembly) |
|||
{ |
|||
LoadSolverInformationFromAssembly(assembly, new Type[0]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
|
|||
/// </summary>
|
|||
/// <param name="assembly">The assembly which will be searched for setup objects.</param>
|
|||
/// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
|
|||
public static void LoadSolverInformationFromAssembly(Assembly assembly, params Type[] typesToExclude) |
|||
{ |
|||
if (assembly == null) |
|||
{ |
|||
throw new ArgumentNullException("Assembly"); |
|||
} |
|||
|
|||
if (typesToExclude == null) |
|||
{ |
|||
throw new ArgumentNullException("typesToExclude"); |
|||
} |
|||
|
|||
var excludedTypes = new List<Type>(typesToExclude); |
|||
|
|||
// Load all the types in the assembly
|
|||
// Find all the types that implement IIterativeSolverSetup
|
|||
// Create an object of each of these types
|
|||
// Get the type of the iterative solver that will be instantiated by the setup object
|
|||
// Check if it's on the excluding list, if so throw the setup object away otherwise keep it.
|
|||
var interfaceTypes = new List<Type>(); |
|||
foreach (var type in assembly.GetTypes().Where(type => (!type.IsAbstract && !type.IsEnum && !type.IsInterface && type.IsVisible))) |
|||
{ |
|||
interfaceTypes.AddRange(type.GetInterfaces()); |
|||
if (!interfaceTypes.Any(match => typeof(IIterativeSolverSetup).IsAssignableFrom(match))) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
// See if we actually want this type of iterative solver
|
|||
IIterativeSolverSetup setup; |
|||
try |
|||
{ |
|||
// If something goes wrong we just ignore it and move on with the next type.
|
|||
// There should probably be a log somewhere indicating that something went wrong?
|
|||
setup = (IIterativeSolverSetup)Activator.CreateInstance(type); |
|||
} |
|||
catch (ArgumentException) |
|||
{ |
|||
continue; |
|||
} |
|||
catch (NotSupportedException) |
|||
{ |
|||
continue; |
|||
} |
|||
catch (TargetInvocationException) |
|||
{ |
|||
continue; |
|||
} |
|||
catch (MethodAccessException) |
|||
{ |
|||
continue; |
|||
} |
|||
catch (MissingMethodException) |
|||
{ |
|||
continue; |
|||
} |
|||
catch (MemberAccessException) |
|||
{ |
|||
continue; |
|||
} |
|||
catch (TypeLoadException) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
if (excludedTypes.Any(match => match.IsAssignableFrom(setup.SolverType) || |
|||
match.IsAssignableFrom(setup.PreconditionerType))) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
// Ok we want the solver, so store the object
|
|||
var ratio = setup.SolutionSpeed / setup.Reliability; |
|||
if (!SolverSetups.ContainsKey(ratio)) |
|||
{ |
|||
SolverSetups.Add(ratio, new List<IIterativeSolverSetup>()); |
|||
} |
|||
|
|||
var list = SolverSetups[ratio]; |
|||
list.Add(setup); |
|||
} |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// The collection of solvers that will be used to
|
|||
/// </summary>
|
|||
private readonly List<IIterativeSolver> _solvers = new List<IIterativeSolver>(); |
|||
|
|||
/// <summary>
|
|||
/// The status of the calculation.
|
|||
/// </summary>
|
|||
private ICalculationStatus _status = NonRunningStatus; |
|||
|
|||
/// <summary>
|
|||
/// The iterator that is used to control the iteration process.
|
|||
/// </summary>
|
|||
private IIterator _iterator; |
|||
|
|||
/// <summary>
|
|||
/// A flag indicating if the solver has been stopped or not.
|
|||
/// </summary>
|
|||
private bool _hasBeenStopped; |
|||
|
|||
/// <summary>
|
|||
/// The solver that is currently running. Reference is used to be able to stop the
|
|||
/// solver if the user cancels the solve process.
|
|||
/// </summary>
|
|||
private IIterativeSolver _currentSolver; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="CompositeSolver"/> class with the default iterator.
|
|||
/// </summary>
|
|||
public CompositeSolver() : this(null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="CompositeSolver"/> class with the specified iterator.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator that will be used to control the iteration process. </param>
|
|||
public CompositeSolver(IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <c>IIterator</c> that will be used to track the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator.</param>
|
|||
public void SetIterator(IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the status of the iteration once the calculation is finished.
|
|||
/// </summary>
|
|||
public ICalculationStatus IterationResult |
|||
{ |
|||
get |
|||
{ |
|||
return _status; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stops the solve process.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that it may take an indetermined amount of time for the solver to actually stop the process.
|
|||
/// </remarks>
|
|||
public void StopSolve() |
|||
{ |
|||
_hasBeenStopped = true; |
|||
if (_currentSolver != null) |
|||
{ |
|||
_currentSolver.StopSolve(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="vector">The solution vector, <c>b</c>.</param>
|
|||
/// <returns>The result vector, <c>x</c>.</returns>
|
|||
public Vector Solve(Matrix matrix, Vector vector) |
|||
{ |
|||
if (vector == null) |
|||
{ |
|||
throw new ArgumentNullException(); |
|||
} |
|||
|
|||
Vector result = new DenseVector(matrix.RowCount); |
|||
Solve(matrix, vector, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution vector, <c>b</c></param>
|
|||
/// <param name="result">The result vector, <c>x</c></param>
|
|||
public void Solve(Matrix matrix, Vector input, Vector result) |
|||
{ |
|||
// If we were stopped before, we are no longer
|
|||
// We're doing this at the start of the method to ensure
|
|||
// that we can use these fields immediately.
|
|||
_hasBeenStopped = false; |
|||
_currentSolver = null; |
|||
|
|||
// Error checks
|
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (result.Count != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Initialize the solver fields
|
|||
// Set the convergence monitor
|
|||
if (_iterator == null) |
|||
{ |
|||
_iterator = Iterator.CreateDefault(); |
|||
} |
|||
|
|||
// Load the solvers into our own internal data structure
|
|||
// Once we have solvers we can always reuse them.
|
|||
if (_solvers.Count == 0) |
|||
{ |
|||
LoadSolvers(); |
|||
} |
|||
|
|||
// Create a copy of the solution and result vectors so we can use them
|
|||
// later on
|
|||
var internalInput = input.Clone(); |
|||
var internalResult = result.Clone(); |
|||
|
|||
foreach (var solver in _solvers.TakeWhile(solver => !_hasBeenStopped)) |
|||
{ |
|||
// Store a reference to the solver so we can stop it.
|
|||
_currentSolver = solver; |
|||
|
|||
try |
|||
{ |
|||
// Reset the iterator and pass it to the solver
|
|||
_iterator.ResetToPrecalculationState(); |
|||
solver.SetIterator(_iterator); |
|||
|
|||
// Start the solver
|
|||
solver.Solve(matrix, internalInput, internalResult); |
|||
} |
|||
catch (Exception) |
|||
{ |
|||
// The solver broke down.
|
|||
// Log a message about this
|
|||
// Switch to the next preconditioner.
|
|||
// Reset the solution vector to the previous solution
|
|||
input.CopyTo(internalInput); |
|||
_status = RunningStatus; |
|||
continue; |
|||
} |
|||
|
|||
// There was no fatal breakdown so check the status
|
|||
if (_iterator.Status is CalculationConverged) |
|||
{ |
|||
// We're done
|
|||
break; |
|||
} |
|||
|
|||
// We're not done
|
|||
// Either:
|
|||
// - calculation finished without convergence
|
|||
if (_iterator.Status is CalculationStoppedWithoutConvergence) |
|||
{ |
|||
// Copy the internal result to the result vector and
|
|||
// continue with the calculation.
|
|||
internalInput.CopyTo(input); |
|||
} |
|||
else |
|||
{ |
|||
// - calculation failed --> restart with the original vector
|
|||
// - calculation diverged --> restart with the original vector
|
|||
// - Some unknown status occurred --> To be safe restart.
|
|||
input.CopyTo(internalInput); |
|||
} |
|||
} |
|||
|
|||
// Inside the loop we already copied the final results (if there are any)
|
|||
// So no need to do that again.
|
|||
|
|||
// Clean up
|
|||
// No longer need the current solver
|
|||
_currentSolver = null; |
|||
|
|||
// Set the final status
|
|||
_status = _iterator.Status; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Load solvers
|
|||
/// </summary>
|
|||
private void LoadSolvers() |
|||
{ |
|||
if (SolverSetups.Count == 0) |
|||
{ |
|||
throw new Exception("IIterativeSolverSetup objects not found"); |
|||
} |
|||
|
|||
#if SILVERLIGHT
|
|||
foreach (var setup in SolverSetups.OrderBy(solver => solver.Key, new DoubleComparer()).Select(pair => pair.Value).SelectMany(setups => setups)) |
|||
#else
|
|||
foreach (var setup in SolverSetups.Select(pair => pair.Value).SelectMany(setups => setups)) |
|||
#endif
|
|||
{ |
|||
_solvers.Add(setup.CreateNew()); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <returns>The result matrix, <c>X</c>.</returns>
|
|||
public Matrix Solve(Matrix matrix, Matrix input) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
var result = matrix.CreateMatrix(input.RowCount, input.ColumnCount); |
|||
Solve(matrix, input, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <param name="result">The result matrix, <c>X</c></param>
|
|||
public void Solve(Matrix matrix, Matrix input, Matrix result) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (matrix.RowCount != input.RowCount || input.RowCount != result.RowCount || input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
for (var column = 0; column < input.ColumnCount; column++) |
|||
{ |
|||
var solution = Solve(matrix, input.Column(column)); |
|||
foreach (var element in solution.GetIndexedEnumerator()) |
|||
{ |
|||
result.At(element.Key, column, element.Value); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,634 @@ |
|||
// <copyright file="GpBiCg.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative |
|||
{ |
|||
using System; |
|||
using Preconditioners; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// A Generalized Product Bi-Conjugate Gradient iterative matrix solver.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an
|
|||
/// alternative version of the Bi-Conjugate Gradient stabilized (CG) solver.
|
|||
/// Unlike the CG solver the GPBiCG solver can be used on
|
|||
/// non-symmetric matrices. <br/>
|
|||
/// Note that much of the success of the solver depends on the selection of the
|
|||
/// proper preconditioner.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The GPBiCG algorithm was taken from: <br/>
|
|||
/// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with
|
|||
/// efficiency and robustness
|
|||
/// <br/>
|
|||
/// S. Fujino
|
|||
/// <br/>
|
|||
/// Applied Numerical Mathematics, Volume 41, 2002, pp 107 - 117
|
|||
/// <br/>
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The example code below provides an indication of the possible use of the
|
|||
/// solver.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
public sealed class GpBiCg : IIterativeSolver |
|||
{ |
|||
/// <summary>
|
|||
/// The status used if there is no status, i.e. the solver hasn't run yet and there is no
|
|||
/// iterator.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
|
|||
/// pre-conditioner will be used.
|
|||
/// </summary>
|
|||
private IPreConditioner _preconditioner; |
|||
|
|||
/// <summary>
|
|||
/// The iterative process controller.
|
|||
/// </summary>
|
|||
private IIterator _iterator; |
|||
|
|||
/// <summary>
|
|||
/// Indicates the number of <c>BiCGStab</c> steps should be taken
|
|||
/// before switching.
|
|||
/// </summary>
|
|||
private int _numberOfBiCgStabSteps = 1; |
|||
|
|||
/// <summary>
|
|||
/// Indicates the number of <c>GPBiCG</c> steps should be taken
|
|||
/// before switching.
|
|||
/// </summary>
|
|||
private int _numberOfGpbiCgSteps = 4; |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the user has stopped the solver.
|
|||
/// </summary>
|
|||
private bool _hasBeenStopped; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="GpBiCg"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings and a default preconditioner.
|
|||
/// </remarks>
|
|||
public GpBiCg() : this(null, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="GpBiCg"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// When using this constructor the solver will use a default preconditioner.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
|
|||
public GpBiCg(IIterator iterator) : this(null, iterator) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="GpBiCg"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings.
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
public GpBiCg(IPreConditioner preconditioner) : this(preconditioner, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="GpBiCg"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
|
|||
public GpBiCg(IPreConditioner preconditioner, IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of steps taken with the <c>BiCgStab</c> algorithm
|
|||
/// before switching over to the <c>GPBiCG</c> algorithm.
|
|||
/// </summary>
|
|||
public int NumberOfBiCgStabSteps |
|||
{ |
|||
get |
|||
{ |
|||
return _numberOfBiCgStabSteps; |
|||
} |
|||
|
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_numberOfBiCgStabSteps = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of steps taken with the <c>GPBiCG</c> algorithm
|
|||
/// before switching over to the <c>BiCgStab</c> algorithm.
|
|||
/// </summary>
|
|||
public int NumberOfGpBiCgSteps |
|||
{ |
|||
get |
|||
{ |
|||
return _numberOfGpbiCgSteps; |
|||
} |
|||
|
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_numberOfGpbiCgSteps = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="preconditioner">The preconditioner.</param>
|
|||
public void SetPreconditioner(IPreConditioner preconditioner) |
|||
{ |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator.</param>
|
|||
public void SetIterator(IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the status of the iteration once the calculation is finished.
|
|||
/// </summary>
|
|||
public ICalculationStatus IterationResult |
|||
{ |
|||
get |
|||
{ |
|||
return (_iterator != null) ? _iterator.Status : DefaultStatus; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stops the solve process.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that it may take an indetermined amount of time for the solver to actually
|
|||
/// stop the process.
|
|||
/// </remarks>
|
|||
public void StopSolve() |
|||
{ |
|||
_hasBeenStopped = true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="vector">The solution vector, <c>b</c>.</param>
|
|||
/// <returns>The result vector, <c>x</c>.</returns>
|
|||
public Vector Solve(Matrix matrix, Vector vector) |
|||
{ |
|||
if (vector == null) |
|||
{ |
|||
throw new ArgumentNullException(); |
|||
} |
|||
|
|||
Vector result = new DenseVector(matrix.RowCount); |
|||
Solve(matrix, vector, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution vector, <c>b</c></param>
|
|||
/// <param name="result">The result vector, <c>x</c></param>
|
|||
public void Solve(Matrix matrix, Vector input, Vector result) |
|||
{ |
|||
// If we were stopped before, we are no longer
|
|||
// We're doing this at the start of the method to ensure
|
|||
// that we can use these fields immediately.
|
|||
_hasBeenStopped = false; |
|||
|
|||
// Error checks
|
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (result.Count != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Initialize the solver fields
|
|||
|
|||
// Set the convergence monitor
|
|||
if (_iterator == null) |
|||
{ |
|||
_iterator = Iterator.CreateDefault(); |
|||
} |
|||
|
|||
if (_preconditioner == null) |
|||
{ |
|||
_preconditioner = new UnitPreconditioner(); |
|||
} |
|||
|
|||
_preconditioner.Initialize(matrix); |
|||
|
|||
// x_0 is initial guess
|
|||
// Take x_0 = 0
|
|||
Vector xtemp = new DenseVector(input.Count); |
|||
|
|||
// r_0 = b - Ax_0
|
|||
// This is basically a SAXPY so it could be made a lot faster
|
|||
Vector residuals = new DenseVector(matrix.RowCount); |
|||
CalculateTrueResidual(matrix, residuals, xtemp, input); |
|||
|
|||
// Define the temporary scalars
|
|||
double beta = 0; |
|||
double sigma; |
|||
|
|||
// Define the temporary vectors
|
|||
// rDash_0 = r_0
|
|||
Vector rdash = new DenseVector(residuals); |
|||
|
|||
// t_-1 = 0
|
|||
Vector t = new DenseVector(residuals.Count); |
|||
Vector t0 = new DenseVector(residuals.Count); |
|||
|
|||
// w_-1 = 0
|
|||
Vector w = new DenseVector(residuals.Count); |
|||
|
|||
// Define the remaining temporary vectors
|
|||
Vector c = new DenseVector(residuals.Count); |
|||
Vector p = new DenseVector(residuals.Count); |
|||
Vector s = new DenseVector(residuals.Count); |
|||
Vector u = new DenseVector(residuals.Count); |
|||
Vector y = new DenseVector(residuals.Count); |
|||
Vector z = new DenseVector(residuals.Count); |
|||
|
|||
Vector temp = new DenseVector(residuals.Count); |
|||
Vector mult = new DenseVector(residuals.Count); |
|||
|
|||
// for (k = 0, 1, .... )
|
|||
var iterationNumber = 0; |
|||
while (ShouldContinue(iterationNumber, xtemp, input, residuals)) |
|||
{ |
|||
// p_k = r_k + beta_(k-1) * (p_(k-1) - u_(k-1))
|
|||
p.Subtract(u, temp); |
|||
|
|||
temp.Multiply(beta, mult); |
|||
residuals.Add(mult, p); |
|||
|
|||
// Solve M b_k = p_k
|
|||
_preconditioner.Approximate(p, temp); |
|||
|
|||
// s_k = A b_k
|
|||
matrix.Multiply(temp, s); |
|||
|
|||
// alpha_k = (r*_0 * r_k) / (r*_0 * s_k)
|
|||
var alpha = rdash.DotProduct(residuals) / rdash.DotProduct(s); |
|||
|
|||
// y_k = t_(k-1) - r_k - alpha_k * w_(k-1) + alpha_k s_k
|
|||
s.Subtract(w, temp); |
|||
t.Subtract(residuals, y); |
|||
|
|||
temp.Multiply(alpha, mult); |
|||
y.Add(mult); |
|||
|
|||
// Store the old value of t in t0
|
|||
t.CopyTo(t0); |
|||
|
|||
// t_k = r_k - alpha_k s_k
|
|||
s.Multiply(-alpha, mult); |
|||
residuals.Add(mult, t); |
|||
|
|||
// Solve M d_k = t_k
|
|||
_preconditioner.Approximate(t, temp); |
|||
|
|||
// c_k = A d_k
|
|||
matrix.Multiply(temp, c); |
|||
var cdot = c.DotProduct(c); |
|||
|
|||
// cDot can only be zero if c is a zero vector
|
|||
// We'll set cDot to 1 if it is zero to prevent NaN's
|
|||
// Note that the calculation should continue fine because
|
|||
// c.DotProduct(t) will be zero and so will c.DotProduct(y)
|
|||
if (cdot.AlmostEqual(0, 1)) |
|||
{ |
|||
cdot = 1.0; |
|||
} |
|||
|
|||
// Even if we don't want to do any BiCGStab steps we'll still have
|
|||
// to do at least one at the start to initialize the
|
|||
// system, but we'll only have to take special measures
|
|||
// if we don't do any so ...
|
|||
var ctdot = c.DotProduct(t); |
|||
double eta; |
|||
if (((_numberOfBiCgStabSteps == 0) && (iterationNumber == 0)) || ShouldRunBiCgStabSteps(iterationNumber)) |
|||
{ |
|||
// sigma_k = (c_k * t_k) / (c_k * c_k)
|
|||
sigma = ctdot / cdot; |
|||
|
|||
// eta_k = 0
|
|||
eta = 0; |
|||
} |
|||
else |
|||
{ |
|||
var ydot = y.DotProduct(y); |
|||
|
|||
// yDot can only be zero if y is a zero vector
|
|||
// We'll set yDot to 1 if it is zero to prevent NaN's
|
|||
// Note that the calculation should continue fine because
|
|||
// y.DotProduct(t) will be zero and so will c.DotProduct(y)
|
|||
if (ydot.AlmostEqual(0, 1)) |
|||
{ |
|||
ydot = 1.0; |
|||
} |
|||
|
|||
var ytdot = y.DotProduct(t); |
|||
var cydot = c.DotProduct(y); |
|||
|
|||
var denom = (cdot * ydot) - (cydot * cydot); |
|||
|
|||
// sigma_k = ((y_k * y_k)(c_k * t_k) - (y_k * t_k)(c_k * y_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
|
|||
sigma = ((ydot * ctdot) - (ytdot * cydot)) / denom; |
|||
|
|||
// eta_k = ((c_k * c_k)(y_k * t_k) - (y_k * c_k)(c_k * t_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
|
|||
eta = ((cdot * ytdot) - (cydot * ctdot)) / denom; |
|||
} |
|||
|
|||
// u_k = sigma_k s_k + eta_k (t_(k-1) - r_k + beta_(k-1) u_(k-1))
|
|||
u.Multiply(beta, mult); |
|||
t0.Add(mult, temp); |
|||
|
|||
temp.Subtract(residuals); |
|||
temp.Multiply(eta); |
|||
|
|||
s.Multiply(sigma, mult); |
|||
temp.Add(mult, u); |
|||
|
|||
// z_k = sigma_k r_k +_ eta_k z_(k-1) - alpha_k u_k
|
|||
z.Multiply(eta); |
|||
|
|||
u.Multiply(-alpha, mult); |
|||
z.Add(mult); |
|||
|
|||
residuals.Multiply(sigma, mult); |
|||
z.Add(mult); |
|||
|
|||
// x_(k+1) = x_k + alpha_k p_k + z_k
|
|||
p.Multiply(alpha, mult); |
|||
xtemp.Add(mult); |
|||
|
|||
xtemp.Add(z); |
|||
|
|||
// r_(k+1) = t_k - eta_k y_k - sigma_k c_k
|
|||
// Copy the old residuals to a temp vector because we'll
|
|||
// need those in the next step
|
|||
residuals.CopyTo(t0); |
|||
|
|||
y.Multiply(-eta, mult); |
|||
t.Add(mult, residuals); |
|||
|
|||
c.Multiply(-sigma, mult); |
|||
residuals.Add(mult); |
|||
|
|||
// beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k)
|
|||
// But first we check if there is a possible NaN. If so just reset beta to zero.
|
|||
beta = (!sigma.AlmostEqual(0, 1)) ? alpha / sigma * rdash.DotProduct(residuals) / rdash.DotProduct(t0) : 0; |
|||
|
|||
// w_k = c_k + beta_k s_k
|
|||
s.Multiply(beta, mult); |
|||
c.Add(mult, w); |
|||
|
|||
// Get the real value
|
|||
_preconditioner.Approximate(xtemp, result); |
|||
|
|||
// Now check for convergence
|
|||
if (!ShouldContinue(iterationNumber, result, input, residuals)) |
|||
{ |
|||
// Recalculate the residuals and go round again. This is done to ensure that
|
|||
// we have the proper residuals.
|
|||
CalculateTrueResidual(matrix, residuals, result, input); |
|||
} |
|||
|
|||
// Next iteration.
|
|||
iterationNumber++; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax
|
|||
/// </summary>
|
|||
/// <param name="matrix">Instance of the <see cref="Matrix"/> A.</param>
|
|||
/// <param name="residual">Residual values in <see cref="Vector"/>.</param>
|
|||
/// <param name="x">Instance of the <see cref="Vector"/> x.</param>
|
|||
/// <param name="b">Instance of the <see cref="Vector"/> b.</param>
|
|||
private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b) |
|||
{ |
|||
// -Ax = residual
|
|||
matrix.Multiply(x, residual); |
|||
residual.Multiply(-1); |
|||
|
|||
// residual + b
|
|||
residual.Add(b); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determine if calculation should continue
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">Number of iterations passed</param>
|
|||
/// <param name="result">Result <see cref="Vector"/>.</param>
|
|||
/// <param name="source">Source <see cref="Vector"/>.</param>
|
|||
/// <param name="residuals">Residual <see cref="Vector"/>.</param>
|
|||
/// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
|
|||
private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals) |
|||
{ |
|||
if (_hasBeenStopped) |
|||
{ |
|||
_iterator.IterationCancelled(); |
|||
return true; |
|||
} |
|||
|
|||
_iterator.DetermineStatus(iterationNumber, result, source, residuals); |
|||
var status = _iterator.Status; |
|||
|
|||
// We stop if either:
|
|||
// - the user has stopped the calculation
|
|||
// - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
|
|||
return (!status.TerminatesCalculation) && (!_hasBeenStopped); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decide if to do steps with BiCgStab
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">Number of iteration</param>
|
|||
/// <returns><c>true</c> if yes, otherwise <c>false</c></returns>
|
|||
private bool ShouldRunBiCgStabSteps(int iterationNumber) |
|||
{ |
|||
// Run the first steps as BiCGStab
|
|||
// The number of steps past a whole iteration set
|
|||
var difference = iterationNumber % (_numberOfBiCgStabSteps + _numberOfGpbiCgSteps); |
|||
|
|||
// Do steps with BiCGStab if:
|
|||
// - The difference is zero or more (i.e. we have done zero or more complete cycles)
|
|||
// - The difference is less than the number of BiCGStab steps that should be taken
|
|||
return (difference >= 0) && (difference < _numberOfBiCgStabSteps); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <returns>The result matrix, <c>X</c>.</returns>
|
|||
public Matrix Solve(Matrix matrix, Matrix input) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
var result = matrix.CreateMatrix(input.RowCount, input.ColumnCount); |
|||
Solve(matrix, input, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <param name="result">The result matrix, <c>X</c></param>
|
|||
public void Solve(Matrix matrix, Matrix input, Matrix result) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (matrix.RowCount != input.RowCount || input.RowCount != result.RowCount || input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
for (var column = 0; column < input.ColumnCount; column++) |
|||
{ |
|||
var solution = Solve(matrix, input.Column(column)); |
|||
foreach (var element in solution.GetIndexedEnumerator()) |
|||
{ |
|||
result.At(element.Key, column, element.Value); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,788 @@ |
|||
// <copyright file="MlkBiCgStab.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative |
|||
{ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Diagnostics; |
|||
using System.Linq; |
|||
using Distributions; |
|||
using Factorization; |
|||
using Preconditioners; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// A Multiple-Lanczos Bi-Conjugate Gradient stabilized iterative matrix solver.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement'
|
|||
/// of the standard BiCgStab solver.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The algorithm was taken from: <br/>
|
|||
/// ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors
|
|||
/// <br/>
|
|||
/// Man-chung Yeung and Tony F. Chan
|
|||
/// <br/>
|
|||
/// SIAM Journal of Scientific Computing
|
|||
/// <br/>
|
|||
/// Volume 21, Number 4, pp. 1263 - 1290
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The example code below provides an indication of the possible use of the
|
|||
/// solver.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
public sealed class MlkBiCgStab : IIterativeSolver |
|||
{ |
|||
/// <summary>
|
|||
/// The default number of starting vectors.
|
|||
/// </summary>
|
|||
private const int DefaultNumberOfStartingVectors = 50; |
|||
|
|||
/// <summary>
|
|||
/// The status used if there is no status, i.e. the solver hasn't run yet and there is no
|
|||
/// iterator.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
|
|||
/// pre-conditioner will be used.
|
|||
/// </summary>
|
|||
private IPreConditioner _preconditioner; |
|||
|
|||
/// <summary>
|
|||
/// The iterative process controller.
|
|||
/// </summary>
|
|||
private IIterator _iterator; |
|||
|
|||
/// <summary>
|
|||
/// The collection of starting vectors which are used as the basis for the Krylov sub-space.
|
|||
/// </summary>
|
|||
private IList<Vector> _startingVectors; |
|||
|
|||
/// <summary>
|
|||
/// The number of starting vectors used by the algorithm
|
|||
/// </summary>
|
|||
private int _numberOfStartingVectors = DefaultNumberOfStartingVectors; |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the user has stopped the solver.
|
|||
/// </summary>
|
|||
private bool _hasBeenStopped; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings and a default preconditioner.
|
|||
/// </remarks>
|
|||
public MlkBiCgStab() : this(null, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// When using this constructor the solver will use a default preconditioner.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
|
|||
public MlkBiCgStab(IIterator iterator) : this(null, iterator) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings.
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
public MlkBiCgStab(IPreConditioner preconditioner) : this(preconditioner, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
|
|||
public MlkBiCgStab(IPreConditioner preconditioner, IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of starting vectors.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Must be larger than 1 and smaller than the number of variables in the matrix that
|
|||
/// for which this solver will be used.
|
|||
/// </remarks>
|
|||
public int NumberOfStartingVectors |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _numberOfStartingVectors; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
if (value <= 1) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_numberOfStartingVectors = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the number of starting vectors to the default value.
|
|||
/// </summary>
|
|||
public void ResetNumberOfStartingVectors() |
|||
{ |
|||
_numberOfStartingVectors = DefaultNumberOfStartingVectors; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="preconditioner">The preconditioner.</param>
|
|||
public void SetPreconditioner(IPreConditioner preconditioner) |
|||
{ |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator.</param>
|
|||
public void SetIterator(IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a series of orthonormal vectors which will be used as basis for the
|
|||
/// Krylov sub-space.
|
|||
/// </summary>
|
|||
public IList<Vector> StartingVectors |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _startingVectors; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
if ((value == null) || (value.Count == 0)) |
|||
{ |
|||
_startingVectors = null; |
|||
} |
|||
else |
|||
{ |
|||
_startingVectors = value; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the status of the iteration once the calculation is finished.
|
|||
/// </summary>
|
|||
public ICalculationStatus IterationResult |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return (_iterator != null) ? _iterator.Status : DefaultStatus; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stops the solve process.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that it may take an indetermined amount of time for the solver to actually stop the process.
|
|||
/// </remarks>
|
|||
public void StopSolve() |
|||
{ |
|||
_hasBeenStopped = true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="vector">The solution vector, <c>b</c>.</param>
|
|||
/// <returns>The result vector, <c>x</c>.</returns>
|
|||
public Vector Solve(Matrix matrix, Vector vector) |
|||
{ |
|||
if (vector == null) |
|||
{ |
|||
throw new ArgumentNullException(); |
|||
} |
|||
|
|||
Vector result = new DenseVector(matrix.RowCount); |
|||
Solve(matrix, vector, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution vector, <c>b</c></param>
|
|||
/// <param name="result">The result vector, <c>x</c></param>
|
|||
public void Solve(Matrix matrix, Vector input, Vector result) |
|||
{ |
|||
// If we were stopped before, we are no longer
|
|||
// We're doing this at the start of the method to ensure
|
|||
// that we can use these fields immediately.
|
|||
_hasBeenStopped = false; |
|||
|
|||
// Error checks
|
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (result.Count != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Initialize the solver fields
|
|||
// Set the convergence monitor
|
|||
if (_iterator == null) |
|||
{ |
|||
_iterator = Iterator.CreateDefault(); |
|||
} |
|||
|
|||
if (_preconditioner == null) |
|||
{ |
|||
_preconditioner = new UnitPreconditioner(); |
|||
} |
|||
|
|||
_preconditioner.Initialize(matrix); |
|||
|
|||
// Choose an initial guess x_0
|
|||
// Take x_0 = 0
|
|||
Vector xtemp = new DenseVector(input.Count); |
|||
|
|||
// Choose k vectors q_1, q_2, ..., q_k
|
|||
// Build a new set if:
|
|||
// a) the stored set doesn't exist (i.e. == null)
|
|||
// b) Is of an incorrect length (i.e. too long)
|
|||
// c) The vectors are of an incorrect length (i.e. too long or too short)
|
|||
var useOld = false; |
|||
if (_startingVectors != null) |
|||
{ |
|||
// We don't accept collections with zero starting vectors so ...
|
|||
if (_startingVectors.Count <= NumberOfStartingVectorsToCreate(_numberOfStartingVectors, input.Count)) |
|||
{ |
|||
// Only check the first vector for sizing. If that matches we assume the
|
|||
// other vectors match too. If they don't the process will crash
|
|||
if (_startingVectors[0].Count == input.Count) |
|||
{ |
|||
useOld = true; |
|||
} |
|||
} |
|||
} |
|||
|
|||
_startingVectors = useOld ? _startingVectors : CreateStartingVectors(_numberOfStartingVectors, input.Count); |
|||
|
|||
// Store the number of starting vectors. Not really necessary but easier to type :)
|
|||
var k = _startingVectors.Count; |
|||
|
|||
// r_0 = b - Ax_0
|
|||
// This is basically a SAXPY so it could be made a lot faster
|
|||
Vector residuals = new DenseVector(matrix.RowCount); |
|||
CalculateTrueResidual(matrix, residuals, xtemp, input); |
|||
|
|||
// Define the temporary scalars
|
|||
var c = new double[k]; |
|||
|
|||
// Define the temporary vectors
|
|||
Vector gtemp = new DenseVector(residuals.Count); |
|||
|
|||
Vector u = new DenseVector(residuals.Count); |
|||
Vector utemp = new DenseVector(residuals.Count); |
|||
Vector temp = new DenseVector(residuals.Count); |
|||
Vector temp1 = new DenseVector(residuals.Count); |
|||
|
|||
Vector zd = new DenseVector(residuals.Count); |
|||
Vector zg = new DenseVector(residuals.Count); |
|||
Vector zw = new DenseVector(residuals.Count); |
|||
|
|||
Vector mult = new DenseVector(residuals.Count); |
|||
|
|||
var d = CreateVectorArray(_startingVectors.Count, residuals.Count); |
|||
|
|||
// g_0 = r_0
|
|||
var g = CreateVectorArray(_startingVectors.Count, residuals.Count); |
|||
residuals.CopyTo(g[k - 1]); |
|||
|
|||
var w = CreateVectorArray(_startingVectors.Count, residuals.Count); |
|||
|
|||
// FOR (j = 0, 1, 2 ....)
|
|||
var iterationNumber = 0; |
|||
while (ShouldContinue(iterationNumber, xtemp, input, residuals)) |
|||
{ |
|||
// SOLVE M g~_((j-1)k+k) = g_((j-1)k+k)
|
|||
_preconditioner.Approximate(g[k - 1], gtemp); |
|||
|
|||
// w_((j-1)k+k) = A g~_((j-1)k+k)
|
|||
matrix.Multiply(gtemp, w[k - 1]); |
|||
|
|||
// c_((j-1)k+k) = q^T_1 w_((j-1)k+k)
|
|||
c[k - 1] = _startingVectors[0].DotProduct(w[k - 1]); |
|||
if (c[k - 1].AlmostEqual(0, 1)) |
|||
{ |
|||
throw new Exception("Iterative solver experience a numerical break down"); |
|||
} |
|||
|
|||
// alpha_(jk+1) = q^T_1 r_((j-1)k+k) / c_((j-1)k+k)
|
|||
var alpha = _startingVectors[0].DotProduct(residuals) / c[k - 1]; |
|||
|
|||
// u_(jk+1) = r_((j-1)k+k) - alpha_(jk+1) w_((j-1)k+k)
|
|||
w[k - 1].Multiply(-alpha, mult); |
|||
residuals.Add(mult, u); |
|||
|
|||
// SOLVE M u~_(jk+1) = u_(jk+1)
|
|||
_preconditioner.Approximate(u, temp1); |
|||
temp1.CopyTo(utemp); |
|||
|
|||
// rho_(j+1) = -u^t_(jk+1) A u~_(jk+1) / ||A u~_(jk+1)||^2
|
|||
matrix.Multiply(temp1, temp); |
|||
var rho = temp.DotProduct(temp); |
|||
|
|||
// If rho is zero then temp is a zero vector and we're probably
|
|||
// about to have zero residuals (i.e. an exact solution).
|
|||
// So set rho to 1.0 because in the next step it will turn to zero.
|
|||
if (rho.AlmostEqual(0, 1)) |
|||
{ |
|||
rho = 1.0; |
|||
} |
|||
|
|||
rho = -u.DotProduct(temp) / rho; |
|||
|
|||
// x_(jk+1) = x_((j-1)k_k) - rho_(j+1) u~_(jk+1) + alpha_(jk+1) g~_((j-1)k+k)
|
|||
utemp.Multiply(-rho, mult); |
|||
xtemp.Add(mult); |
|||
|
|||
gtemp.Multiply(alpha); |
|||
xtemp.Add(gtemp); |
|||
|
|||
// r_(jk+1) = rho_(j+1) A u~_(jk+1) + u_(jk+1)
|
|||
u.CopyTo(residuals); |
|||
|
|||
// Reuse temp
|
|||
temp.Multiply(rho); |
|||
residuals.Add(temp); |
|||
|
|||
// Check convergence and stop if we are converged.
|
|||
if (!ShouldContinue(iterationNumber, xtemp, input, residuals)) |
|||
{ |
|||
// Calculate the true residual
|
|||
CalculateTrueResidual(matrix, residuals, xtemp, input); |
|||
|
|||
// Now recheck the convergence
|
|||
if (!ShouldContinue(iterationNumber, xtemp, input, residuals)) |
|||
{ |
|||
// We're all good now.
|
|||
// Exit from the while loop.
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
// FOR (i = 1,2, ...., k)
|
|||
for (var i = 0; i < k; i++) |
|||
{ |
|||
// z_d = u_(jk+1)
|
|||
u.CopyTo(zd); |
|||
|
|||
// z_g = r_(jk+i)
|
|||
residuals.CopyTo(zg); |
|||
|
|||
// z_w = 0
|
|||
zw.Clear(); |
|||
|
|||
// FOR (s = i, ...., k-1) AND j >= 1
|
|||
double beta; |
|||
if (iterationNumber >= 1) |
|||
{ |
|||
for (var s = i; s < k - 1; s++) |
|||
{ |
|||
// beta^(jk+i)_((j-1)k+s) = -q^t_(s+1) z_d / c_((j-1)k+s)
|
|||
beta = -_startingVectors[s + 1].DotProduct(zd) / c[s]; |
|||
|
|||
// z_d = z_d + beta^(jk+i)_((j-1)k+s) d_((j-1)k+s)
|
|||
d[s].Multiply(beta, mult); |
|||
zd.Add(mult); |
|||
|
|||
// z_g = z_g + beta^(jk+i)_((j-1)k+s) g_((j-1)k+s)
|
|||
g[s].Multiply(beta, mult); |
|||
zg.Add(mult); |
|||
|
|||
// z_w = z_w + beta^(jk+i)_((j-1)k+s) w_((j-1)k+s)
|
|||
w[s].Multiply(beta, mult); |
|||
zw.Add(mult); |
|||
} |
|||
} |
|||
|
|||
beta = rho * c[k - 1]; |
|||
if (beta.AlmostEqual(0, 1)) |
|||
{ |
|||
throw new Exception("Iterative solver experience a numerical break down"); |
|||
} |
|||
|
|||
// beta^(jk+i)_((j-1)k+k) = -(q^T_1 (r_(jk+1) + rho_(j+1) z_w)) / (rho_(j+1) c_((j-1)k+k))
|
|||
zw.Multiply(rho, mult); |
|||
residuals.Add(mult, temp); |
|||
beta = -_startingVectors[0].DotProduct(temp) / beta; |
|||
|
|||
// z_g = z_g + beta^(jk+i)_((j-1)k+k) g_((j-1)k+k)
|
|||
g[k - 1].Multiply(beta, mult); |
|||
zg.Add(mult); |
|||
|
|||
// z_w = rho_(j+1) (z_w + beta^(jk+i)_((j-1)k+k) w_((j-1)k+k))
|
|||
w[k - 1].Multiply(beta, mult); |
|||
zw.Add(mult); |
|||
zw.Multiply(rho); |
|||
|
|||
// z_d = r_(jk+i) + z_w
|
|||
residuals.Add(zw, zd); |
|||
|
|||
// FOR (s = 1, ... i - 1)
|
|||
for (var s = 0; s < i - 1; s++) |
|||
{ |
|||
// beta^(jk+i)_(jk+s) = -q^T_s+1 z_d / c_(jk+s)
|
|||
beta = -_startingVectors[s + 1].DotProduct(zd) / c[s]; |
|||
|
|||
// z_d = z_d + beta^(jk+i)_(jk+s) * d_(jk+s)
|
|||
d[s].Multiply(beta, mult); |
|||
zd.Add(mult); |
|||
|
|||
// z_g = z_g + beta^(jk+i)_(jk+s) * g_(jk+s)
|
|||
g[s].Multiply(beta, mult); |
|||
zg.Add(mult); |
|||
} |
|||
|
|||
// d_(jk+i) = z_d - u_(jk+i)
|
|||
zd.Subtract(u, d[i]); |
|||
|
|||
// g_(jk+i) = z_g + z_w
|
|||
zg.Add(zw, g[i]); |
|||
|
|||
// IF (i < k - 1)
|
|||
if (i < k - 1) |
|||
{ |
|||
// c_(jk+1) = q^T_i+1 d_(jk+i)
|
|||
c[i] = _startingVectors[i + 1].DotProduct(d[i]); |
|||
if (c[i].AlmostEqual(0, 1)) |
|||
{ |
|||
throw new Exception("Iterative solver experience a numerical break down"); |
|||
} |
|||
|
|||
// alpha_(jk+i+1) = q^T_(i+1) u_(jk+i) / c_(jk+i)
|
|||
alpha = _startingVectors[i + 1].DotProduct(u) / c[i]; |
|||
|
|||
// u_(jk+i+1) = u_(jk+i) - alpha_(jk+i+1) d_(jk+i)
|
|||
d[i].Multiply(-alpha, mult); |
|||
u.Add(mult); |
|||
|
|||
// SOLVE M g~_(jk+i) = g_(jk+i)
|
|||
_preconditioner.Approximate(g[i], gtemp); |
|||
|
|||
// x_(jk+i+1) = x_(jk+i) + rho_(j+1) alpha_(jk+i+1) g~_(jk+i)
|
|||
gtemp.Multiply(rho * alpha, mult); |
|||
xtemp.Add(mult); |
|||
|
|||
// w_(jk+i) = A g~_(jk+i)
|
|||
matrix.Multiply(gtemp, w[i]); |
|||
|
|||
// r_(jk+i+1) = r_(jk+i) - rho_(j+1) alpha_(jk+i+1) w_(jk+i)
|
|||
w[i].Multiply(-rho * alpha, mult); |
|||
residuals.Add(mult); |
|||
|
|||
// We can check the residuals here if they're close
|
|||
if (!ShouldContinue(iterationNumber, xtemp, input, residuals)) |
|||
{ |
|||
// Recalculate the residuals and go round again. This is done to ensure that
|
|||
// we have the proper residuals.
|
|||
CalculateTrueResidual(matrix, residuals, xtemp, input); |
|||
} |
|||
} |
|||
} // END ITERATION OVER i
|
|||
|
|||
iterationNumber++; |
|||
} |
|||
|
|||
// copy the temporary result to the real result vector
|
|||
xtemp.CopyTo(result); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of starting vectors to create
|
|||
/// </summary>
|
|||
/// <param name="maximumNumberOfStartingVectors">Maximum number</param>
|
|||
/// <param name="numberOfVariables">Number of variables</param>
|
|||
/// <returns>Number of starting vectors to create</returns>
|
|||
private static int NumberOfStartingVectorsToCreate(int maximumNumberOfStartingVectors, int numberOfVariables) |
|||
{ |
|||
// Create no more starting vectors than the size of the problem - 1
|
|||
return Math.Min(maximumNumberOfStartingVectors, (numberOfVariables - 1)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns an array of starting vectors.
|
|||
/// </summary>
|
|||
/// <param name="maximumNumberOfStartingVectors">The maximum number of starting vectors that should be created.</param>
|
|||
/// <param name="numberOfVariables">The number of variables.</param>
|
|||
/// <returns>
|
|||
/// An array with starting vectors. The array will never be larger than the
|
|||
/// <paramref name="maximumNumberOfStartingVectors"/> but it may be smaller if
|
|||
/// the <paramref name="numberOfVariables"/> is smaller than
|
|||
/// the <paramref name="maximumNumberOfStartingVectors"/>.
|
|||
/// </returns>
|
|||
private static IList<Vector> CreateStartingVectors(int maximumNumberOfStartingVectors, int numberOfVariables) |
|||
{ |
|||
// Create no more starting vectors than the size of the problem - 1
|
|||
// Get random values and then orthogonalize them with
|
|||
// modified Gramm - Schmidt
|
|||
var count = NumberOfStartingVectorsToCreate(maximumNumberOfStartingVectors, numberOfVariables); |
|||
|
|||
// Get a random set of samples based on the standard normal distribution with
|
|||
// mean = 0 and sd = 1
|
|||
var distribution = new Normal(); |
|||
|
|||
Matrix matrix = new DenseMatrix(numberOfVariables, count); |
|||
for (var i = 0; i < matrix.ColumnCount; i++) |
|||
{ |
|||
var samples = distribution.Samples().Take(matrix.RowCount).ToArray(); |
|||
|
|||
// Set the column
|
|||
matrix.SetColumn(i, samples); |
|||
} |
|||
|
|||
// Compute the orthogonalization.
|
|||
var gs = new GramSchmidt(matrix); |
|||
var orthogonalMatrix = gs.Q; |
|||
|
|||
// Now transfer this to vectors
|
|||
var result = new List<Vector>(); |
|||
for (var i = 0; i < orthogonalMatrix.ColumnCount; i++) |
|||
{ |
|||
result.Add(orthogonalMatrix.Column(i)); |
|||
|
|||
// Normalize the result vector
|
|||
result[i].Multiply(1 / result[i].Norm(2)); |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Create random vecrors array
|
|||
/// </summary>
|
|||
/// <param name="arraySize">Number of vectors</param>
|
|||
/// <param name="vectorSize">Size of each vector</param>
|
|||
/// <returns>Array of random vectors</returns>
|
|||
private static Vector[] CreateVectorArray(int arraySize, int vectorSize) |
|||
{ |
|||
var result = new Vector[arraySize]; |
|||
for (var i = 0; i < result.Length; i++) |
|||
{ |
|||
result[i] = new DenseVector(vectorSize); |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax
|
|||
/// </summary>
|
|||
/// <param name="matrix">Source <see cref="Matrix"/>A.</param>
|
|||
/// <param name="residual">Residual <see cref="Vector"/> data.</param>
|
|||
/// <param name="x">x <see cref="Vector"/> data.</param>
|
|||
/// <param name="b">b <see cref="Vector"/> data.</param>
|
|||
private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b) |
|||
{ |
|||
// -Ax = residual
|
|||
matrix.Multiply(x, residual); |
|||
residual.Multiply(-1); |
|||
|
|||
// residual + b
|
|||
residual.Add(b); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determine if calculation should continue
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">Number of iterations passed</param>
|
|||
/// <param name="result">Result <see cref="Vector"/>.</param>
|
|||
/// <param name="source">Source <see cref="Vector"/>.</param>
|
|||
/// <param name="residuals">Residual <see cref="Vector"/>.</param>
|
|||
/// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
|
|||
private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals) |
|||
{ |
|||
if (_hasBeenStopped) |
|||
{ |
|||
_iterator.IterationCancelled(); |
|||
return true; |
|||
} |
|||
|
|||
_iterator.DetermineStatus(iterationNumber, result, source, residuals); |
|||
var status = _iterator.Status; |
|||
|
|||
// We stop if either:
|
|||
// - the user has stopped the calculation
|
|||
// - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
|
|||
return (!status.TerminatesCalculation) && (!_hasBeenStopped); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <returns>The result matrix, <c>X</c>.</returns>
|
|||
public Matrix Solve(Matrix matrix, Matrix input) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
var result = matrix.CreateMatrix(input.RowCount, input.ColumnCount); |
|||
Solve(matrix, input, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <param name="result">The result matrix, <c>X</c></param>
|
|||
public void Solve(Matrix matrix, Matrix input, Matrix result) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (matrix.RowCount != input.RowCount || input.RowCount != result.RowCount || input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
for (var column = 0; column < input.ColumnCount; column++) |
|||
{ |
|||
var solution = Solve(matrix, input.Column(column)); |
|||
foreach (var element in solution.GetIndexedEnumerator()) |
|||
{ |
|||
result.At(element.Key, column, element.Value); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,532 @@ |
|||
// <copyright file="TFQMR.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative |
|||
{ |
|||
using System; |
|||
using Preconditioners; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// A Transpose Free Quasi-Minimal Residual (TFQMR) iterative matrix solver.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The TFQMR algorithm was taken from: <br/>
|
|||
/// Iterative methods for sparse linear systems.
|
|||
/// <br/>
|
|||
/// Yousef Saad
|
|||
/// <br/>
|
|||
/// Algorithm is described in Chapter 7, section 7.4.3, page 219
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The example code below provides an indication of the possible use of the
|
|||
/// solver.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
public sealed class TFQMR : IIterativeSolver |
|||
{ |
|||
/// <summary>
|
|||
/// The status used if there is no status, i.e. the solver hasn't run yet and there is no
|
|||
/// iterator.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
|
|||
/// pre-conditioner will be used.
|
|||
/// </summary>
|
|||
private IPreConditioner _preconditioner; |
|||
|
|||
/// <summary>
|
|||
/// The iterative process controller.
|
|||
/// </summary>
|
|||
private IIterator _iterator; |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the user has stopped the solver.
|
|||
/// </summary>
|
|||
private bool _hasBeenStopped; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TFQMR"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings and a default preconditioner.
|
|||
/// </remarks>
|
|||
public TFQMR() : this(null, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TFQMR"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// When using this constructor the solver will use a default preconditioner.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
|
|||
public TFQMR(IIterator iterator) : this(null, iterator) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TFQMR"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// When using this constructor the solver will use the <see cref="IIterator"/> with
|
|||
/// the standard settings.
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
public TFQMR(IPreConditioner preconditioner) : this(preconditioner, null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TFQMR"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The main advantages of using a user defined <see cref="IIterator"/> are:
|
|||
/// <list type="number">
|
|||
/// <item>It is possible to set the desired convergence limits.</item>
|
|||
/// <item>
|
|||
/// It is possible to check the reason for which the solver finished
|
|||
/// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
|
|||
/// </item>
|
|||
/// </list>
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
|
|||
/// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
|
|||
public TFQMR(IPreConditioner preconditioner, IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="preconditioner">The preconditioner.</param>
|
|||
public void SetPreconditioner(IPreConditioner preconditioner) |
|||
{ |
|||
_preconditioner = preconditioner; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
|
|||
/// </summary>
|
|||
/// <param name="iterator">The iterator.</param>
|
|||
public void SetIterator(IIterator iterator) |
|||
{ |
|||
_iterator = iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the status of the iteration once the calculation is finished.
|
|||
/// </summary>
|
|||
public ICalculationStatus IterationResult |
|||
{ |
|||
get |
|||
{ |
|||
return (_iterator != null) ? _iterator.Status : DefaultStatus; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stops the solve process.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that it may take an indetermined amount of time for the solver to actually stop the process.
|
|||
/// </remarks>
|
|||
public void StopSolve() |
|||
{ |
|||
_hasBeenStopped = true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="vector">The solution vector, <c>b</c>.</param>
|
|||
/// <returns>The result vector, <c>x</c>.</returns>
|
|||
public Vector Solve(Matrix matrix, Vector vector) |
|||
{ |
|||
if (vector == null) |
|||
{ |
|||
throw new ArgumentNullException(); |
|||
} |
|||
|
|||
Vector result = new DenseVector(matrix.RowCount); |
|||
Solve(matrix, vector, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation Ax = b, where A is the coefficient matrix, b is the
|
|||
/// solution vector and x is the unknown vector.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution vector, <c>b</c></param>
|
|||
/// <param name="result">The result vector, <c>x</c></param>
|
|||
public void Solve(Matrix matrix, Vector input, Vector result) |
|||
{ |
|||
// If we were stopped before, we are no longer
|
|||
// We're doing this at the start of the method to ensure
|
|||
// that we can use these fields immediately.
|
|||
_hasBeenStopped = false; |
|||
|
|||
// Error checks
|
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (result.Count != input.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Initialize the solver fields
|
|||
// Set the convergence monitor
|
|||
if (_iterator == null) |
|||
{ |
|||
_iterator = Iterator.CreateDefault(); |
|||
} |
|||
|
|||
if (_preconditioner == null) |
|||
{ |
|||
_preconditioner = new UnitPreconditioner(); |
|||
} |
|||
|
|||
_preconditioner.Initialize(matrix); |
|||
|
|||
var d = new DenseVector(input.Count); |
|||
var r = new DenseVector(input); |
|||
|
|||
var uodd = new DenseVector(input.Count); |
|||
var ueven = new DenseVector(input.Count); |
|||
|
|||
var v = new DenseVector(input.Count); |
|||
var pseudoResiduals = new DenseVector(input); |
|||
|
|||
var x = new DenseVector(input.Count); |
|||
var yodd = new DenseVector(input.Count); |
|||
var yeven = new DenseVector(input); |
|||
|
|||
// Temp vectors
|
|||
var temp = new DenseVector(input.Count); |
|||
var mult = new DenseVector(input.Count); |
|||
|
|||
// Initialize
|
|||
var startNorm = input.Norm(2); |
|||
|
|||
// Define the scalars
|
|||
double alpha = 0; |
|||
double eta = 0; |
|||
double theta = 0; |
|||
|
|||
var tau = startNorm; |
|||
var rho = tau * tau; |
|||
|
|||
// Calculate the initial values for v
|
|||
// M temp = yEven
|
|||
_preconditioner.Approximate(yeven, temp); |
|||
|
|||
// v = A temp
|
|||
matrix.Multiply(temp, v); |
|||
|
|||
// Set uOdd
|
|||
v.CopyTo(ueven); |
|||
|
|||
// Start the iteration
|
|||
var iterationNumber = 0; |
|||
while (ShouldContinue(iterationNumber, result, input, pseudoResiduals)) |
|||
{ |
|||
// First part of the step, the even bit
|
|||
if (IsEven(iterationNumber)) |
|||
{ |
|||
// sigma = (v, r)
|
|||
var sigma = v.DotProduct(r); |
|||
if (sigma.AlmostEqual(0, 1)) |
|||
{ |
|||
// FAIL HERE
|
|||
_iterator.IterationCancelled(); |
|||
break; |
|||
} |
|||
|
|||
// alpha = rho / sigma
|
|||
alpha = rho / sigma; |
|||
|
|||
// yOdd = yEven - alpha * v
|
|||
v.Multiply(-alpha, mult); |
|||
yeven.Add(mult, yodd); |
|||
|
|||
// Solve M temp = yOdd
|
|||
_preconditioner.Approximate(yodd, temp); |
|||
|
|||
// uOdd = A temp
|
|||
matrix.Multiply(temp, uodd); |
|||
} |
|||
|
|||
// The intermediate step which is equal for both even and
|
|||
// odd iteration steps.
|
|||
// Select the correct vector
|
|||
var uinternal = IsEven(iterationNumber) ? ueven : uodd; |
|||
var yinternal = IsEven(iterationNumber) ? yeven : yodd; |
|||
|
|||
// pseudoResiduals = pseudoResiduals - alpha * uOdd
|
|||
uinternal.Multiply(-alpha, mult); |
|||
pseudoResiduals.Add(mult); |
|||
|
|||
// d = yOdd + theta * theta * eta / alpha * d
|
|||
d.Multiply(theta * theta * eta / alpha, temp); |
|||
yinternal.Add(temp, d); |
|||
|
|||
// theta = ||pseudoResiduals||_2 / tau
|
|||
theta = pseudoResiduals.Norm(2) / tau; |
|||
var c = 1 / Math.Sqrt(1 + (theta * theta)); |
|||
|
|||
// tau = tau * theta * c
|
|||
tau *= theta * c; |
|||
|
|||
// eta = c^2 * alpha
|
|||
eta = c * c * alpha; |
|||
|
|||
// x = x + eta * d
|
|||
d.Multiply(eta, mult); |
|||
x.Add(mult); |
|||
|
|||
// Check convergence and see if we can bail
|
|||
if (!ShouldContinue(iterationNumber, result, input, pseudoResiduals)) |
|||
{ |
|||
// Calculate the real values
|
|||
_preconditioner.Approximate(x, result); |
|||
|
|||
// Calculate the true residual. Use the temp vector for that
|
|||
// so that we don't pollute the pseudoResidual vector for no
|
|||
// good reason.
|
|||
CalculateTrueResidual(matrix, temp, result, input); |
|||
|
|||
// Now recheck the convergence
|
|||
if (!ShouldContinue(iterationNumber, result, input, temp)) |
|||
{ |
|||
// We're all good now.
|
|||
return; |
|||
} |
|||
} |
|||
|
|||
// The odd step
|
|||
if (!IsEven(iterationNumber)) |
|||
{ |
|||
if (rho.AlmostEqual(0, 1)) |
|||
{ |
|||
// FAIL HERE
|
|||
_iterator.IterationCancelled(); |
|||
break; |
|||
} |
|||
|
|||
var rhoNew = pseudoResiduals.DotProduct(r); |
|||
var beta = rhoNew / rho; |
|||
|
|||
// Update rho for the next loop
|
|||
rho = rhoNew; |
|||
|
|||
// yOdd = pseudoResiduals + beta * yOdd
|
|||
yodd.Multiply(beta, mult); |
|||
pseudoResiduals.Add(mult, yeven); |
|||
|
|||
// Solve M temp = yOdd
|
|||
_preconditioner.Approximate(yeven, temp); |
|||
|
|||
// uOdd = A temp
|
|||
matrix.Multiply(temp, ueven); |
|||
|
|||
// v = uEven + beta * (uOdd + beta * v)
|
|||
v.Multiply(beta, mult); |
|||
uodd.Add(mult, temp); |
|||
|
|||
temp.Multiply(beta, mult); |
|||
ueven.Add(mult, v); |
|||
} |
|||
|
|||
// Calculate the real values
|
|||
_preconditioner.Approximate(x, result); |
|||
|
|||
iterationNumber++; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates the true residual of the matrix equation Ax = b according to: residual = b - Ax
|
|||
/// </summary>
|
|||
/// <param name="matrix">Instance of the <see cref="Matrix"/> A.</param>
|
|||
/// <param name="residual">Residual values in <see cref="Vector"/>.</param>
|
|||
/// <param name="x">Instance of the <see cref="Vector"/> x.</param>
|
|||
/// <param name="b">Instance of the <see cref="Vector"/> b.</param>
|
|||
private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b) |
|||
{ |
|||
// -Ax = residual
|
|||
matrix.Multiply(x, residual); |
|||
residual.Multiply(-1); |
|||
|
|||
// residual + b
|
|||
residual.Add(b); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determine if calculation should continue
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">Number of iterations passed</param>
|
|||
/// <param name="result">Result <see cref="Vector"/>.</param>
|
|||
/// <param name="source">Source <see cref="Vector"/>.</param>
|
|||
/// <param name="residuals">Residual <see cref="Vector"/>.</param>
|
|||
/// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
|
|||
private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals) |
|||
{ |
|||
if (_hasBeenStopped) |
|||
{ |
|||
_iterator.IterationCancelled(); |
|||
return true; |
|||
} |
|||
|
|||
_iterator.DetermineStatus(iterationNumber, result, source, residuals); |
|||
var status = _iterator.Status; |
|||
|
|||
// We stop if either:
|
|||
// - the user has stopped the calculation
|
|||
// - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
|
|||
return (!status.TerminatesCalculation) && (!_hasBeenStopped); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Is <paramref name="number"/> even?
|
|||
/// </summary>
|
|||
/// <param name="number">Number to check</param>
|
|||
/// <returns><c>true</c> if <paramref name="number"/> even, otherwise <c>false</c></returns>
|
|||
private static bool IsEven(int number) |
|||
{ |
|||
return number % 2 == 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <returns>The result matrix, <c>X</c>.</returns>
|
|||
public Matrix Solve(Matrix matrix, Matrix input) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
var result = matrix.CreateMatrix(input.RowCount, input.ColumnCount); |
|||
Solve(matrix, input, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Solves the matrix equation AX = B, where A is the coefficient matrix, B is the
|
|||
/// solution matrix and X is the unknown matrix.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
|
|||
/// <param name="input">The solution matrix, <c>B</c>.</param>
|
|||
/// <param name="result">The result matrix, <c>X</c></param>
|
|||
public void Solve(Matrix matrix, Matrix input, Matrix result) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (input == null) |
|||
{ |
|||
throw new ArgumentNullException("input"); |
|||
} |
|||
|
|||
if (result == null) |
|||
{ |
|||
throw new ArgumentNullException("result"); |
|||
} |
|||
|
|||
if (matrix.RowCount != input.RowCount || input.RowCount != result.RowCount || input.ColumnCount != result.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
for (var column = 0; column < input.ColumnCount; column++) |
|||
{ |
|||
var solution = Solve(matrix, input.Column(column)); |
|||
foreach (var element in solution.GetIndexedEnumerator()) |
|||
{ |
|||
result.At(element.Key, column, element.Value); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,325 @@ |
|||
// <copyright file="Iterator.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers |
|||
{ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using Properties; |
|||
using Status; |
|||
using StopCriterium; |
|||
|
|||
/// <summary>
|
|||
/// An iterator that is used to check if an iterative calculation should continue or stop.
|
|||
/// </summary>
|
|||
public sealed class Iterator : IIterator |
|||
{ |
|||
/// <summary>
|
|||
/// The default status for the iterator.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// Creates a default iterator with all the <see cref="IIterationStopCriterium"/> objects.
|
|||
/// </summary>
|
|||
/// <returns>A new <see cref="IIterator"/> object.</returns>
|
|||
public static IIterator CreateDefault() |
|||
{ |
|||
var iterator = new Iterator(); |
|||
iterator.Add(new FailureStopCriterium()); |
|||
iterator.Add(new DivergenceStopCriterium()); |
|||
iterator.Add(new IterationCountStopCriterium()); |
|||
iterator.Add(new ResidualStopCriterium()); |
|||
|
|||
return iterator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The collection that holds all the stop criteria and the flag indicating if they should be added
|
|||
/// to the child iterators.
|
|||
/// </summary>
|
|||
private readonly Dictionary<Type, IIterationStopCriterium> _stopCriterias = new Dictionary<Type, IIterationStopCriterium>(); |
|||
|
|||
/// <summary>
|
|||
/// The status of the iterator.
|
|||
/// </summary>
|
|||
private ICalculationStatus _status = DefaultStatus; |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the iteration was cancelled.
|
|||
/// </summary>
|
|||
private bool _wasIterationCancelled; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Iterator"/> class.
|
|||
/// </summary>
|
|||
public Iterator() : this(null) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Iterator"/> class with the specified stop criteria.
|
|||
/// </summary>
|
|||
/// <param name="stopCriteria">
|
|||
/// The specified stop criteria. Only one stop criterium of each type can be passed in. None
|
|||
/// of the stop criteria will be passed on to child iterators.
|
|||
/// </param>
|
|||
/// <exception cref="ArgumentException">Thrown if <paramref name="stopCriteria"/> contains multiple stop criteria of the same type.</exception>
|
|||
public Iterator(IEnumerable<IIterationStopCriterium> stopCriteria) |
|||
{ |
|||
// Add the stop criteria
|
|||
if (stopCriteria == null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
foreach (var stopCriterium in stopCriteria.Where(stopCriterium => stopCriterium != null)) |
|||
{ |
|||
Add(stopCriterium); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Adds an <see cref="IIterationStopCriterium"/> to the internal collection of stop-criteria. Only a
|
|||
/// single stop criterium of each type can be stored.
|
|||
/// </summary>
|
|||
/// <param name="stopCriterium">The stop criterium to add.</param>
|
|||
/// <exception cref="ArgumentNullException">Thrown if <paramref name="stopCriterium"/> is <see langword="null" />.</exception>
|
|||
/// <exception cref="ArgumentException">
|
|||
/// Thrown if <paramref name="stopCriterium"/> is of the same type as an already
|
|||
/// stored criterium.
|
|||
/// </exception>
|
|||
public void Add(IIterationStopCriterium stopCriterium) |
|||
{ |
|||
if (stopCriterium == null) |
|||
{ |
|||
throw new ArgumentNullException("stopCriterium"); |
|||
} |
|||
|
|||
if (_stopCriterias.ContainsKey(stopCriterium.GetType())) |
|||
{ |
|||
throw new ArgumentException(Resources.StopCriteriumDuplicate); |
|||
} |
|||
|
|||
// Store the stop criterium.
|
|||
_stopCriterias.Add(stopCriterium.GetType(), stopCriterium); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Removes the <see cref="IIterationStopCriterium"/> from the internal collection.
|
|||
/// </summary>
|
|||
/// <param name="stopCriterium">The stop criterium that must be removed.</param>
|
|||
public void Remove(IIterationStopCriterium stopCriterium) |
|||
{ |
|||
if (stopCriterium == null) |
|||
{ |
|||
throw new ArgumentNullException("stopCriterium"); |
|||
} |
|||
|
|||
if (!_stopCriterias.ContainsKey(stopCriterium.GetType())) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
// Remove from the collection
|
|||
_stopCriterias.Remove(stopCriterium.GetType()); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Indicates if the specific stop criterium is stored by the <see cref="IIterator"/>.
|
|||
/// </summary>
|
|||
/// <param name="stopCriterium">The stop criterium.</param>
|
|||
/// <returns><c>true</c> if the <see cref="IIterator"/> contains the stop criterium; otherwise <c>false</c>.</returns>
|
|||
public bool Contains(IIterationStopCriterium stopCriterium) |
|||
{ |
|||
return stopCriterium != null && _stopCriterias.ContainsKey(stopCriterium.GetType()); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of stored stop criteria.
|
|||
/// </summary>
|
|||
/// <remarks>Used for testing only.</remarks>
|
|||
internal int NumberOfCriteria |
|||
{ |
|||
get |
|||
{ |
|||
return _stopCriterias.Count; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets an <c>IEnumerator</c> that enumerates over all the stored stop criteria.
|
|||
/// </summary>
|
|||
/// <remarks>Used for testing only.</remarks>
|
|||
internal IEnumerator<IIterationStopCriterium> StoredStopCriteria |
|||
{ |
|||
get |
|||
{ |
|||
return _stopCriterias.Select(criterium => criterium.Value).GetEnumerator(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Indicates to the iterator that the iterative process has been cancelled.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Does not reset the stop-criteria.
|
|||
/// </remarks>
|
|||
public void IterationCancelled() |
|||
{ |
|||
_wasIterationCancelled = true; |
|||
_status = new CalculationCancelled(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <c>IIterator</c>. Result is set into <c>Status</c> field.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual iterators may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
public void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector) |
|||
{ |
|||
if (_stopCriterias.Count == 0) |
|||
{ |
|||
throw new ArgumentException(Resources.StopCriteriumMissing); |
|||
} |
|||
|
|||
if (iterationNumber < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("iterationNumber"); |
|||
} |
|||
|
|||
if (solutionVector == null) |
|||
{ |
|||
throw new ArgumentNullException("solutionVector"); |
|||
} |
|||
|
|||
if (sourceVector == null) |
|||
{ |
|||
throw new ArgumentNullException("sourceVector"); |
|||
} |
|||
|
|||
if (residualVector == null) |
|||
{ |
|||
throw new ArgumentNullException("residualVector"); |
|||
} |
|||
|
|||
// While we're cancelled we don't call on the stop-criteria.
|
|||
if (_wasIterationCancelled) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
foreach (var stopCriterium in _stopCriterias.Select(pair => pair.Value)) |
|||
{ |
|||
stopCriterium.DetermineStatus(iterationNumber, solutionVector, sourceVector, residualVector); |
|||
var status = stopCriterium.Status; |
|||
|
|||
// Check if the status is:
|
|||
// - Running --> keep going
|
|||
// - Indetermined --> keep going
|
|||
// Anything else:
|
|||
// Stop looping and set that status
|
|||
if ((status is CalculationRunning) || (status is CalculationIndetermined)) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
_status = status; |
|||
return; |
|||
} |
|||
|
|||
// Got all the way through
|
|||
// So we're running because we had vectors passed to us.
|
|||
if (!(_status is CalculationRunning)) |
|||
{ |
|||
_status = new CalculationRunning(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
public ICalculationStatus Status |
|||
{ |
|||
get |
|||
{ |
|||
return _status; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the <see cref="IIterator"/> to the pre-calculation state.
|
|||
/// </summary>
|
|||
public void ResetToPrecalculationState() |
|||
{ |
|||
// Indicate that we're no longer cancelled.
|
|||
_wasIterationCancelled = false; |
|||
|
|||
// Reset the status.
|
|||
_status = DefaultStatus; |
|||
|
|||
// Reset the stop-criteria
|
|||
foreach (var stopCriterium in _stopCriterias.Select(pair => pair.Value)) |
|||
{ |
|||
stopCriterium.ResetToPrecalculationState(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Creates a deep clone of the current iterator.
|
|||
/// </summary>
|
|||
/// <returns>The deep clone of the current iterator.</returns>
|
|||
public IIterator Clone() |
|||
{ |
|||
var stopCriteria = _stopCriterias.Select(pair => pair.Value).Select(stopCriterium => (IIterationStopCriterium)stopCriterium.Clone()).ToList(); |
|||
return new Iterator(stopCriteria); |
|||
} |
|||
|
|||
#if !SILVERLIGHT
|
|||
/// <summary>
|
|||
/// Creates a deep clone of the current iterator.
|
|||
/// </summary>
|
|||
/// <returns>The deep clone of the current iterator.</returns>
|
|||
object ICloneable.Clone() |
|||
{ |
|||
return Clone(); |
|||
} |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,148 @@ |
|||
// <copyright file="Diagonal.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// A diagonal preconditioner. The preconditioner uses the inverse
|
|||
/// of the matrix diagonal as preconditioning values.
|
|||
/// </summary>
|
|||
public sealed class Diagonal : IPreConditioner |
|||
{ |
|||
/// <summary>
|
|||
/// The inverse of the matrix diagonal.
|
|||
/// </summary>
|
|||
private double[] _inverseDiagonals; |
|||
|
|||
/// <summary>
|
|||
/// Returns the decomposed matrix diagonal.
|
|||
/// </summary>
|
|||
/// <returns>The matrix diagonal.</returns>
|
|||
internal DiagonalMatrix DiagonalEntries() |
|||
{ |
|||
var result = new DiagonalMatrix(_inverseDiagonals.Length); |
|||
for (var i = 0; i < _inverseDiagonals.Length; i++) |
|||
{ |
|||
result[i, i] = 1 / _inverseDiagonals[i]; |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes the preconditioner and loads the internal data structures.
|
|||
/// </summary>
|
|||
/// <param name="matrix">
|
|||
/// The <see cref="Matrix"/> upon which this preconditioner is based.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <see langword="null" />. </exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not a square matrix.</exception>
|
|||
public void Initialize(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
_inverseDiagonals = new double[matrix.RowCount]; |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
_inverseDiagonals[i] = 1 / matrix[i, i]; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <returns>The left hand side vector.</returns>
|
|||
public Vector Approximate(Vector rhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (_inverseDiagonals == null) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDoesNotExist); |
|||
} |
|||
|
|||
if (rhs.Count != _inverseDiagonals.Length) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "rhs"); |
|||
} |
|||
|
|||
Vector result = new DenseVector(rhs.Count); |
|||
Approximate(rhs, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
|
|||
public void Approximate(Vector rhs, Vector lhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (lhs == null) |
|||
{ |
|||
throw new ArgumentNullException("lhs"); |
|||
} |
|||
|
|||
if (_inverseDiagonals == null) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDoesNotExist); |
|||
} |
|||
|
|||
if ((lhs.Count != rhs.Count) || (lhs.Count != _inverseDiagonals.Length)) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "rhs"); |
|||
} |
|||
|
|||
for (var i = 0; i < _inverseDiagonals.Length; i++) |
|||
{ |
|||
lhs[i] = rhs[i] * _inverseDiagonals[i]; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,73 @@ |
|||
// <copyright file="IPreConditioner.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners |
|||
{ |
|||
/// <summary>
|
|||
/// The base interface for preconditioner classes.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// Preconditioners are used by iterative solvers to improve the convergence
|
|||
/// speed of the solving process. Increase in convergence speed
|
|||
/// is related to the number of iterations necessary to get a converged solution.
|
|||
/// So while in general the use of a preconditioner means that the iterative
|
|||
/// solver will perform fewer iterations it does not guarantee that the actual
|
|||
/// solution time decreases given that some preconditioners can be expensive to
|
|||
/// setup and run.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// Note that in general changes to the matrix will invalidate the preconditioner
|
|||
/// if the changes occur after creating the preconditioner.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
public interface IPreConditioner |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes the preconditioner and loads the internal data structures.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix on which the preconditioner is based.</param>
|
|||
void Initialize(Matrix matrix); |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Mx = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <returns>The left hand side vector.</returns>
|
|||
Vector Approximate(Vector rhs); |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Mx = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
|
|||
void Approximate(Vector rhs, Vector lhs); |
|||
} |
|||
} |
|||
@ -0,0 +1,727 @@ |
|||
// <copyright file="Ilutp.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners |
|||
{ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// This class performs an Incomplete LU factorization with drop tolerance
|
|||
/// and partial pivoting. The drop tolerance indicates which additional entries
|
|||
/// will be dropped from the factorized LU matrices.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The ILUTP-Mem algorithm was taken from: <br/>
|
|||
/// ILUTP_Mem: a Space-Efficient Incomplete LU Preconditioner
|
|||
/// <br/>
|
|||
/// Tzu-Yi Chen, Department of Mathematics and Computer Science, <br/>
|
|||
/// Pomona College, Claremont CA 91711, USA <br/>
|
|||
/// Published in: <br/>
|
|||
/// Lecture Notes in Computer Science <br/>
|
|||
/// Volume 3046 / 2004 <br/>
|
|||
/// pp. 20 - 28 <br/>
|
|||
/// Algorithm is described in Section 2, page 22
|
|||
/// </remarks>
|
|||
public sealed class Ilutp : IPreConditioner |
|||
{ |
|||
/// <summary>
|
|||
/// The default fill level.
|
|||
/// </summary>
|
|||
public const double DefaultFillLevel = 200.0; |
|||
|
|||
/// <summary>
|
|||
/// The default drop tolerance.
|
|||
/// </summary>
|
|||
public const double DefaultDropTolerance = 0.0001; |
|||
|
|||
/// <summary>
|
|||
/// The decomposed upper triangular matrix.
|
|||
/// </summary>
|
|||
private SparseMatrix _upper; |
|||
|
|||
/// <summary>
|
|||
/// The decomposed lower triangular matrix.
|
|||
/// </summary>
|
|||
private SparseMatrix _lower; |
|||
|
|||
/// <summary>
|
|||
/// The array containing the pivot values.
|
|||
/// </summary>
|
|||
private int[] _pivots; |
|||
|
|||
/// <summary>
|
|||
/// The fill level.
|
|||
/// </summary>
|
|||
private double _fillLevel = DefaultFillLevel; |
|||
|
|||
/// <summary>
|
|||
/// The drop tolerance.
|
|||
/// </summary>
|
|||
private double _dropTolerance = DefaultDropTolerance; |
|||
|
|||
/// <summary>
|
|||
/// The pivot tolerance.
|
|||
/// </summary>
|
|||
private double _pivotTolerance; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Ilutp"/> class with the default settings.
|
|||
/// </summary>
|
|||
public Ilutp() |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Ilutp"/> class with the specified settings.
|
|||
/// </summary>
|
|||
/// <param name="fillLevel">
|
|||
/// The amount of fill that is allowed in the matrix. The value is a fraction of
|
|||
/// the number of non-zero entries in the original matrix. Values should be positive.
|
|||
/// </param>
|
|||
/// <param name="dropTolerance">
|
|||
/// The absolute drop tolerance which indicates below what absolute value an entry
|
|||
/// will be dropped from the matrix. A drop tolerance of 0.0 means that no values
|
|||
/// will be dropped. Values should always be positive.
|
|||
/// </param>
|
|||
/// <param name="pivotTolerance">
|
|||
/// The pivot tolerance which indicates at what level pivoting will take place. A
|
|||
/// value of 0.0 means that no pivoting will take place.
|
|||
/// </param>
|
|||
public Ilutp(double fillLevel, double dropTolerance, double pivotTolerance) |
|||
{ |
|||
if (fillLevel < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("fillLevel"); |
|||
} |
|||
|
|||
if (dropTolerance < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("dropTolerance"); |
|||
} |
|||
|
|||
if (pivotTolerance < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("pivotTolerance"); |
|||
} |
|||
|
|||
_fillLevel = fillLevel; |
|||
_dropTolerance = dropTolerance; |
|||
_pivotTolerance = pivotTolerance; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the amount of fill that is allowed in the matrix. The
|
|||
/// value is a fraction of the number of non-zero entries in the original
|
|||
/// matrix. The standard value is 200.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// Values should always be positive and can be higher than 1.0. A value lower
|
|||
/// than 1.0 means that the eventual preconditioner matrix will have fewer
|
|||
/// non-zero entries as the original matrix. A value higher than 1.0 means that
|
|||
/// the eventual preconditioner can have more non-zero values than the original
|
|||
/// matrix.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// Note that any changes to the <b>FillLevel</b> after creating the preconditioner
|
|||
/// will invalidate the created preconditioner and will require a re-initialization of
|
|||
/// the preconditioner.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if a negative value is provided.</exception>
|
|||
public double FillLevel |
|||
{ |
|||
get |
|||
{ |
|||
return _fillLevel; |
|||
} |
|||
|
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("Value"); |
|||
} |
|||
|
|||
_fillLevel = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the absolute drop tolerance which indicates below what absolute value
|
|||
/// an entry will be dropped from the matrix. The standard value is 0.0001.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The values should always be positive and can be larger than 1.0. A low value will
|
|||
/// keep more small numbers in the preconditioner matrix. A high value will remove
|
|||
/// more small numbers from the preconditioner matrix.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// Note that any changes to the <b>DropTolerance</b> after creating the preconditioner
|
|||
/// will invalidate the created preconditioner and will require a re-initialization of
|
|||
/// the preconditioner.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if a negative value is provided.</exception>
|
|||
public double DropTolerance |
|||
{ |
|||
get |
|||
{ |
|||
return _dropTolerance; |
|||
} |
|||
|
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("Value"); |
|||
} |
|||
|
|||
_dropTolerance = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the pivot tolerance which indicates at what level pivoting will
|
|||
/// take place. The standard value is 0.0 which means pivoting will never take place.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// The pivot tolerance is used to calculate if pivoting is necessary. Pivoting
|
|||
/// will take place if any of the values in a row is bigger than the
|
|||
/// diagonal value of that row divided by the pivot tolerance, i.e. pivoting
|
|||
/// will take place if <b>row(i,j) > row(i,i) / PivotTolerance</b> for
|
|||
/// any <b>j</b> that is not equal to <b>i</b>.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// Note that any changes to the <b>PivotTolerance</b> after creating the preconditioner
|
|||
/// will invalidate the created preconditioner and will require a re-initialization of
|
|||
/// the preconditioner.
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if a negative value is provided.</exception>
|
|||
public double PivotTolerance |
|||
{ |
|||
get |
|||
{ |
|||
return _pivotTolerance; |
|||
} |
|||
|
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("Value"); |
|||
} |
|||
|
|||
_pivotTolerance = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the upper triagonal matrix that was created during the LU decomposition.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This method is used for debugging purposes only and should normally not be used.
|
|||
/// </remarks>
|
|||
/// <returns>A new matrix containing the upper triagonal elements.</returns>
|
|||
internal Matrix UpperTriangle() |
|||
{ |
|||
return _upper.Clone(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the lower triagonal matrix that was created during the LU decomposition.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This method is used for debugging purposes only and should normally not be used.
|
|||
/// </remarks>
|
|||
/// <returns>A new matrix containing the lower triagonal elements.</returns>
|
|||
internal Matrix LowerTriangle() |
|||
{ |
|||
return _lower.Clone(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the pivot array. This array is not needed for normal use because
|
|||
/// the preconditioner will return the solution vector values in the proper order.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This method is used for debugging purposes only and should normally not be used.
|
|||
/// </remarks>
|
|||
/// <returns>The pivot array.</returns>
|
|||
internal int[] Pivots() |
|||
{ |
|||
var result = new int[_pivots.Length]; |
|||
for (var i = 0; i < _pivots.Length; i++) |
|||
{ |
|||
result[i] = _pivots[i]; |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes the preconditioner and loads the internal data structures.
|
|||
/// </summary>
|
|||
/// <param name="matrix">
|
|||
/// The <see cref="Matrix"/> upon which this preconditioner is based. Note that the
|
|||
/// method takes a general matrix type. However internally the data is stored
|
|||
/// as a sparse matrix. Therefore it is not recommended to pass a dense matrix.
|
|||
/// </param>
|
|||
/// <exception cref="ArgumentNullException"> If <paramref name="matrix"/> is <see langword="null" />.</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not a square matrix.</exception>
|
|||
public void Initialize(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
var sparseMatrix = (matrix is SparseMatrix) ? matrix as SparseMatrix : new SparseMatrix(matrix.ToArray()); |
|||
|
|||
// The creation of the preconditioner follows the following algorithm.
|
|||
// spaceLeft = lfilNnz * nnz(A)
|
|||
// for i = 1, .. , n
|
|||
// {
|
|||
// w = a(i,*)
|
|||
// for j = 1, .. , i - 1
|
|||
// {
|
|||
// if (w(j) != 0)
|
|||
// {
|
|||
// w(j) = w(j) / a(j,j)
|
|||
// if (w(j) < dropTol)
|
|||
// {
|
|||
// w(j) = 0;
|
|||
// }
|
|||
// if (w(j) != 0)
|
|||
// {
|
|||
// w = w - w(j) * U(j,*)
|
|||
// }
|
|||
// }
|
|||
// }
|
|||
//
|
|||
// for j = i, .. ,n
|
|||
// {
|
|||
// if w(j) <= dropTol * ||A(i,*)||
|
|||
// {
|
|||
// w(j) = 0
|
|||
// }
|
|||
// }
|
|||
//
|
|||
// spaceRow = spaceLeft / (n - i + 1) // Determine the space for this row
|
|||
// lfil = spaceRow / 2 // space for this row of L
|
|||
// l(i,j) = w(j) for j = 1, .. , i -1 // only the largest lfil elements
|
|||
//
|
|||
// lfil = spaceRow - nnz(L(i,:)) // space for this row of U
|
|||
// u(i,j) = w(j) for j = i, .. , n // only the largest lfil - 1 elements
|
|||
// w = 0
|
|||
//
|
|||
// if max(U(i,i + 1: n)) > U(i,i) / pivTol then // pivot if necessary
|
|||
// {
|
|||
// pivot by swapping the max and the diagonal entries
|
|||
// Update L, U
|
|||
// Update P
|
|||
// }
|
|||
// spaceLeft = spaceLeft - nnz(L(i,:)) - nnz(U(i,:))
|
|||
// }
|
|||
// Create the lower triangular matrix
|
|||
_lower = new SparseMatrix(sparseMatrix.RowCount); |
|||
|
|||
// Create the upper triangular matrix and copy the values
|
|||
_upper = new SparseMatrix(sparseMatrix.RowCount); |
|||
|
|||
// Create the pivot array
|
|||
_pivots = new int[sparseMatrix.RowCount]; |
|||
for (var i = 0; i < _pivots.Length; i++) |
|||
{ |
|||
_pivots[i] = i; |
|||
} |
|||
|
|||
Vector workVector = new DenseVector(sparseMatrix.RowCount); |
|||
Vector rowVector = new DenseVector(sparseMatrix.ColumnCount); |
|||
var indexSorting = new int[sparseMatrix.RowCount]; |
|||
|
|||
// spaceLeft = lfilNnz * nnz(A)
|
|||
var spaceLeft = (int)_fillLevel * sparseMatrix.NonZerosCount; |
|||
|
|||
// for i = 1, .. , n
|
|||
for (var i = 0; i < sparseMatrix.RowCount; i++) |
|||
{ |
|||
// w = a(i,*)
|
|||
sparseMatrix.Row(i, workVector); |
|||
|
|||
// pivot the row
|
|||
PivotRow(workVector); |
|||
var vectorNorm = workVector.Norm(Double.PositiveInfinity); |
|||
|
|||
// for j = 1, .. , i - 1)
|
|||
for (var j = 0; j < i; j++) |
|||
{ |
|||
// if (w(j) != 0)
|
|||
// {
|
|||
// w(j) = w(j) / a(j,j)
|
|||
// if (w(j) < dropTol)
|
|||
// {
|
|||
// w(j) = 0;
|
|||
// }
|
|||
// if (w(j) != 0)
|
|||
// {
|
|||
// w = w - w(j) * U(j,*)
|
|||
// }
|
|||
if (workVector[j] != 0.0) |
|||
{ |
|||
// Calculate the multiplication factors that go into the L matrix
|
|||
workVector[j] = workVector[j] / _upper[j, j]; |
|||
if (Math.Abs(workVector[j]) < _dropTolerance) |
|||
{ |
|||
workVector[j] = 0.0; |
|||
} |
|||
|
|||
// Calculate the addition factor
|
|||
if (workVector[j] != 0.0) |
|||
{ |
|||
// vector update all in one go
|
|||
_upper.Row(j, rowVector); |
|||
|
|||
// zero out columnVector[k] because we don't need that
|
|||
// one anymore for k = 0 to k = j
|
|||
for (var k = 0; k <= j; k++) |
|||
{ |
|||
rowVector[k] = 0.0; |
|||
} |
|||
|
|||
rowVector.Multiply(workVector[j]); |
|||
workVector.Subtract(rowVector); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// for j = i, .. ,n
|
|||
for (var j = i; j < sparseMatrix.RowCount; j++) |
|||
{ |
|||
// if w(j) <= dropTol * ||A(i,*)||
|
|||
// {
|
|||
// w(j) = 0
|
|||
// }
|
|||
if (Math.Abs(workVector[j]) <= _dropTolerance * vectorNorm) |
|||
{ |
|||
workVector[j] = 0.0; |
|||
} |
|||
} |
|||
|
|||
// spaceRow = spaceLeft / (n - i + 1) // Determine the space for this row
|
|||
var spaceRow = spaceLeft / (sparseMatrix.RowCount - i + 1); |
|||
|
|||
// lfil = spaceRow / 2 // space for this row of L
|
|||
var fillLevel = spaceRow / 2; |
|||
FindLargestItems(0, i - 1, indexSorting, workVector); |
|||
|
|||
// l(i,j) = w(j) for j = 1, .. , i -1 // only the largest lfil elements
|
|||
var lowerNonZeroCount = 0; |
|||
var count = 0; |
|||
for (var j = 0; j < i; j++) |
|||
{ |
|||
if ((count > fillLevel) || (indexSorting[j] == -1)) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
_lower[i, indexSorting[j]] = workVector[indexSorting[j]]; |
|||
count += 1; |
|||
lowerNonZeroCount += 1; |
|||
} |
|||
|
|||
FindLargestItems(i + 1, sparseMatrix.RowCount - 1, indexSorting, workVector); |
|||
|
|||
// lfil = spaceRow - nnz(L(i,:)) // space for this row of U
|
|||
fillLevel = spaceRow - lowerNonZeroCount; |
|||
|
|||
// u(i,j) = w(j) for j = i + 1, .. , n // only the largest lfil - 1 elements
|
|||
var upperNonZeroCount = 0; |
|||
count = 0; |
|||
for (var j = 0; j < sparseMatrix.RowCount - i; j++) |
|||
{ |
|||
if ((count > fillLevel - 1) || (indexSorting[j] == -1)) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
_upper[i, indexSorting[j]] = workVector[indexSorting[j]]; |
|||
count += 1; |
|||
upperNonZeroCount += 1; |
|||
} |
|||
|
|||
// Simply copy the diagonal element. Next step is to see if we pivot
|
|||
_upper[i, i] = workVector[i]; |
|||
|
|||
// if max(U(i,i + 1: n)) > U(i,i) / pivTol then // pivot if necessary
|
|||
// {
|
|||
// pivot by swapping the max and the diagonal entries
|
|||
// Update L, U
|
|||
// Update P
|
|||
// }
|
|||
|
|||
// Check if we really need to pivot. If (i+1) >=(mCoefficientMatrix.Rows -1) then
|
|||
// we are working on the last row. That means that there is only one number
|
|||
// And pivoting is useless. Also the indexSorting array will only contain
|
|||
// -1 values.
|
|||
if ((i + 1) < (sparseMatrix.RowCount - 1)) |
|||
{ |
|||
if (Math.Abs(workVector[i]) < _pivotTolerance * Math.Abs(workVector[indexSorting[0]])) |
|||
{ |
|||
// swap columns of u (which holds the values of A in the
|
|||
// sections that haven't been partitioned yet.
|
|||
SwapColumns(_upper, i, indexSorting[0]); |
|||
|
|||
// Update P
|
|||
var temp = _pivots[i]; |
|||
_pivots[i] = _pivots[indexSorting[0]]; |
|||
_pivots[indexSorting[0]] = temp; |
|||
} |
|||
} |
|||
|
|||
// spaceLeft = spaceLeft - nnz(L(i,:)) - nnz(U(i,:))
|
|||
spaceLeft -= lowerNonZeroCount + upperNonZeroCount; |
|||
} |
|||
|
|||
for (var i = 0; i < _lower.RowCount; i++) |
|||
{ |
|||
_lower[i, i] = 1.0; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Pivot elements in the <paramref name="row"/> according to internal pivot array
|
|||
/// </summary>
|
|||
/// <param name="row">Row <see cref="Vector"/> to pivot in</param>
|
|||
private void PivotRow(Vector row) |
|||
{ |
|||
var knownPivots = new Dictionary<int, int>(); |
|||
|
|||
// pivot the row
|
|||
for (var i = 0; i < row.Count; i++) |
|||
{ |
|||
if ((_pivots[i] != i) && (!PivotMapFound(knownPivots, i))) |
|||
{ |
|||
// store the pivots in the hashtable
|
|||
knownPivots.Add(_pivots[i], i); |
|||
|
|||
var t = row[i]; |
|||
row[i] = row[_pivots[i]]; |
|||
row[_pivots[i]] = t; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Was pivoting already performed
|
|||
/// </summary>
|
|||
/// <param name="knownPivots">Pivots already done</param>
|
|||
/// <param name="currentItem">Current item to pivot</param>
|
|||
/// <returns><c>true</c> if performed, otherwise <c>false</c></returns>
|
|||
private bool PivotMapFound(Dictionary<int, int> knownPivots, int currentItem) |
|||
{ |
|||
if (knownPivots.ContainsKey(_pivots[currentItem])) |
|||
{ |
|||
if (knownPivots[_pivots[currentItem]].Equals(currentItem)) |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
if (knownPivots.ContainsKey(currentItem)) |
|||
{ |
|||
if (knownPivots[currentItem].Equals(_pivots[currentItem])) |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Swap columns in the <see cref="Matrix"/>
|
|||
/// </summary>
|
|||
/// <param name="matrix">Source <see cref="Matrix"/>.</param>
|
|||
/// <param name="firstColumn">First column index to swap</param>
|
|||
/// <param name="secondColumn">Second column index to swap</param>
|
|||
private static void SwapColumns(Matrix matrix, int firstColumn, int secondColumn) |
|||
{ |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
var temp = matrix[i, firstColumn]; |
|||
matrix[i, firstColumn] = matrix[i, secondColumn]; |
|||
matrix[i, secondColumn] = temp; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sort vector descending, not changing vector but placing sorted indicies to <paramref name="sortedIndices"/>
|
|||
/// </summary>
|
|||
/// <param name="lowerBound">Start sort form</param>
|
|||
/// <param name="upperBound">Sort till upper bound</param>
|
|||
/// <param name="sortedIndices">Array with sorted vector indicies</param>
|
|||
/// <param name="values">Source <see cref="Vector"/></param>
|
|||
private static void FindLargestItems(int lowerBound, int upperBound, int[] sortedIndices, Vector values) |
|||
{ |
|||
// Copy the indices for the values into the array
|
|||
for (var i = 0; i < upperBound + 1 - lowerBound; i++) |
|||
{ |
|||
sortedIndices[i] = lowerBound + i; |
|||
} |
|||
|
|||
for (var i = upperBound + 1 - lowerBound; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = -1; |
|||
} |
|||
|
|||
// Sort the first set of items.
|
|||
// Sorting starts at index 0 because the index array
|
|||
// starts at zero
|
|||
// and ends at index upperBound - lowerBound
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, upperBound - lowerBound, sortedIndices, values); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <returns>The left hand side vector.</returns>
|
|||
public Vector Approximate(Vector rhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (_upper == null) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDoesNotExist); |
|||
} |
|||
|
|||
if (rhs.Count != _upper.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "rhs"); |
|||
} |
|||
|
|||
Vector result = new DenseVector(rhs.Count); |
|||
Approximate(rhs, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
|
|||
public void Approximate(Vector rhs, Vector lhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (lhs == null) |
|||
{ |
|||
throw new ArgumentNullException("lhs"); |
|||
} |
|||
|
|||
if (_upper == null) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDoesNotExist); |
|||
} |
|||
|
|||
if ((lhs.Count != rhs.Count) || (lhs.Count != _upper.RowCount)) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "rhs"); |
|||
} |
|||
|
|||
// Solve equation here
|
|||
// Pivot(vector, result);
|
|||
// Solve L*Y = B(piv,:)
|
|||
Vector rowValues = new DenseVector(_lower.RowCount); |
|||
for (var i = 0; i < _lower.RowCount; i++) |
|||
{ |
|||
_lower.Row(i, rowValues); |
|||
|
|||
var sum = 0.0; |
|||
for (var j = 0; j < i; j++) |
|||
{ |
|||
sum += rowValues[j] * lhs[j]; |
|||
} |
|||
|
|||
lhs[i] = rhs[i] - sum; |
|||
} |
|||
|
|||
// Solve U*X = Y;
|
|||
for (var i = _upper.RowCount - 1; i > -1; i--) |
|||
{ |
|||
_upper.Row(i, rowValues); |
|||
|
|||
var sum = 0.0; |
|||
for (var j = _upper.RowCount - 1; j > i; j--) |
|||
{ |
|||
sum += rowValues[j] * lhs[j]; |
|||
} |
|||
|
|||
lhs[i] = 1 / rowValues[i] * (lhs[i] - sum); |
|||
} |
|||
|
|||
// We have a column pivot so we only need to pivot the
|
|||
// end result not the incoming right hand side vector
|
|||
var temp = lhs.Clone(); |
|||
|
|||
Pivot(temp, lhs); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Pivot elements in <see cref="Vector"/> accoring to internal pivot array
|
|||
/// </summary>
|
|||
/// <param name="vector">Source <see cref="Vector"/>.</param>
|
|||
/// <param name="result">Result <see cref="Vector"/> after pivoting.</param>
|
|||
private void Pivot(Vector vector, Vector result) |
|||
{ |
|||
for (var i = 0; i < _pivots.Length; i++) |
|||
{ |
|||
result[i] = vector[_pivots[i]]; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,225 @@ |
|||
// <copyright file="IlutpElementSorter.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners |
|||
{ |
|||
/// <summary>
|
|||
/// An element sort algorithm for the <see cref="Ilutp"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This sort algorithm is used to sort the columns in a sparse matrix based on
|
|||
/// the value of the element on the diagonal of the matrix.
|
|||
/// </remarks>
|
|||
internal class IlutpElementSorter |
|||
{ |
|||
/// <summary>
|
|||
/// Sorts the elements of the <paramref name="values"/> vector in decreasing
|
|||
/// fashion. The vector itself is not affected.
|
|||
/// </summary>
|
|||
/// <param name="lowerBound">The starting index.</param>
|
|||
/// <param name="upperBound">The stopping index.</param>
|
|||
/// <param name="sortedIndices">An array that will contain the sorted indices once the algorithm finishes.</param>
|
|||
/// <param name="values">The <see cref="Vector"/> that contains the values that need to be sorted.</param>
|
|||
public static void SortDoubleIndicesDecreasing(int lowerBound, int upperBound, int[] sortedIndices, Vector values) |
|||
{ |
|||
// Move all the indices that we're interested in to the beginning of the
|
|||
// array. Ignore the rest of the indices.
|
|||
if (lowerBound > 0) |
|||
{ |
|||
for (var i = 0; i < (upperBound - lowerBound + 1); i++) |
|||
{ |
|||
Exchange(sortedIndices, i, i + lowerBound); |
|||
} |
|||
|
|||
upperBound -= lowerBound; |
|||
lowerBound = 0; |
|||
} |
|||
|
|||
HeapSortDoublesIndices(lowerBound, upperBound, sortedIndices, values); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sorts the elements of the <paramref name="values"/> vector in decreasing
|
|||
/// fashion using heap sort algorithm. The vector itself is not affected.
|
|||
/// </summary>
|
|||
/// <param name="lowerBound">The starting index.</param>
|
|||
/// <param name="upperBound">The stopping index.</param>
|
|||
/// <param name="sortedIndices">An array that will contain the sorted indices once the algorithm finishes.</param>
|
|||
/// <param name="values">The <see cref="Vector"/> that contains the values that need to be sorted.</param>
|
|||
private static void HeapSortDoublesIndices(int lowerBound, int upperBound, int[] sortedIndices, Vector values) |
|||
{ |
|||
var start = ((upperBound - lowerBound + 1) / 2) - 1 + lowerBound; |
|||
var end = (upperBound - lowerBound + 1) - 1 + lowerBound; |
|||
|
|||
BuildDoubleIndexHeap(start, upperBound - lowerBound + 1, sortedIndices, values); |
|||
|
|||
while (end >= lowerBound) |
|||
{ |
|||
Exchange(sortedIndices, end, lowerBound); |
|||
SiftDoubleIndices(sortedIndices, values, lowerBound, end); |
|||
end -= 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Build heap for double indicies
|
|||
/// </summary>
|
|||
/// <param name="start">Root position</param>
|
|||
/// <param name="count">Lenght of <paramref name="values"/></param>
|
|||
/// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
|
|||
/// <param name="values">Target <see cref="Vector"/></param>
|
|||
private static void BuildDoubleIndexHeap(int start, int count, int[] sortedIndices, Vector values) |
|||
{ |
|||
while (start >= 0) |
|||
{ |
|||
SiftDoubleIndices(sortedIndices, values, start, count); |
|||
start -= 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sift double indicies
|
|||
/// </summary>
|
|||
/// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
|
|||
/// <param name="values">Target <see cref="Vector"/></param>
|
|||
/// <param name="begin">Root position</param>
|
|||
/// <param name="count">Lenght of <paramref name="values"/></param>
|
|||
private static void SiftDoubleIndices(int[] sortedIndices, Vector values, int begin, int count) |
|||
{ |
|||
var root = begin; |
|||
int child; |
|||
|
|||
while (root * 2 < count) |
|||
{ |
|||
child = root * 2; |
|||
if ((child < count - 1) && (values[sortedIndices[child]] > values[sortedIndices[child + 1]])) |
|||
{ |
|||
child += 1; |
|||
} |
|||
|
|||
if (values[sortedIndices[root]] <= values[sortedIndices[child]]) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
Exchange(sortedIndices, root, child); |
|||
root = child; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sorts the given integers in a decreasing fashion.
|
|||
/// </summary>
|
|||
/// <param name="values">The values.</param>
|
|||
public static void SortIntegersDecreasing(int[] values) |
|||
{ |
|||
HeapSortIntegers(values, values.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sort the given integers in a decreasing fashion using heapsort algorithm
|
|||
/// </summary>
|
|||
/// <param name="values">Array of values to sort</param>
|
|||
/// <param name="count">Length of <paramref name="values"/></param>
|
|||
private static void HeapSortIntegers(int[] values, int count) |
|||
{ |
|||
var start = (count / 2) - 1; |
|||
var end = count - 1; |
|||
|
|||
BuildHeap(values, start, count); |
|||
|
|||
while (end >= 0) |
|||
{ |
|||
Exchange(values, end, 0); |
|||
Sift(values, 0, end); |
|||
end -= 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Build heap
|
|||
/// </summary>
|
|||
/// <param name="values">Target values array</param>
|
|||
/// <param name="start">Root position</param>
|
|||
/// <param name="count">Lenght of <paramref name="values"/></param>
|
|||
private static void BuildHeap(int[] values, int start, int count) |
|||
{ |
|||
while (start >= 0) |
|||
{ |
|||
Sift(values, start, count); |
|||
start -= 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sift values
|
|||
/// </summary>
|
|||
/// <param name="values">Target value array</param>
|
|||
/// <param name="start">Root position</param>
|
|||
/// <param name="count">Lenght of <paramref name="values"/></param>
|
|||
private static void Sift(int[] values, int start, int count) |
|||
{ |
|||
var root = start; |
|||
int child; |
|||
|
|||
while (root * 2 < count) |
|||
{ |
|||
child = root * 2; |
|||
if ((child < count - 1) && (values[child] > values[child + 1])) |
|||
{ |
|||
child += 1; |
|||
} |
|||
|
|||
if (values[root] > values[child]) |
|||
{ |
|||
Exchange(values, root, child); |
|||
root = child; |
|||
} |
|||
else |
|||
{ |
|||
return; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Exchange values in array
|
|||
/// </summary>
|
|||
/// <param name="values">Target values array</param>
|
|||
/// <param name="first">First value to exchanghe</param>
|
|||
/// <param name="second">Second value to exchanghe</param>
|
|||
private static void Exchange(int[] values, int first, int second) |
|||
{ |
|||
var t = values[first]; |
|||
values[first] = values[second]; |
|||
values[second] = t; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,258 @@ |
|||
// <copyright file="IncompleteLU.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// An incomplete, level 0, LU factorization preconditioner.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The ILU(0) algorithm was taken from: <br/>
|
|||
/// Iterative methods for sparse linear systems <br/>
|
|||
/// Yousef Saad <br/>
|
|||
/// Algorithm is described in Chapter 10, section 10.3.2, page 275 <br/>
|
|||
/// </remarks>
|
|||
public sealed class IncompleteLU : IPreConditioner |
|||
{ |
|||
/// <summary>
|
|||
/// The matrix holding the lower (L) and upper (U) matrices. The
|
|||
/// decomposition matrices are combined to reduce storage.
|
|||
/// </summary>
|
|||
private SparseMatrix _decompositionLU; |
|||
|
|||
/// <summary>
|
|||
/// Returns the upper triagonal matrix that was created during the LU decomposition.
|
|||
/// </summary>
|
|||
/// <returns>A new matrix containing the upper triagonal elements.</returns>
|
|||
internal Matrix UpperTriangle() |
|||
{ |
|||
var result = new SparseMatrix(_decompositionLU.RowCount); |
|||
for (var i = 0; i < _decompositionLU.RowCount; i++) |
|||
{ |
|||
for (var j = i; j < _decompositionLU.ColumnCount; j++) |
|||
{ |
|||
result[i, j] = _decompositionLU[i, j]; |
|||
} |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the lower triagonal matrix that was created during the LU decomposition.
|
|||
/// </summary>
|
|||
/// <returns>A new matrix containing the lower triagonal elements.</returns>
|
|||
internal Matrix LowerTriangle() |
|||
{ |
|||
var result = new SparseMatrix(_decompositionLU.RowCount); |
|||
for (var i = 0; i < _decompositionLU.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j <= i; j++) |
|||
{ |
|||
if (i == j) |
|||
{ |
|||
result[i, j] = 1.0; |
|||
} |
|||
else |
|||
{ |
|||
result[i, j] = _decompositionLU[i, j]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes the preconditioner and loads the internal data structures.
|
|||
/// </summary>
|
|||
/// <param name="matrix">The matrix upon which the preconditioner is based. </param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <see langword="null" />.</exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not a square matrix.</exception>
|
|||
public void Initialize(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
_decompositionLU = new SparseMatrix(matrix.ToArray()); |
|||
|
|||
// M == A
|
|||
// for i = 2, ... , n do
|
|||
// for k = 1, .... , i - 1 do
|
|||
// if (i,k) == NZ(Z) then
|
|||
// compute z(i,k) = z(i,k) / z(k,k);
|
|||
// for j = k + 1, ...., n do
|
|||
// if (i,j) == NZ(Z) then
|
|||
// compute z(i,j) = z(i,j) - z(i,k) * z(k,j)
|
|||
// end
|
|||
// end
|
|||
// end
|
|||
// end
|
|||
// end
|
|||
for (var i = 0; i < _decompositionLU.RowCount; i++) |
|||
{ |
|||
for (var k = 0; k < i; k++) |
|||
{ |
|||
if (_decompositionLU[i, k] != 0.0) |
|||
{ |
|||
var t = _decompositionLU[i, k] / _decompositionLU[k, k]; |
|||
_decompositionLU[i, k] = t; |
|||
if (_decompositionLU[k, i] != 0.0) |
|||
{ |
|||
_decompositionLU[i, i] = _decompositionLU[i, i] - (t * _decompositionLU[k, i]); |
|||
} |
|||
|
|||
for (var j = k + 1; j < _decompositionLU.RowCount; j++) |
|||
{ |
|||
if (j == i) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
if (_decompositionLU[i, j] != 0.0) |
|||
{ |
|||
_decompositionLU[i, j] = _decompositionLU[i, j] - (t * _decompositionLU[k, j]); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <returns>The left hand side vector.</returns>
|
|||
public Vector Approximate(Vector rhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (_decompositionLU == null) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDoesNotExist); |
|||
} |
|||
|
|||
if (rhs.Count != _decompositionLU.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "rhs"); |
|||
} |
|||
|
|||
Vector result = new DenseVector(rhs.Count); |
|||
Approximate(rhs, result); |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
|
|||
public void Approximate(Vector rhs, Vector lhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (lhs == null) |
|||
{ |
|||
throw new ArgumentNullException("lhs"); |
|||
} |
|||
|
|||
if (_decompositionLU == null) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDoesNotExist); |
|||
} |
|||
|
|||
if ((lhs.Count != rhs.Count) || (lhs.Count != _decompositionLU.RowCount)) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
// Solve:
|
|||
// Lz = y
|
|||
// Which gives
|
|||
// for (int i = 1; i < matrix.RowLength; i++)
|
|||
// {
|
|||
// z_i = l_ii^-1 * (y_i - SUM_(j<i) l_ij * z_j)
|
|||
// }
|
|||
// NOTE: l_ii should be 1 because u_ii has to be the value
|
|||
Vector rowValues = new DenseVector(_decompositionLU.RowCount); |
|||
for (var i = 0; i < _decompositionLU.RowCount; i++) |
|||
{ |
|||
// Clear the rowValues
|
|||
rowValues.Clear(); |
|||
_decompositionLU.Row(i, rowValues); |
|||
|
|||
var sum = 0.0; |
|||
for (var j = 0; j < i; j++) |
|||
{ |
|||
sum += rowValues[j] * lhs[j]; |
|||
} |
|||
|
|||
lhs[i] = rhs[i] - sum; |
|||
} |
|||
|
|||
// Solve:
|
|||
// Ux = z
|
|||
// Which gives
|
|||
// for (int i = matrix.RowLength - 1; i > -1; i--)
|
|||
// {
|
|||
// x_i = u_ii^-1 * (z_i - SUM_(j > i) u_ij * x_j)
|
|||
// }
|
|||
for (var i = _decompositionLU.RowCount - 1; i > -1; i--) |
|||
{ |
|||
_decompositionLU.Row(i, rowValues); |
|||
|
|||
var sum = 0.0; |
|||
for (var j = _decompositionLU.RowCount - 1; j > i; j--) |
|||
{ |
|||
sum += rowValues[j] * lhs[j]; |
|||
} |
|||
|
|||
lhs[i] = 1 / rowValues[i] * (lhs[i] - sum); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,136 @@ |
|||
// <copyright file="UnitPreconditioner.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners |
|||
{ |
|||
using System; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// A unit preconditioner. This preconditioner does not actually do anything
|
|||
/// it is only used when running an <see cref="IIterativeSolver"/> without
|
|||
/// a preconditioner.
|
|||
/// </summary>
|
|||
internal sealed class UnitPreconditioner : IPreConditioner |
|||
{ |
|||
/// <summary>
|
|||
/// The coefficient matrix on which this preconditioner operates.
|
|||
/// Is used to check dimensions on the different vectors that are processed.
|
|||
/// </summary>
|
|||
private int _size; |
|||
|
|||
/// <summary>
|
|||
/// Initializes the preconditioner and loads the internal data structures.
|
|||
/// </summary>
|
|||
/// <param name="matrix">
|
|||
/// The matrix upon which the preconditioner is based.
|
|||
/// </param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <see langword="null"/>. </exception>
|
|||
/// <exception cref="ArgumentException">If <paramref name="matrix"/> is not a square matrix.</exception>
|
|||
public void Initialize(Matrix matrix) |
|||
{ |
|||
if (matrix == null) |
|||
{ |
|||
throw new ArgumentNullException("matrix"); |
|||
} |
|||
|
|||
if (matrix.RowCount != matrix.ColumnCount) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixSquare, "matrix"); |
|||
} |
|||
|
|||
_size = matrix.RowCount; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="rhs"/> is <see langword="null"/>.</exception>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="lhs"/> is <see langword="null"/>. </exception>
|
|||
/// <exception cref="ArgumentException">
|
|||
/// <para>
|
|||
/// If <paramref name="rhs"/> and <paramref name="lhs"/> do not have the same size.
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// - or -
|
|||
/// </para>
|
|||
/// <para>
|
|||
/// If the size of <paramref name="rhs"/> is different the number of rows of the coefficient matrix.
|
|||
/// </para>
|
|||
/// </exception>
|
|||
public void Approximate(Vector rhs, Vector lhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (lhs == null) |
|||
{ |
|||
throw new ArgumentNullException("lhs"); |
|||
} |
|||
|
|||
if ((lhs.Count != rhs.Count) || (lhs.Count != _size)) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength); |
|||
} |
|||
|
|||
rhs.CopyTo(lhs); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Approximates the solution to the matrix equation <b>Ax = b</b>.
|
|||
/// </summary>
|
|||
/// <param name="rhs">The right hand side vector.</param>
|
|||
/// <returns>The left hand side vector.</returns>
|
|||
/// <exception cref="ArgumentNullException">If <paramref name="rhs"/> is <see langword="null"/>. </exception>
|
|||
/// <exception cref="ArgumentException">
|
|||
/// If the size of <paramref name="rhs"/> is different the number of rows of the coefficient matrix.
|
|||
/// </exception>
|
|||
public Vector Approximate(Vector rhs) |
|||
{ |
|||
if (rhs == null) |
|||
{ |
|||
throw new ArgumentNullException("rhs"); |
|||
} |
|||
|
|||
if (rhs.Count != _size) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentMatrixDimensions); |
|||
} |
|||
|
|||
Vector result = new DenseVector(rhs.Count); |
|||
Approximate(rhs, result); |
|||
return result; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,49 @@ |
|||
// <copyright file="CalculationCancelled.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that a calculation was cancelled by the user.
|
|||
/// </summary>
|
|||
public struct CalculationCancelled : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,51 @@ |
|||
// <copyright file="CalculationConverged.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that a calculation has converged to the desired convergence levels.
|
|||
/// </summary>
|
|||
public struct CalculationConverged : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
// TODO: CalculationConverged: Should we put the achieved residuals and convergence levels on here?
|
|||
} |
|||
} |
|||
@ -0,0 +1,51 @@ |
|||
// <copyright file="CalculationDiverged.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that the calculation diverged.
|
|||
/// </summary>
|
|||
public struct CalculationDiverged : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
// TODO: CalculationDiverged - Should we put the residuals on here?
|
|||
} |
|||
} |
|||
@ -0,0 +1,51 @@ |
|||
// <copyright file="CalculationFailure.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that a calculation has failed for some reason.
|
|||
/// </summary>
|
|||
public struct CalculationFailure : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
// TODO: CalcuationFailure - Indicate why the calculation has failed?
|
|||
} |
|||
} |
|||
@ -0,0 +1,49 @@ |
|||
// <copyright file="CalculationIndetermined.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that the state of the calculation is indetermined, not started or stopped.
|
|||
/// </summary>
|
|||
public struct CalculationIndetermined : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,51 @@ |
|||
// <copyright file="CalculationRunning.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that the calculation is running and no results are yet known.
|
|||
/// </summary>
|
|||
public struct CalculationRunning : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
// TODO: CalculationRunning - Get current residuals?
|
|||
} |
|||
} |
|||
@ -0,0 +1,52 @@ |
|||
// <copyright file="CalculationStoppedWithoutConvergence.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates that the calculation has been stopped due to reaching the stopping
|
|||
/// limits, but that convergence was not achieved.
|
|||
/// </summary>
|
|||
public struct CalculationStoppedWithoutConvergence : ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
public bool TerminatesCalculation |
|||
{ |
|||
get |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
// TODO: Indicate which stopping limit was reached?
|
|||
} |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
// <copyright file="ICalculationStatus.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Status |
|||
{ |
|||
/// <summary>
|
|||
/// Defines the base interface for calculation status objects.
|
|||
/// </summary>
|
|||
public interface ICalculationStatus |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether current status warrants stopping the calculation.
|
|||
/// </summary>
|
|||
bool TerminatesCalculation { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,391 @@ |
|||
// <copyright file="DivergenceStopCriterium.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium |
|||
{ |
|||
using System; |
|||
using System.Diagnostics; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// Monitors an iterative calculation for signs of divergence.
|
|||
/// </summary>
|
|||
public sealed class DivergenceStopCriterium : IIterationStopCriterium |
|||
{ |
|||
/// <summary>
|
|||
/// Default value for the maximum relative increase that the
|
|||
/// residual may experience before a divergence warning is issued.
|
|||
/// </summary>
|
|||
public const double DefaultMaximumRelativeIncrease = 0.08; |
|||
|
|||
/// <summary>
|
|||
/// Default value for the minimum number of iterations over which
|
|||
/// the residual must grow before a divergence warning is issued.
|
|||
/// </summary>
|
|||
public const int DefaultMinimumNumberOfIterations = 10; |
|||
|
|||
/// <summary>
|
|||
/// Defines the default last iteration number. Set to -1 because iterations normally
|
|||
/// start at 0.
|
|||
/// </summary>
|
|||
private const int DefaultLastIterationNumber = -1; |
|||
|
|||
/// <summary>
|
|||
/// The default status.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The maximum relative increase the residual may experience without triggering a divergence warning.
|
|||
/// </summary>
|
|||
private double _maximumRelativeIncrease; |
|||
|
|||
/// <summary>
|
|||
/// The number of iterations over which a residual increase should be tracked before issuing a divergence warning.
|
|||
/// </summary>
|
|||
private int _minimumNumberOfIterations; |
|||
|
|||
/// <summary>
|
|||
/// The status of the calculation
|
|||
/// </summary>
|
|||
private ICalculationStatus _status = DefaultStatus; |
|||
|
|||
/// <summary>
|
|||
/// The array that holds the tracking information.
|
|||
/// </summary>
|
|||
private double[] _residualHistory; |
|||
|
|||
/// <summary>
|
|||
/// The iteration number of the last iteration.
|
|||
/// </summary>
|
|||
private int _lastIteration = DefaultLastIterationNumber; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum
|
|||
/// relative increase and the default minimum number of tracking iterations.
|
|||
/// </summary>
|
|||
public DivergenceStopCriterium() : this(DefaultMaximumRelativeIncrease, DefaultMinimumNumberOfIterations) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum
|
|||
/// relative increase and the default minimum number of tracking iterations.
|
|||
/// </summary>
|
|||
/// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued.</param>
|
|||
public DivergenceStopCriterium(double maximumRelativeIncrease) : this(maximumRelativeIncrease, DefaultMinimumNumberOfIterations) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum
|
|||
/// relative increase and the specified minimum number of tracking iterations.
|
|||
/// </summary>
|
|||
/// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued. </param>
|
|||
public DivergenceStopCriterium(int minimumIterations) : this(DefaultMinimumNumberOfIterations, minimumIterations) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum
|
|||
/// relative increase and the specified minimum number of tracking iterations.
|
|||
/// </summary>
|
|||
/// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued. </param>
|
|||
/// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued.</param>
|
|||
public DivergenceStopCriterium(double maximumRelativeIncrease, int minimumIterations) |
|||
{ |
|||
if (maximumRelativeIncrease <= 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("maximumRelativeIncrease"); |
|||
} |
|||
|
|||
// There must be at least three iterations otherwise we can't calculate the relative increase
|
|||
if (minimumIterations < 3) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("minimumIterations"); |
|||
} |
|||
|
|||
_maximumRelativeIncrease = maximumRelativeIncrease; |
|||
_minimumNumberOfIterations = minimumIterations; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the maximum relative increase that the residual may experience before a divergence warning is issued.
|
|||
/// </summary>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if the <c>Maximum</c> is set to zero or below.</exception>
|
|||
public double MaximumRelativeIncrease |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _maximumRelativeIncrease; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
if (value <= 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_maximumRelativeIncrease = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the maximum relative increase to the default.
|
|||
/// </summary>
|
|||
public void ResetMaximumRelativeIncreaseToDefault() |
|||
{ |
|||
_maximumRelativeIncrease = DefaultMaximumRelativeIncrease; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the minimum number of iterations over which the residual must grow before
|
|||
/// issuing a divergence warning.
|
|||
/// </summary>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if the <c>value</c> is set to less than one.</exception>
|
|||
public int MinimumNumberOfIterations |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _minimumNumberOfIterations; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
// There must be at least three iterations otherwise we can't calculate
|
|||
// the relative increase
|
|||
if (value < 3) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_minimumNumberOfIterations = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the minimum number of iterations to the default.
|
|||
/// </summary>
|
|||
public void ResetNumberOfIterationsToDefault() |
|||
{ |
|||
_minimumNumberOfIterations = DefaultMinimumNumberOfIterations; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual stop criteria may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
public void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector) |
|||
{ |
|||
if (iterationNumber < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("iterationNumber"); |
|||
} |
|||
|
|||
if (residualVector == null) |
|||
{ |
|||
throw new ArgumentNullException("residualVector"); |
|||
} |
|||
|
|||
if (_lastIteration >= iterationNumber) |
|||
{ |
|||
// We have already stored the actual last iteration number
|
|||
// For now do nothing. We only care about the next step.
|
|||
return; |
|||
} |
|||
|
|||
if ((_residualHistory == null) || (_residualHistory.Length != RequiredHistoryLength)) |
|||
{ |
|||
_residualHistory = new double[RequiredHistoryLength]; |
|||
} |
|||
|
|||
// We always track the residual.
|
|||
// Move the old versions one element up in the array.
|
|||
for (var i = 1; i < _residualHistory.Length; i++) |
|||
{ |
|||
_residualHistory[i - 1] = _residualHistory[i]; |
|||
} |
|||
|
|||
// Store the infinity norms of both the solution and residual vectors
|
|||
// These values will be used to calculate the relative drop in residuals later on.
|
|||
_residualHistory[_residualHistory.Length - 1] = residualVector.Norm(Double.PositiveInfinity); |
|||
|
|||
// Check if we have NaN's. If so we've gone way beyond normal divergence.
|
|||
// Stop the iteration.
|
|||
if (double.IsNaN(_residualHistory[_residualHistory.Length - 1])) |
|||
{ |
|||
SetStatusToDiverged(); |
|||
return; |
|||
} |
|||
|
|||
// Check if we are diverging and if so set the status
|
|||
if (IsDiverging()) |
|||
{ |
|||
SetStatusToDiverged(); |
|||
} |
|||
else |
|||
{ |
|||
SetStatusToRunning(); |
|||
} |
|||
|
|||
_lastIteration = iterationNumber; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Detect if solution is diverging
|
|||
/// </summary>
|
|||
/// <returns><c>true</c> if diverging, otherwise <c>false</c></returns>
|
|||
private bool IsDiverging() |
|||
{ |
|||
// Run for each variable
|
|||
for (var i = 1; i < _residualHistory.Length; i++) |
|||
{ |
|||
var difference = _residualHistory[i] - _residualHistory[i - 1]; |
|||
|
|||
// Divergence is occurring if:
|
|||
// - the last residual is larger than the previous one
|
|||
// - the relative increase of the residual is larger than the setting allows
|
|||
if ((difference < 0) || (_residualHistory[i - 1] * (1 + _maximumRelativeIncrease) >= _residualHistory[i])) |
|||
{ |
|||
// No divergence taking place within the required number of iterations
|
|||
// So reset and stop the iteration. There is no way we can get to the
|
|||
// required number of iterations anymore.
|
|||
return false; |
|||
} |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets required history lenght
|
|||
/// </summary>
|
|||
private int RequiredHistoryLength |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _minimumNumberOfIterations + 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationDiverged"/>
|
|||
/// </summary>
|
|||
private void SetStatusToDiverged() |
|||
{ |
|||
if (!(_status is CalculationDiverged)) |
|||
{ |
|||
_status = new CalculationDiverged(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationRunning"/>
|
|||
/// </summary>
|
|||
private void SetStatusToRunning() |
|||
{ |
|||
if (!(_status is CalculationRunning)) |
|||
{ |
|||
_status = new CalculationRunning(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
public ICalculationStatus Status |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _status; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
|
|||
/// </summary>
|
|||
public void ResetToPrecalculationState() |
|||
{ |
|||
_status = DefaultStatus; |
|||
_lastIteration = DefaultLastIterationNumber; |
|||
_residualHistory = null; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
|
|||
/// <see cref="IIterationStopCriterium"/> monitors.
|
|||
/// </summary>
|
|||
/// <value>Returns <see cref="StopCriterium.StopLevel.Divergence"/>.</value>
|
|||
public StopLevel StopLevel |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return StopLevel.Divergence; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="DivergenceStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="DivergenceStopCriterium"/> class.</returns>
|
|||
public IIterationStopCriterium Clone() |
|||
{ |
|||
return new DivergenceStopCriterium(_maximumRelativeIncrease, _minimumNumberOfIterations); |
|||
} |
|||
|
|||
#if !SILVERLIGHT
|
|||
/// <summary>
|
|||
/// Clone this object
|
|||
/// </summary>
|
|||
/// <returns>Object clone</returns>
|
|||
object ICloneable.Clone() |
|||
{ |
|||
return Clone(); |
|||
} |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,199 @@ |
|||
// <copyright file="FailureStopCriterium.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium |
|||
{ |
|||
using System; |
|||
using System.Diagnostics; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// Defines an <see cref="IIterationStopCriterium"/> that monitors residuals for NaN's.
|
|||
/// </summary>
|
|||
public sealed class FailureStopCriterium : IIterationStopCriterium |
|||
{ |
|||
/// <summary>
|
|||
/// Defines the default last iteration number. Set to -1 because iterations normally
|
|||
/// start at 0.
|
|||
/// </summary>
|
|||
private const int DefaultLastIterationNumber = -1; |
|||
|
|||
/// <summary>
|
|||
/// The default status.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The status of the calculation
|
|||
/// </summary>
|
|||
private ICalculationStatus _status = DefaultStatus; |
|||
|
|||
/// <summary>
|
|||
/// The iteration number of the last iteration.
|
|||
/// </summary>
|
|||
private int _lastIteration = DefaultLastIterationNumber; |
|||
|
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual stop criteria may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
public void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector) |
|||
{ |
|||
if (iterationNumber < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("iterationNumber"); |
|||
} |
|||
|
|||
if (solutionVector == null) |
|||
{ |
|||
throw new ArgumentNullException("solutionVector"); |
|||
} |
|||
|
|||
if (residualVector == null) |
|||
{ |
|||
throw new ArgumentNullException("residualVector"); |
|||
} |
|||
|
|||
if (solutionVector.Count != residualVector.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentArraysSameLength); |
|||
} |
|||
|
|||
if (_lastIteration >= iterationNumber) |
|||
{ |
|||
// We have already stored the actual last iteration number
|
|||
// For now do nothing. We only care about the next step.
|
|||
return; |
|||
} |
|||
|
|||
// Store the infinity norms of both the solution and residual vectors
|
|||
var residualNorm = residualVector.Norm(Double.PositiveInfinity); |
|||
var solutionNorm = solutionVector.Norm(Double.PositiveInfinity); |
|||
|
|||
if (Double.IsNaN(solutionNorm) || Double.IsNaN(residualNorm)) |
|||
{ |
|||
SetStatusToFailed(); |
|||
} |
|||
else |
|||
{ |
|||
SetStatusToRunning(); |
|||
} |
|||
|
|||
_lastIteration = iterationNumber; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationFailure"/>
|
|||
/// </summary>
|
|||
private void SetStatusToFailed() |
|||
{ |
|||
if (!(_status is CalculationFailure)) |
|||
{ |
|||
_status = new CalculationFailure(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationRunning"/>
|
|||
/// </summary>
|
|||
private void SetStatusToRunning() |
|||
{ |
|||
if (!(_status is CalculationRunning)) |
|||
{ |
|||
_status = new CalculationRunning(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
public ICalculationStatus Status |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _status; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
|
|||
/// </summary>
|
|||
public void ResetToPrecalculationState() |
|||
{ |
|||
_status = DefaultStatus; |
|||
_lastIteration = DefaultLastIterationNumber; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
|
|||
/// <see cref="IIterationStopCriterium"/> monitors.
|
|||
/// </summary>
|
|||
/// <value>Returns <see cref="CalculationFailure"/>.</value>
|
|||
public StopLevel StopLevel |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return StopLevel.CalculationFailure; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="FailureStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="FailureStopCriterium"/> class.</returns>
|
|||
public IIterationStopCriterium Clone() |
|||
{ |
|||
return new FailureStopCriterium(); |
|||
} |
|||
|
|||
#if !SILVERLIGHT
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="FailureStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="FailureStopCriterium"/> class.</returns>
|
|||
object ICloneable.Clone() |
|||
{ |
|||
return Clone(); |
|||
} |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,79 @@ |
|||
// <copyright file="IIterationStopCriterium.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium |
|||
{ |
|||
using System; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// The base interface for classes that provide stop criteria for iterative calculations.
|
|||
/// </summary>
|
|||
public interface IIterationStopCriterium |
|||
#if !SILVERLIGHT
|
|||
: ICloneable |
|||
#endif
|
|||
{ |
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <see cref="IIterationStopCriterium"/>. Status is set to <c>Status</c> field of current object.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual stop criteria may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector); |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
/// <remarks><see langword="null" /> is not a legal value. Status should be set in <see cref="DetermineStatus"/> implementation.</remarks>
|
|||
ICalculationStatus Status { get; } |
|||
|
|||
/// <summary>
|
|||
/// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
|
|||
/// </summary>
|
|||
/// <remarks>To implementers: Invoking this method should not clear the user defined
|
|||
/// property values, only the state that is used to track the progress of the
|
|||
/// calculation.</remarks>
|
|||
void ResetToPrecalculationState(); |
|||
|
|||
/// <summary>
|
|||
/// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
|
|||
/// <see cref="IIterationStopCriterium"/> monitors.
|
|||
/// </summary>
|
|||
StopLevel StopLevel { get; } |
|||
|
|||
#if SILVERLIGHT
|
|||
IIterationStopCriterium Clone(); |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,225 @@ |
|||
// <copyright file="IterationCountStopCriterium.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium |
|||
{ |
|||
using System; |
|||
using System.Diagnostics; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// Defines an <see cref="IIterationStopCriterium"/> that monitors the numbers of iteration
|
|||
/// steps as stop criterium.
|
|||
/// </summary>
|
|||
public sealed class IterationCountStopCriterium : IIterationStopCriterium |
|||
{ |
|||
/// <summary>
|
|||
/// The default value for the maximum number of iterations the process is allowed
|
|||
/// to perform.
|
|||
/// </summary>
|
|||
public const int DefaultMaximumNumberOfIterations = 1000; |
|||
|
|||
/// <summary>
|
|||
/// The default status.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The maximum number of iterations the calculation is allowed to perform.
|
|||
/// </summary>
|
|||
private int _maximumNumberOfIterations; |
|||
|
|||
/// <summary>
|
|||
/// The status of the calculation
|
|||
/// </summary>
|
|||
private ICalculationStatus _status = DefaultStatus; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="IterationCountStopCriterium"/> class with the default maximum
|
|||
/// number of iterations.
|
|||
/// </summary>
|
|||
public IterationCountStopCriterium() : this(DefaultMaximumNumberOfIterations) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="IterationCountStopCriterium"/> class with the specified maximum
|
|||
/// number of iterations.
|
|||
/// </summary>
|
|||
/// <param name="maximumNumberOfIterations">The maximum number of iterations the calculation is allowed to perform.</param>
|
|||
public IterationCountStopCriterium(int maximumNumberOfIterations) |
|||
{ |
|||
if (maximumNumberOfIterations < 1) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("maximumNumberOfIterations"); |
|||
} |
|||
|
|||
_maximumNumberOfIterations = maximumNumberOfIterations; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the maximum number of iterations the calculation is allowed to perform.
|
|||
/// </summary>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if the <c>Maximum</c> is set to a negative value.</exception>
|
|||
public int MaximumNumberOfIterations |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _maximumNumberOfIterations; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
if (value < 1) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_maximumNumberOfIterations = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the maximum number of iterations to the default.
|
|||
/// </summary>
|
|||
public void ResetMaximumNumberOfIterationsToDefault() |
|||
{ |
|||
_maximumNumberOfIterations = DefaultMaximumNumberOfIterations; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <see cref="IterationCountStopCriterium"/>. Result is set into <c>Status</c> field.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual stop criteria may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
public void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector) |
|||
{ |
|||
if (iterationNumber < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("iterationNumber"); |
|||
} |
|||
|
|||
if (iterationNumber >= _maximumNumberOfIterations) |
|||
{ |
|||
SetStatusToFinished(); |
|||
} |
|||
else |
|||
{ |
|||
SetStatusToRunning(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationFailure"/>
|
|||
/// </summary>
|
|||
private void SetStatusToFinished() |
|||
{ |
|||
if (!(_status is CalculationStoppedWithoutConvergence)) |
|||
{ |
|||
_status = new CalculationStoppedWithoutConvergence(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationRunning"/>
|
|||
/// </summary>
|
|||
private void SetStatusToRunning() |
|||
{ |
|||
if (!(_status is CalculationRunning)) |
|||
{ |
|||
_status = new CalculationRunning(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
public ICalculationStatus Status |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _status; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the <see cref="IterationCountStopCriterium"/> to the pre-calculation state.
|
|||
/// </summary>
|
|||
public void ResetToPrecalculationState() |
|||
{ |
|||
_status = DefaultStatus; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
|
|||
/// <see cref="IterationCountStopCriterium"/> monitors.
|
|||
/// </summary>
|
|||
/// <value>Returns <see cref="StopLevel"/>.</value>
|
|||
public StopLevel StopLevel |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return StopLevel.StoppedWithoutConvergence; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="IterationCountStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="IterationCountStopCriterium"/> class.</returns>
|
|||
public IIterationStopCriterium Clone() |
|||
{ |
|||
return new IterationCountStopCriterium(_maximumNumberOfIterations); |
|||
} |
|||
|
|||
#if !SILVERLIGHT
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="IterationCountStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="IterationCountStopCriterium"/> object.</returns>
|
|||
object ICloneable.Clone() |
|||
{ |
|||
return Clone(); |
|||
} |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,407 @@ |
|||
// <copyright file="ResidualStopCriterium.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium |
|||
{ |
|||
using System; |
|||
using System.Diagnostics; |
|||
using Properties; |
|||
using Status; |
|||
|
|||
/// <summary>
|
|||
/// Defines an <see cref="IIterationStopCriterium"/> that monitors residuals as stop criterium.
|
|||
/// </summary>
|
|||
public sealed class ResidualStopCriterium : IIterationStopCriterium |
|||
{ |
|||
/// <summary>
|
|||
/// The default value for the maximum value of the residual.
|
|||
/// </summary>
|
|||
public const double DefaultMaximumResidual = 1e-12; |
|||
|
|||
/// <summary>
|
|||
/// The default value for the minimum number of iterations.
|
|||
/// </summary>
|
|||
public const int DefaultMinimumIterationsBelowMaximum = 0; |
|||
|
|||
/// <summary>
|
|||
/// Defines the default last iteration number. Set to -1 because iterations normally start at 0.
|
|||
/// </summary>
|
|||
private const int DefaultLastIterationNumber = -1; |
|||
|
|||
/// <summary>
|
|||
/// The default status.
|
|||
/// </summary>
|
|||
private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined(); |
|||
|
|||
/// <summary>
|
|||
/// The maximum value for the residual below which the calculation is considered converged.
|
|||
/// </summary>
|
|||
private double _maximum; |
|||
|
|||
/// <summary>
|
|||
/// The minimum number of iterations for which the residual has to be below the maximum before
|
|||
/// the calculation is considered converged.
|
|||
/// </summary>
|
|||
private int _minimumIterationsBelowMaximum; |
|||
|
|||
/// <summary>
|
|||
/// The status of the calculation
|
|||
/// </summary>
|
|||
private ICalculationStatus _status = DefaultStatus; |
|||
|
|||
/// <summary>
|
|||
/// The number of iterations since the residuals got below the maximum.
|
|||
/// </summary>
|
|||
private int _iterationCount; |
|||
|
|||
/// <summary>
|
|||
/// The iteration number of the last iteration.
|
|||
/// </summary>
|
|||
private int _lastIteration = DefaultLastIterationNumber; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum
|
|||
/// residual and the default minimum number of iterations.
|
|||
/// </summary>
|
|||
public ResidualStopCriterium() : this(DefaultMaximumResidual, DefaultMinimumIterationsBelowMaximum) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified
|
|||
/// maximum residual and the default minimum number of iterations.
|
|||
/// </summary>
|
|||
/// <param name="maximum">The maximum value for the residual below which the calculation is considered converged.</param>
|
|||
public ResidualStopCriterium(double maximum) : this(maximum, DefaultMinimumIterationsBelowMaximum) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum residual
|
|||
/// and specified minimum number of iterations.
|
|||
/// </summary>
|
|||
/// <param name="minimumIterationsBelowMaximum">
|
|||
/// The minimum number of iterations for which the residual has to be below the maximum before
|
|||
/// the calculation is considered converged.
|
|||
/// </param>
|
|||
public ResidualStopCriterium(int minimumIterationsBelowMaximum) : this(DefaultMaximumResidual, minimumIterationsBelowMaximum) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified
|
|||
/// maximum residual and minimum number of iterations.
|
|||
/// </summary>
|
|||
/// <param name="maximum">
|
|||
/// The maximum value for the residual below which the calculation is considered converged.
|
|||
/// </param>
|
|||
/// <param name="minimumIterationsBelowMaximum">
|
|||
/// The minimum number of iterations for which the residual has to be below the maximum before
|
|||
/// the calculation is considered converged.
|
|||
/// </param>
|
|||
public ResidualStopCriterium(double maximum, int minimumIterationsBelowMaximum) |
|||
{ |
|||
if (maximum < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("maximum"); |
|||
} |
|||
|
|||
if (minimumIterationsBelowMaximum < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("minimumIterationsBelowMaximum"); |
|||
} |
|||
|
|||
_maximum = maximum; |
|||
_minimumIterationsBelowMaximum = minimumIterationsBelowMaximum; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the maximum value for the residual below which the calculation is considered
|
|||
/// converged.
|
|||
/// </summary>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if the <c>Maximum</c> is set to a negative value.</exception>
|
|||
public double Maximum |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _maximum; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_maximum = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the maximum residual to the default.
|
|||
/// </summary>
|
|||
public void ResetMaximumResidualToDefault() |
|||
{ |
|||
_maximum = DefaultMaximumResidual; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the minimum number of iterations for which the residual has to be
|
|||
/// below the maximum before the calculation is considered converged.
|
|||
/// </summary>
|
|||
/// <exception cref="ArgumentOutOfRangeException">Thrown if the <c>BelowMaximumFor</c> is set to a value less than 1.</exception>
|
|||
public int MinimumIterationsBelowMaximum |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _minimumIterationsBelowMaximum; |
|||
} |
|||
|
|||
[DebuggerStepThrough] |
|||
set |
|||
{ |
|||
if (value < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
_minimumIterationsBelowMaximum = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the minimum number of iterations to the default.
|
|||
/// </summary>
|
|||
public void ResetMinimumIterationsBelowMaximumToDefault() |
|||
{ |
|||
_minimumIterationsBelowMaximum = DefaultMinimumIterationsBelowMaximum; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determines the status of the iterative calculation based on the stop criteria stored
|
|||
/// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
|
|||
/// </summary>
|
|||
/// <param name="iterationNumber">The number of iterations that have passed so far.</param>
|
|||
/// <param name="solutionVector">The vector containing the current solution values.</param>
|
|||
/// <param name="sourceVector">The right hand side vector.</param>
|
|||
/// <param name="residualVector">The vector containing the current residual vectors.</param>
|
|||
/// <remarks>
|
|||
/// The individual stop criteria may internally track the progress of the calculation based
|
|||
/// on the invocation of this method. Therefore this method should only be called if the
|
|||
/// calculation has moved forwards at least one step.
|
|||
/// </remarks>
|
|||
public void DetermineStatus(int iterationNumber, Vector solutionVector, Vector sourceVector, Vector residualVector) |
|||
{ |
|||
if (iterationNumber < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("iterationNumber"); |
|||
} |
|||
|
|||
if (solutionVector == null) |
|||
{ |
|||
throw new ArgumentNullException("solutionVector"); |
|||
} |
|||
|
|||
if (sourceVector == null) |
|||
{ |
|||
throw new ArgumentNullException("sourceVector"); |
|||
} |
|||
|
|||
if (residualVector == null) |
|||
{ |
|||
throw new ArgumentNullException("residualVector"); |
|||
} |
|||
|
|||
if (solutionVector.Count != sourceVector.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "sourceVector"); |
|||
} |
|||
|
|||
if (solutionVector.Count != residualVector.Count) |
|||
{ |
|||
throw new ArgumentException(Resources.ArgumentVectorsSameLength, "residualVector"); |
|||
} |
|||
|
|||
// Store the infinity norms of both the solution and residual vectors
|
|||
// These values will be used to calculate the relative drop in residuals
|
|||
// later on.
|
|||
var residualNorm = residualVector.Norm(Double.PositiveInfinity); |
|||
|
|||
// Check the residuals by calculating:
|
|||
// ||r_i|| <= stop_tol * ||b||
|
|||
var stopCriterium = ComputeStopCriterium(sourceVector.Norm(Double.PositiveInfinity)); |
|||
|
|||
// First check that we have real numbers not NaN's.
|
|||
// NaN's can occur when the iterative process diverges so we
|
|||
// stop if that is the case.
|
|||
if (double.IsNaN(stopCriterium) || double.IsNaN(residualNorm)) |
|||
{ |
|||
_iterationCount = 0; |
|||
SetStatusToDiverged(); |
|||
return; |
|||
} |
|||
|
|||
// ||r_i|| <= stop_tol * ||b||
|
|||
// Stop the calculation if it's clearly smaller than the tolerance
|
|||
var decimalMagnitude = Math.Abs(stopCriterium.Magnitude()) + 1; |
|||
if (residualNorm.IsSmallerWithDecimalPlaces(stopCriterium, decimalMagnitude)) |
|||
{ |
|||
if (_lastIteration <= iterationNumber) |
|||
{ |
|||
_iterationCount = iterationNumber - _lastIteration; |
|||
if (_iterationCount >= _minimumIterationsBelowMaximum) |
|||
{ |
|||
SetStatusToConverged(); |
|||
} |
|||
else |
|||
{ |
|||
SetStatusToRunning(); |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
_iterationCount = 0; |
|||
SetStatusToRunning(); |
|||
} |
|||
|
|||
_lastIteration = iterationNumber; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculate stop criterium
|
|||
/// </summary>
|
|||
/// <param name="solutionNorm">Solution vector norm</param>
|
|||
/// <returns>Criterium value</returns>
|
|||
private double ComputeStopCriterium(double solutionNorm) |
|||
{ |
|||
// This is criterium 1 from Templates for the solution of linear systems.
|
|||
// The problem with this criterium is that it's not limiting enough. For now
|
|||
// we won't use it. Later on we might get back to it.
|
|||
// return mMaximumResidual * (System.Math.Abs(mMatrixNorm) * System.Math.Abs(solutionNorm) + System.Math.Abs(mVectorNorm));
|
|||
|
|||
// For now use criterium 2 from Templates for the solution of linear systems. See page 60.
|
|||
return _maximum * Math.Abs(solutionNorm); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationDiverged"/>
|
|||
/// </summary>
|
|||
private void SetStatusToDiverged() |
|||
{ |
|||
if (!(_status is CalculationDiverged)) |
|||
{ |
|||
_status = new CalculationDiverged(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationConverged"/>
|
|||
/// </summary>
|
|||
private void SetStatusToConverged() |
|||
{ |
|||
if (!(_status is CalculationConverged)) |
|||
{ |
|||
_status = new CalculationConverged(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set status to <see cref="CalculationRunning"/>
|
|||
/// </summary>
|
|||
private void SetStatusToRunning() |
|||
{ |
|||
if (!(_status is CalculationRunning)) |
|||
{ |
|||
_status = new CalculationRunning(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current calculation status.
|
|||
/// </summary>
|
|||
public ICalculationStatus Status |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return _status; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
|
|||
/// </summary>
|
|||
public void ResetToPrecalculationState() |
|||
{ |
|||
_status = DefaultStatus; |
|||
_iterationCount = 0; |
|||
_lastIteration = DefaultLastIterationNumber; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
|
|||
/// <see cref="IIterationStopCriterium"/> monitors.
|
|||
/// </summary>
|
|||
/// <value>Returns <see cref="StopLevel"/>.</value>
|
|||
public StopLevel StopLevel |
|||
{ |
|||
[DebuggerStepThrough] |
|||
get |
|||
{ |
|||
return StopLevel.Convergence; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="ResidualStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="ResidualStopCriterium"/> class.</returns>
|
|||
public IIterationStopCriterium Clone() |
|||
{ |
|||
return new ResidualStopCriterium(_maximum, _minimumIterationsBelowMaximum); |
|||
} |
|||
|
|||
#if !SILVERLIGHT
|
|||
/// <summary>
|
|||
/// Clones the current <see cref="ResidualStopCriterium"/> and its settings.
|
|||
/// </summary>
|
|||
/// <returns>A new instance of the <see cref="ResidualStopCriterium"/> object.</returns>
|
|||
object ICloneable.Clone() |
|||
{ |
|||
return Clone(); |
|||
} |
|||
#endif
|
|||
} |
|||
} |
|||
@ -0,0 +1,57 @@ |
|||
// <copyright file="StopLevel.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium |
|||
{ |
|||
/// <summary>
|
|||
/// Indicates what an <c>IIterationStopCriterium</c> monitors for stop criteria.
|
|||
/// </summary>
|
|||
public enum StopLevel |
|||
{ |
|||
/// <summary>
|
|||
/// The <see cref="IIterationStopCriterium"/> monitors calculation failures in the
|
|||
/// iterative calculation.
|
|||
/// </summary>
|
|||
CalculationFailure, |
|||
|
|||
/// <summary>
|
|||
/// The <see cref="IIterationStopCriterium"/> monitors the calculation for signs of divergence.
|
|||
/// </summary>
|
|||
Divergence, |
|||
|
|||
/// <summary>
|
|||
/// The <see cref="IIterationStopCriterium"/> guards the calculation against unlimited continuation
|
|||
/// by monitoring user specified limits, e.g. the maximum number of iterations.
|
|||
/// </summary>
|
|||
StoppedWithoutConvergence, |
|||
|
|||
/// <summary>
|
|||
/// The <see cref="IIterationStopCriterium"/> monitors the calculation for convergence, usually
|
|||
/// based on the residuals of the calculation.
|
|||
/// </summary>
|
|||
Convergence |
|||
} |
|||
} |
|||
@ -0,0 +1,449 @@ |
|||
// <copyright file="DiagonalMatrixTests.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double |
|||
{ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using MbUnit.Framework; |
|||
using LinearAlgebra.Double; |
|||
|
|||
public class DiagonalMatrixTests : MatrixTests |
|||
{ |
|||
[SetUp] |
|||
public override void SetupMatrices() |
|||
{ |
|||
TestData2D = new Dictionary<string, double[,]> |
|||
{ |
|||
{ "Singular3x3", new [,] { { 1.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 3.0 } } }, |
|||
{ "Square3x3", new [,] { { -1.1, 0.0, 0.0 }, { 0.0, 1.1, 0.0 }, { 0.0, 0.0, 6.6 } } }, |
|||
{ "Square4x4", new [,] { { -1.1, 0.0, 0.0, 0.0 }, { 0.0, 1.1, 0.0, 0.0 }, { 0.0, 0.0, 6.2, 0.0}, { 0.0, 0.0, 0.0, -7.7 } } }, |
|||
{ "Singular4x4", new [,] { { -1.1, 0.0, 0.0, 0.0 }, { 0.0, -2.2, 0.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0}, { 0.0, 0.0, 0.0, -4.4 } } }, |
|||
{ "Tall3x2", new [,] { { -1.1, 0.0 }, { 0.0, 1.1 }, { 0.0, 0.0 } } }, |
|||
{ "Wide2x3", new [,] { { -1.1, 0.0, 0.0 }, { 0.0, 1.1, 0.0 } } } |
|||
}; |
|||
|
|||
TestMatrices = new Dictionary<string, Matrix>(); |
|||
foreach (var name in TestData2D.Keys) |
|||
{ |
|||
TestMatrices.Add(name, CreateMatrix(TestData2D[name])); |
|||
} |
|||
} |
|||
|
|||
protected override Matrix CreateMatrix(int rows, int columns) |
|||
{ |
|||
return new DiagonalMatrix(rows, columns); |
|||
} |
|||
|
|||
protected override Matrix CreateMatrix(double[,] data) |
|||
{ |
|||
return new DiagonalMatrix(data); |
|||
} |
|||
|
|||
protected override Vector CreateVector(int size) |
|||
{ |
|||
return new DenseVector(size); |
|||
} |
|||
|
|||
protected override Vector CreateVector(double[] data) |
|||
{ |
|||
return new DenseVector(data); |
|||
} |
|||
|
|||
[Test] |
|||
public void CanCreateMatrixFromDiagonalArray() |
|||
{ |
|||
var testData = new Dictionary<string, Matrix> |
|||
{ |
|||
{ "Singular3x3", new DiagonalMatrix(3, 3, new[] { 1.0, 0.0, 3.0}) }, |
|||
{ "Square3x3", new DiagonalMatrix(4, 4, new[] { -1.1, 1.1, 6.6 }) }, |
|||
{ "Square4x4", new DiagonalMatrix(4, 4, new[] { -1.1, 1.1, 6.2, -7.7 }) }, |
|||
{ "Tall3x2", new DiagonalMatrix(3, 2, new[] { -1.1, 1.1 }) }, |
|||
{ "Wide2x3", new DiagonalMatrix(2, 3, new[] { -1.1, 1.1 }) }, |
|||
}; |
|||
|
|||
foreach (var name in testData.Keys) |
|||
{ |
|||
Assert.AreEqual(TestMatrices[name], testData[name]); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
public void MatrixFrom1DArrayIsReference() |
|||
{ |
|||
var data = new double[] { 1, 2, 3, 4, 5}; |
|||
var matrix = new DiagonalMatrix(5, 5, data); |
|||
matrix[0, 0] = 10.0; |
|||
Assert.AreEqual(10.0, data[0]); |
|||
} |
|||
|
|||
[Test] |
|||
[Row("Singular3x3")] |
|||
[Row("Singular3x3")] |
|||
[Row("Square3x3")] |
|||
[Row("Square4x4")] |
|||
[Row("Tall3x2")] |
|||
[Row("Wide2x3")] |
|||
public void CanCreateMatrixFrom2DArray(string name) |
|||
{ |
|||
var matrix = new DiagonalMatrix(TestData2D[name]); |
|||
for (var i = 0; i < TestData2D[name].GetLength(0); i++) |
|||
{ |
|||
for (var j = 0; j < TestData2D[name].GetLength(1); j++) |
|||
{ |
|||
Assert.AreEqual(TestData2D[name][i, j], matrix[i, j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
public void CanCreateMatrixWithUniformValues() |
|||
{ |
|||
var matrix = new DiagonalMatrix(10, 10, 10.0); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
Assert.AreEqual(matrix[i, i], 10.0); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
public void CanCreateIdentity() |
|||
{ |
|||
var matrix = DiagonalMatrix.Identity(5); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrix.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(i == j ? 1.0 : 0.0, matrix[i, j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row(0)] |
|||
[Row(-1)] |
|||
[ExpectedArgumentException] |
|||
public void IdentityFailsWithZeroOrNegativeOrder(int order) |
|||
{ |
|||
DiagonalMatrix.Identity(order); |
|||
} |
|||
|
|||
[Test] |
|||
public override void CanDiagonallyStackMatricesWithPassingResult() |
|||
{ |
|||
var top = TestMatrices["Tall3x2"]; |
|||
var bottom = TestMatrices["Wide2x3"]; |
|||
var result = new SparseMatrix(top.RowCount + bottom.RowCount, top.ColumnCount + bottom.ColumnCount); |
|||
top.DiagonalStack(bottom, result); |
|||
Assert.AreEqual(top.RowCount + bottom.RowCount, result.RowCount); |
|||
Assert.AreEqual(top.ColumnCount + bottom.ColumnCount, result.ColumnCount); |
|||
|
|||
for (var i = 0; i < result.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < result.ColumnCount; j++) |
|||
{ |
|||
if (i < top.RowCount && j < top.ColumnCount) |
|||
{ |
|||
Assert.AreEqual(top[i, j], result[i, j]); |
|||
} |
|||
else if (i >= top.RowCount && j >= top.ColumnCount) |
|||
{ |
|||
Assert.AreEqual(bottom[i - top.RowCount, j - top.ColumnCount], result[i, j]); |
|||
} |
|||
else |
|||
{ |
|||
Assert.AreEqual(0, result[i, j]); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void CanMultiplyMatrixWithMatrixIntoResult(string nameA, string nameB) |
|||
{ |
|||
var matrixA = TestMatrices[nameA]; |
|||
var matrixB = TestMatrices[nameB]; |
|||
var matrixC = new SparseMatrix(matrixA.RowCount, matrixB.ColumnCount); |
|||
matrixA.Multiply(matrixB, matrixC); |
|||
|
|||
Assert.AreEqual(matrixC.RowCount, matrixA.RowCount); |
|||
Assert.AreEqual(matrixC.ColumnCount, matrixB.ColumnCount); |
|||
|
|||
for (var i = 0; i < matrixC.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixC.ColumnCount; j++) |
|||
{ |
|||
AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Column(j), matrixC[i, j], 15); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row("Singular3x3")] |
|||
[ExpectedException(typeof(InvalidOperationException))] |
|||
public void CanPermuteMatrixRowsThrowException(string name) |
|||
{ |
|||
var matrix = CreateMatrix(TestData2D[name]); |
|||
var matrixp = CreateMatrix(TestData2D[name]); |
|||
|
|||
var permutation = new Permutation(new[] { 2, 0, 1 }); |
|||
matrixp.PermuteRows(permutation); |
|||
|
|||
Assert.AreNotSame(matrix, matrixp); |
|||
Assert.AreEqual(matrix.RowCount, matrixp.RowCount); |
|||
Assert.AreEqual(matrix.ColumnCount, matrixp.ColumnCount); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrix.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrix[i, j], matrixp[permutation[i], j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row("Singular3x3")] |
|||
[ExpectedException(typeof(InvalidOperationException))] |
|||
public void CanPermuteMatrixColumnsThrowException(string name) |
|||
{ |
|||
var matrix = CreateMatrix(TestData2D[name]); |
|||
var matrixp = CreateMatrix(TestData2D[name]); |
|||
|
|||
var permutation = new Permutation(new[] { 2, 0, 1 }); |
|||
matrixp.PermuteColumns(permutation); |
|||
|
|||
Assert.AreNotSame(matrix, matrixp); |
|||
Assert.AreEqual(matrix.RowCount, matrixp.RowCount); |
|||
Assert.AreEqual(matrix.ColumnCount, matrixp.ColumnCount); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrix.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrix[i, j], matrixp[i, permutation[j]]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void CanPermuteMatrixRows(string name) |
|||
{ |
|||
} |
|||
|
|||
public override void CanPermuteMatrixColumns(string name) |
|||
{ |
|||
} |
|||
|
|||
public override void PointwiseDivideResult() |
|||
{ |
|||
foreach (var data in TestMatrices.Values) |
|||
{ |
|||
var other = data.Clone(); |
|||
var result = data.Clone(); |
|||
data.PointwiseDivide(other, result); |
|||
var min = Math.Min(data.RowCount, data.ColumnCount); |
|||
for (var i = 0; i < min; i++) |
|||
{ |
|||
Assert.AreEqual(data[i, i] / other[i, i], result[i, i]); |
|||
} |
|||
|
|||
result = data.PointwiseDivide(other); |
|||
for (var i = 0; i < min; i++) |
|||
{ |
|||
Assert.AreEqual(data[i, i] / other[i, i], result[i, i]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void SetColumnWithArray(string name, double[] column) |
|||
{ |
|||
try |
|||
{ |
|||
// Pass all invoke to base
|
|||
base.SetColumnWithArray(name, column); |
|||
} |
|||
catch(AggregateException ex) |
|||
{ |
|||
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
|
|||
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException))) |
|||
{ |
|||
throw; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void SetColumnWithVector(string name, double[] column) |
|||
{ |
|||
try |
|||
{ |
|||
// Pass all invoke to base
|
|||
base.SetColumnWithVector(name, column); |
|||
} |
|||
catch (AggregateException ex) |
|||
{ |
|||
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
|
|||
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException))) |
|||
{ |
|||
throw; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void SetRowWithArray(string name, double[] row) |
|||
{ |
|||
try |
|||
{ |
|||
// Pass all invoke to base
|
|||
base.SetRowWithArray(name, row); |
|||
} |
|||
catch (AggregateException ex) |
|||
{ |
|||
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
|
|||
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException))) |
|||
{ |
|||
throw; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void SetRowWithVector(string name, double[] row) |
|||
{ |
|||
try |
|||
{ |
|||
// Pass all invoke to base
|
|||
base.SetRowWithVector(name, row); |
|||
} |
|||
catch (AggregateException ex) |
|||
{ |
|||
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
|
|||
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException))) |
|||
{ |
|||
throw; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void SetSubMatrix(int rowStart, int rowLength, int colStart, int colLength) |
|||
{ |
|||
try |
|||
{ |
|||
// Pass all invoke to base
|
|||
base.SetSubMatrix(rowStart, rowLength, colStart, colLength); |
|||
} |
|||
catch (AggregateException ex) |
|||
{ |
|||
// Supress only IndexOutOfRangeException exceptions due to Diagonal matrix nature
|
|||
if (ex.InnerExceptions.Any(innerException => !(innerException is IndexOutOfRangeException))) |
|||
{ |
|||
throw; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override void FrobeniusNorm() |
|||
{ |
|||
var matrix = TestMatrices["Square3x3"]; |
|||
var denseMatrix = new DenseMatrix(TestData2D["Square3x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); |
|||
|
|||
matrix = TestMatrices["Wide2x3"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Wide2x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); |
|||
|
|||
matrix = TestMatrices["Tall3x2"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Tall3x2"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14); |
|||
} |
|||
|
|||
public override void InfinityNorm() |
|||
{ |
|||
var matrix = TestMatrices["Square3x3"]; |
|||
var denseMatrix = new DenseMatrix(TestData2D["Square3x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); |
|||
|
|||
matrix = TestMatrices["Wide2x3"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Wide2x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); |
|||
|
|||
matrix = TestMatrices["Tall3x2"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Tall3x2"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14); |
|||
} |
|||
|
|||
public override void L1Norm() |
|||
{ |
|||
var matrix = TestMatrices["Square3x3"]; |
|||
var denseMatrix = new DenseMatrix(TestData2D["Square3x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); |
|||
|
|||
matrix = TestMatrices["Wide2x3"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Wide2x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); |
|||
|
|||
matrix = TestMatrices["Tall3x2"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Tall3x2"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.L1Norm(), matrix.L1Norm(), 14); |
|||
} |
|||
|
|||
public override void L2Norm() |
|||
{ |
|||
var matrix = TestMatrices["Square3x3"]; |
|||
var denseMatrix = new DenseMatrix(TestData2D["Square3x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); |
|||
|
|||
matrix = TestMatrices["Wide2x3"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Wide2x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); |
|||
|
|||
matrix = TestMatrices["Tall3x2"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Tall3x2"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.L2Norm(), matrix.L2Norm(), 14); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Determinant() |
|||
{ |
|||
var matrix = TestMatrices["Square3x3"]; |
|||
var denseMatrix = new DenseMatrix(TestData2D["Square3x3"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); |
|||
|
|||
matrix = TestMatrices["Square4x4"]; |
|||
denseMatrix = new DenseMatrix(TestData2D["Square4x4"]); |
|||
AssertHelpers.AlmostEqual(denseMatrix.Determinant(), matrix.Determinant(), 14); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void DeterminantNotSquareMatrixThrowException() |
|||
{ |
|||
var matrix = TestMatrices["Tall3x2"]; |
|||
matrix.Determinant(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,330 @@ |
|||
// <copyright file="GramSchmidtTests.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://numerics.mathdotnet.com
|
|||
// http://github.com/mathnet/mathnet-numerics
|
|||
// http://mathnetnumerics.codeplex.com
|
|||
//
|
|||
// Copyright (c) 2009-2010 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization |
|||
{ |
|||
using MbUnit.Framework; |
|||
using LinearAlgebra.Double.Factorization; |
|||
|
|||
public class GramSchmidtTests |
|||
{ |
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void ConstructorNull() |
|||
{ |
|||
new GramSchmidt(null); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void WideMatrixThrowsInvalidMatrixOperationException() |
|||
{ |
|||
new GramSchmidt(new UserDefinedMatrix(3, 4)); |
|||
} |
|||
|
|||
[Test] |
|||
[Row(1)] |
|||
[Row(10)] |
|||
[Row(100)] |
|||
public void CanFactorizeIdentity(int order) |
|||
{ |
|||
var I = UserDefinedMatrix.Identity(order); |
|||
var factorGramSchmidt = I.GramSchmidt(); |
|||
|
|||
Assert.AreEqual(I.RowCount, factorGramSchmidt.Q.RowCount); |
|||
Assert.AreEqual(I.ColumnCount, factorGramSchmidt.Q.ColumnCount); |
|||
|
|||
for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) |
|||
{ |
|||
if (i == j) |
|||
{ |
|||
Assert.AreEqual(1.0, factorGramSchmidt.R[i, j]); |
|||
} |
|||
else |
|||
{ |
|||
Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) |
|||
{ |
|||
if (i == j) |
|||
{ |
|||
Assert.AreEqual(1.0, factorGramSchmidt.Q[i, j]); |
|||
} |
|||
else |
|||
{ |
|||
Assert.AreEqual(0.0, factorGramSchmidt.Q[i, j]); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
[Test] |
|||
[Row(1)] |
|||
[Row(10)] |
|||
[Row(100)] |
|||
public void IdentityDeterminantIsOne(int order) |
|||
{ |
|||
var I = UserDefinedMatrix.Identity(order); |
|||
var factorGramSchmidt = I.GramSchmidt(); |
|||
Assert.AreEqual(1.0, factorGramSchmidt.Determinant); |
|||
} |
|||
|
|||
[Test] |
|||
[Row(1,1)] |
|||
[Row(2,2)] |
|||
[Row(5,5)] |
|||
[Row(10,6)] |
|||
[Row(50,48)] |
|||
[Row(100,98)] |
|||
[MultipleAsserts] |
|||
public void CanFactorizeRandomMatrix(int row, int column) |
|||
{ |
|||
var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); |
|||
var factorGramSchmidt = matrixA.GramSchmidt(); |
|||
|
|||
// Make sure the Q has the right dimensions.
|
|||
Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); |
|||
Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); |
|||
|
|||
// Make sure the R has the right dimensions.
|
|||
Assert.AreEqual(column, factorGramSchmidt.R.RowCount); |
|||
Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); |
|||
|
|||
// Make sure the R factor is upper triangular.
|
|||
for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) |
|||
{ |
|||
if (i > j) |
|||
{ |
|||
Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Make sure the Q*R is the original matrix.
|
|||
var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; |
|||
for (var i = 0; i < matrixQfromR.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixQfromR.ColumnCount; j++) |
|||
{ |
|||
Assert.AreApproximatelyEqual(matrixA[i, j], matrixQfromR[i, j], 1.0e-11); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row(1)] |
|||
[Row(2)] |
|||
[Row(5)] |
|||
[Row(10)] |
|||
[Row(50)] |
|||
[Row(100)] |
|||
[MultipleAsserts] |
|||
public void CanSolveForRandomVector(int order) |
|||
{ |
|||
var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); |
|||
var matrixACopy = matrixA.Clone(); |
|||
var factorGramSchmidt = matrixA.GramSchmidt(); |
|||
|
|||
var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order); |
|||
var resultx = factorGramSchmidt.Solve(vectorb); |
|||
|
|||
Assert.AreEqual(matrixA.ColumnCount, resultx.Count); |
|||
|
|||
var bReconstruct = matrixA * resultx; |
|||
|
|||
// Check the reconstruction.
|
|||
for (var i = 0; i < order; i++) |
|||
{ |
|||
Assert.AreApproximatelyEqual(vectorb[i], bReconstruct[i], 1.0e-11); |
|||
} |
|||
|
|||
// Make sure A didn't change.
|
|||
for (var i = 0; i < matrixA.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixA.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row(1)] |
|||
[Row(4)] |
|||
[Row(8)] |
|||
[Row(10)] |
|||
[Row(50)] |
|||
[Row(100)] |
|||
[MultipleAsserts] |
|||
public void CanSolveForRandomMatrix(int order) |
|||
{ |
|||
var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); |
|||
var matrixACopy = matrixA.Clone(); |
|||
var factorGramSchmidt = matrixA.GramSchmidt(); |
|||
|
|||
var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); |
|||
var matrixX = factorGramSchmidt.Solve(matrixB); |
|||
|
|||
// The solution X row dimension is equal to the column dimension of A
|
|||
Assert.AreEqual(matrixA.ColumnCount, matrixX.RowCount); |
|||
// The solution X has the same number of columns as B
|
|||
Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount); |
|||
|
|||
var matrixBReconstruct = matrixA * matrixX; |
|||
|
|||
// Check the reconstruction.
|
|||
for (var i = 0; i < matrixB.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixB.ColumnCount; j++) |
|||
{ |
|||
Assert.AreApproximatelyEqual(matrixB[i, j], matrixBReconstruct[i, j], 1.0e-11); |
|||
} |
|||
} |
|||
|
|||
// Make sure A didn't change.
|
|||
for (var i = 0; i < matrixA.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixA.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row(1)] |
|||
[Row(2)] |
|||
[Row(5)] |
|||
[Row(10)] |
|||
[Row(50)] |
|||
[Row(100)] |
|||
[MultipleAsserts] |
|||
public void CanSolveForRandomVectorWhenResultVectorGiven(int order) |
|||
{ |
|||
var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); |
|||
var matrixACopy = matrixA.Clone(); |
|||
var factorGramSchmidt = matrixA.GramSchmidt(); |
|||
var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order); |
|||
var vectorbCopy = vectorb.Clone(); |
|||
var resultx = new UserDefinedVector(order); |
|||
factorGramSchmidt.Solve(vectorb,resultx); |
|||
|
|||
Assert.AreEqual(vectorb.Count, resultx.Count); |
|||
|
|||
var bReconstruct = matrixA * resultx; |
|||
|
|||
// Check the reconstruction.
|
|||
for (var i = 0; i < vectorb.Count; i++) |
|||
{ |
|||
Assert.AreApproximatelyEqual(vectorb[i], bReconstruct[i], 1.0e-11); |
|||
} |
|||
|
|||
// Make sure A didn't change.
|
|||
for (var i = 0; i < matrixA.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixA.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]); |
|||
} |
|||
} |
|||
|
|||
// Make sure b didn't change.
|
|||
for (var i = 0; i < vectorb.Count; i++) |
|||
{ |
|||
Assert.AreEqual(vectorbCopy[i], vectorb[i]); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[Row(1)] |
|||
[Row(4)] |
|||
[Row(8)] |
|||
[Row(10)] |
|||
[Row(50)] |
|||
[Row(100)] |
|||
[MultipleAsserts] |
|||
public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order) |
|||
{ |
|||
var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); |
|||
var matrixACopy = matrixA.Clone(); |
|||
var factorGramSchmidt = matrixA.GramSchmidt(); |
|||
|
|||
var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); |
|||
var matrixBCopy = matrixB.Clone(); |
|||
|
|||
var matrixX = new UserDefinedMatrix(order, order); |
|||
factorGramSchmidt.Solve(matrixB,matrixX); |
|||
|
|||
// The solution X row dimension is equal to the column dimension of A
|
|||
Assert.AreEqual(matrixA.ColumnCount, matrixX.RowCount); |
|||
// The solution X has the same number of columns as B
|
|||
Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount); |
|||
|
|||
var matrixBReconstruct = matrixA * matrixX; |
|||
|
|||
// Check the reconstruction.
|
|||
for (var i = 0; i < matrixB.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixB.ColumnCount; j++) |
|||
{ |
|||
Assert.AreApproximatelyEqual(matrixB[i, j], matrixBReconstruct[i, j], 1.0e-11); |
|||
} |
|||
} |
|||
|
|||
// Make sure A didn't change.
|
|||
for (var i = 0; i < matrixA.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixA.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrixACopy[i, j], matrixA[i, j]); |
|||
} |
|||
} |
|||
|
|||
// Make sure B didn't change.
|
|||
for (var i = 0; i < matrixB.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < matrixB.ColumnCount; j++) |
|||
{ |
|||
Assert.AreEqual(matrixBCopy[i, j], matrixB[i, j]); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,205 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers; |
|||
using LinearAlgebra.Double.Solvers.Iterative; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public class BiCgStabTest |
|||
{ |
|||
private const double ConvergenceBoundary = 1e-10; |
|||
private const int MaximumIterations = 1000; |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveWideMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(2, 3); |
|||
Vector input = new DenseVector(2); |
|||
|
|||
var solver = new BiCgStab(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveLongMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(3, 2); |
|||
Vector input = new DenseVector(3); |
|||
|
|||
var solver = new BiCgStab(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new BiCgStab(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveScaledUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Scale it with a funny number
|
|||
matrix.Multiply(System.Math.PI); |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new BiCgStab(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolvePoissonMatrixAndBackMultiply() |
|||
{ |
|||
// Create the matrix
|
|||
var matrix = new SparseMatrix(100); |
|||
|
|||
// Assemble the matrix. We assume we're solving the Poisson equation
|
|||
// on a rectangular 10 x 10 grid
|
|||
const int GridSize = 10; |
|||
|
|||
// The pattern is:
|
|||
// 0 .... 0 -1 0 0 0 0 0 0 0 0 -1 4 -1 0 0 0 0 0 0 0 0 -1 0 0 ... 0
|
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
// Insert the first set of -1's
|
|||
if (i > (GridSize - 1)) |
|||
{ |
|||
matrix[i, i - GridSize] = -1; |
|||
} |
|||
|
|||
// Insert the second set of -1's
|
|||
if (i > 0) |
|||
{ |
|||
matrix[i, i - 1] = -1; |
|||
} |
|||
|
|||
// Insert the centerline values
|
|||
matrix[i, i] = 4; |
|||
|
|||
// Insert the first trailing set of -1's
|
|||
if (i < matrix.RowCount - 1) |
|||
{ |
|||
matrix[i, i + 1] = -1; |
|||
} |
|||
|
|||
// Insert the second trailing set of -1's
|
|||
if (i < matrix.RowCount - GridSize) |
|||
{ |
|||
matrix[i, i + GridSize] = -1; |
|||
} |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new BiCgStab(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue(System.Math.Abs(y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,207 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers; |
|||
using LinearAlgebra.Double.Solvers.Iterative; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public class GpBiCgTest |
|||
{ |
|||
private const double ConvergenceBoundary = 1e-10; |
|||
private const int MaximumIterations = 1000; |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveWideMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(2, 3); |
|||
Vector input = new DenseVector(2); |
|||
|
|||
var solver = new GpBiCg(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveLongMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(3, 2); |
|||
Vector input = new DenseVector(3); |
|||
|
|||
var solver = new GpBiCg(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new GpBiCg(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveScaledUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Scale it with a funny number
|
|||
matrix.Multiply(System.Math.PI); |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
|
|||
var solver = new GpBiCg(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolvePoissonMatrixAndBackMultiply() |
|||
{ |
|||
// Create the matrix
|
|||
var matrix = new SparseMatrix(100); |
|||
|
|||
// Assemble the matrix. We assume we're solving the Poisson equation
|
|||
// on a rectangular 10 x 10 grid
|
|||
const int GridSize = 10; |
|||
|
|||
// The pattern is:
|
|||
// 0 .... 0 -1 0 0 0 0 0 0 0 0 -1 4 -1 0 0 0 0 0 0 0 0 -1 0 0 ... 0
|
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
// Insert the first set of -1's
|
|||
if (i > (GridSize - 1)) |
|||
{ |
|||
matrix[i, i - GridSize] = -1; |
|||
} |
|||
|
|||
// Insert the second set of -1's
|
|||
if (i > 0) |
|||
{ |
|||
matrix[i, i - 1] = -1; |
|||
} |
|||
|
|||
// Insert the centerline values
|
|||
matrix[i, i] = 4; |
|||
|
|||
// Insert the first trailing set of -1's
|
|||
if (i < matrix.RowCount - 1) |
|||
{ |
|||
matrix[i, i + 1] = -1; |
|||
} |
|||
|
|||
// Insert the second trailing set of -1's
|
|||
if (i < matrix.RowCount - GridSize) |
|||
{ |
|||
matrix[i, i + GridSize] = -1; |
|||
} |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
|
|||
var solver = new GpBiCg(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue(System.Math.Abs(y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,205 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers; |
|||
using LinearAlgebra.Double.Solvers.Iterative; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public class MlkBiCgStabTest |
|||
{ |
|||
private const double ConvergenceBoundary = 1e-10; |
|||
private const int MaximumIterations = 1000; |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveWideMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(2, 3); |
|||
Vector input = new DenseVector(2); |
|||
|
|||
var solver = new MlkBiCgStab(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveLongMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(3, 2); |
|||
Vector input = new DenseVector(3); |
|||
|
|||
var solver = new MlkBiCgStab(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
|
|||
var solver = new MlkBiCgStab(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveScaledUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Scale it with a funny number
|
|||
matrix.Multiply(System.Math.PI); |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new MlkBiCgStab(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolvePoissonMatrixAndBackMultiply() |
|||
{ |
|||
// Create the matrix
|
|||
var matrix = new SparseMatrix(100); |
|||
// Assemble the matrix. We assume we're solving the Poisson equation
|
|||
// on a rectangular 10 x 10 grid
|
|||
const int GridSize = 10; |
|||
|
|||
// The pattern is:
|
|||
// 0 .... 0 -1 0 0 0 0 0 0 0 0 -1 4 -1 0 0 0 0 0 0 0 0 -1 0 0 ... 0
|
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
// Insert the first set of -1's
|
|||
if (i > (GridSize - 1)) |
|||
{ |
|||
matrix[i, i - GridSize] = -1; |
|||
} |
|||
|
|||
// Insert the second set of -1's
|
|||
if (i > 0) |
|||
{ |
|||
matrix[i, i - 1] = -1; |
|||
} |
|||
|
|||
// Insert the centerline values
|
|||
matrix[i, i] = 4; |
|||
|
|||
// Insert the first trailing set of -1's
|
|||
if (i < matrix.RowCount - 1) |
|||
{ |
|||
matrix[i, i + 1] = -1; |
|||
} |
|||
|
|||
// Insert the second trailing set of -1's
|
|||
if (i < matrix.RowCount - GridSize) |
|||
{ |
|||
matrix[i, i + GridSize] = -1; |
|||
} |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new MlkBiCgStab(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue(System.Math.Abs(y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,204 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers; |
|||
using LinearAlgebra.Double.Solvers.Iterative; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public class TFQMRTest |
|||
{ |
|||
private const double ConvergenceBoundary = 1e-10; |
|||
private const int MaximumIterations = 1000; |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveWideMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(2, 3); |
|||
Vector input = new DenseVector(2); |
|||
|
|||
var solver = new TFQMR(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void SolveLongMatrix() |
|||
{ |
|||
var matrix = new SparseMatrix(3, 2); |
|||
Vector input = new DenseVector(3); |
|||
|
|||
var solver = new TFQMR(); |
|||
solver.Solve(matrix, input); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
|
|||
var solver = new TFQMR(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveScaledUnitMatrixAndBackMultiply() |
|||
{ |
|||
// Create the identity matrix
|
|||
Matrix matrix = new SparseMatrix(100); |
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
matrix[i, i] = 1.0; |
|||
} |
|||
// Scale it with a funny number
|
|||
matrix.Multiply(System.Math.PI); |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new TFQMR(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue((y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolvePoissonMatrixAndBackMultiply() |
|||
{ |
|||
// Create the matrix
|
|||
var matrix = new SparseMatrix(100); |
|||
// Assemble the matrix. We assume we're solving the Poisson equation
|
|||
// on a rectangular 10 x 10 grid
|
|||
const int GridSize = 10; |
|||
|
|||
// The pattern is:
|
|||
// 0 .... 0 -1 0 0 0 0 0 0 0 0 -1 4 -1 0 0 0 0 0 0 0 0 -1 0 0 ... 0
|
|||
for (var i = 0; i < matrix.RowCount; i++) |
|||
{ |
|||
// Insert the first set of -1's
|
|||
if (i > (GridSize - 1)) |
|||
{ |
|||
matrix[i, i - GridSize] = -1; |
|||
} |
|||
|
|||
// Insert the second set of -1's
|
|||
if (i > 0) |
|||
{ |
|||
matrix[i, i - 1] = -1; |
|||
} |
|||
|
|||
// Insert the centerline values
|
|||
matrix[i, i] = 4; |
|||
|
|||
// Insert the first trailing set of -1's
|
|||
if (i < matrix.RowCount - 1) |
|||
{ |
|||
matrix[i, i + 1] = -1; |
|||
} |
|||
|
|||
// Insert the second trailing set of -1's
|
|||
if (i < matrix.RowCount - GridSize) |
|||
{ |
|||
matrix[i, i + GridSize] = -1; |
|||
} |
|||
} |
|||
|
|||
// Create the y vector
|
|||
Vector y = new DenseVector(matrix.RowCount, 1); |
|||
|
|||
// Create an iteration monitor which will keep track of iterative convergence
|
|||
var monitor = new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new IterationCountStopCriterium(MaximumIterations), |
|||
new ResidualStopCriterium(ConvergenceBoundary), |
|||
new DivergenceStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
var solver = new TFQMR(monitor); |
|||
|
|||
// Solve equation Ax = y
|
|||
var x = solver.Solve(matrix, y); |
|||
|
|||
// Now compare the results
|
|||
Assert.IsNotNull(x, "#02"); |
|||
Assert.AreEqual(y.Count, x.Count, "#03"); |
|||
|
|||
// Back multiply the vector
|
|||
var z = matrix.Multiply(x); |
|||
|
|||
// Check that the solution converged
|
|||
Assert.IsTrue(monitor.Status is CalculationConverged, "#04"); |
|||
|
|||
// Now compare the vectors
|
|||
for (var i = 0; i < y.Count; i++) |
|||
{ |
|||
Assert.IsTrue(System.Math.Abs(y[i] - z[i]).IsSmaller(ConvergenceBoundary, 1), "#05-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,353 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers |
|||
{ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public class IteratorTest |
|||
{ |
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CreateWithNullCollection() |
|||
{ |
|||
var iterator = new Iterator(null); |
|||
Assert.IsNotNull(iterator, "Should have an iterator"); |
|||
Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CreateWithEmptyCollection() |
|||
{ |
|||
var iterator = new Iterator(new IIterationStopCriterium[] { }); |
|||
Assert.IsNotNull(iterator, "Should have an iterator"); |
|||
Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CreateWithCollectionWithNulls() |
|||
{ |
|||
var iterator = new Iterator(new IIterationStopCriterium[] { null, null }); |
|||
Assert.IsNotNull(iterator, "Should have an iterator"); |
|||
Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria"); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void CreateWithDuplicates() |
|||
{ |
|||
new Iterator(new IIterationStopCriterium[] |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new FailureStopCriterium() |
|||
}); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CreateWithCollection() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
Assert.IsNotNull(iterator, "Should have an iterator"); |
|||
|
|||
// Check that we have all the criteria
|
|||
Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
var enumerator = iterator.StoredStopCriteria; |
|||
while (enumerator.MoveNext()) |
|||
{ |
|||
var criterium = enumerator.Current; |
|||
Assert.IsTrue(criteria.Exists( c => ReferenceEquals(c, criterium)), "Criterium missing"); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void AddWithNullStopCriterium() |
|||
{ |
|||
var iterator = new Iterator(); |
|||
iterator.Add(null); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void AddWithExistingStopCriterium() |
|||
{ |
|||
var iterator = new Iterator(); |
|||
iterator.Add(new FailureStopCriterium()); |
|||
Assert.AreEqual(1, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
|
|||
iterator.Add(new FailureStopCriterium()); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Add() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(); |
|||
Assert.AreEqual(0, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
|
|||
foreach (var criterium in criteria) |
|||
{ |
|||
iterator.Add(criterium); |
|||
Assert.IsTrue(iterator.Contains(criterium), "Missing criterium"); |
|||
} |
|||
|
|||
// Check that we have all the criteria
|
|||
Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
var enumerator = iterator.StoredStopCriteria; |
|||
while (enumerator.MoveNext()) |
|||
{ |
|||
var criterium = enumerator.Current; |
|||
Assert.IsTrue(criteria.Exists( c => ReferenceEquals(c, criterium)), "Criterium missing"); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void RemoveWithNullStopCriterium() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
|
|||
iterator.Remove(null); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void RemoveWithNonExistingStopCriterium() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
|
|||
iterator.Remove(new ResidualStopCriterium()); |
|||
Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Remove() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count"); |
|||
|
|||
foreach (var criterium in criteria) |
|||
{ |
|||
iterator.Remove(criterium); |
|||
Assert.IsFalse(iterator.Contains(criterium), "Did not remove the criterium"); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void DetermineStatusWithoutStopCriteria() |
|||
{ |
|||
var iterator = new Iterator(); |
|||
iterator.DetermineStatus(0, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
new DenseVector(3, 6)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedException(typeof(ArgumentOutOfRangeException))] |
|||
public void DetermineStatusWithNegativeIterationNumber() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
|
|||
iterator.DetermineStatus(-1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
new DenseVector(3, 6)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullSolutionVector() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
|
|||
iterator.DetermineStatus(1, |
|||
null, |
|||
new DenseVector(3, 5), |
|||
new DenseVector(3, 6)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullSourceVector() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
|
|||
iterator.DetermineStatus(1, |
|||
new DenseVector(3, 5), |
|||
null, |
|||
new DenseVector(3, 6)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullResidualVector() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
var iterator = new Iterator(criteria); |
|||
|
|||
iterator.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
null); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatus() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(1) |
|||
}; |
|||
|
|||
var iterator = new Iterator(criteria); |
|||
|
|||
// First step, nothing should happen.
|
|||
iterator.DetermineStatus(0, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4)); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), iterator.Status, "Incorrect status"); |
|||
|
|||
// Second step, should run out of iterations.
|
|||
iterator.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4)); |
|||
Assert.IsInstanceOfType(typeof(CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetToPrecalculationState() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(1) |
|||
}; |
|||
|
|||
var iterator = new Iterator(criteria); |
|||
|
|||
// First step, nothing should happen.
|
|||
iterator.DetermineStatus(0, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4)); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), iterator.Status, "Incorrect status"); |
|||
|
|||
iterator.ResetToPrecalculationState(); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), iterator.Status, "Incorrect status"); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criteria[0].Status, "Incorrect status"); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criteria[1].Status, "Incorrect status"); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criteria[2].Status, "Incorrect status"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Clone() |
|||
{ |
|||
var criteria = new List<IIterationStopCriterium> |
|||
{ |
|||
new FailureStopCriterium(), |
|||
new DivergenceStopCriterium(), |
|||
new IterationCountStopCriterium(), |
|||
new ResidualStopCriterium() |
|||
}; |
|||
|
|||
var iterator = new Iterator(criteria); |
|||
|
|||
var clonedIterator = iterator.Clone(); |
|||
Assert.IsInstanceOfType(typeof(Iterator), clonedIterator, "Incorrect type"); |
|||
|
|||
var clone = clonedIterator as Iterator; |
|||
Assert.IsNotNull(clone); |
|||
// ReSharper disable PossibleNullReferenceException
|
|||
Assert.AreEqual(iterator.NumberOfCriteria, clone.NumberOfCriteria, "Incorrect criterium count"); |
|||
// ReSharper restore PossibleNullReferenceException
|
|||
|
|||
var enumerator = clone.StoredStopCriteria; |
|||
while (enumerator.MoveNext()) |
|||
{ |
|||
var criterium = enumerator.Current; |
|||
Assert.IsTrue(criteria.Exists(c => c.GetType().Equals(criterium.GetType())), "Criterium missing"); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,30 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Preconditioners; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class DiagonalTest : PreconditionerTest |
|||
{ |
|||
internal override IPreConditioner CreatePreconditioner() |
|||
{ |
|||
return new Diagonal(); |
|||
} |
|||
|
|||
protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector vector, Vector result) |
|||
{ |
|||
Assert.AreEqual(typeof(Diagonal), preconditioner.GetType(), "#01"); |
|||
|
|||
// Compute M * result = product
|
|||
// compare vector and product. Should be equal
|
|||
Vector product = new DenseVector(result.Count); |
|||
matrix.Multiply(result, product); |
|||
|
|||
for (var i = 0; i < product.Count; i++) |
|||
{ |
|||
Assert.IsTrue(vector[i].AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,502 @@ |
|||
// NOTE: This class file Build Action is not set to Compile by default. Because IlutpElementSorter class is internal. If you want
|
|||
// NOTE: to test IlutpElementSorter you should make it public, set Build Action=Compile of this file (in properties) and run tets.
|
|||
// NOTE: After all tests passed please do all actions vice versa. IlutpElementSorter class is only for internal usage.
|
|||
|
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Preconditioners; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class IluptElementSorterTest |
|||
{ |
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithIncreasingIntergerArray() |
|||
{ |
|||
var sortedIndices = new [] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 1 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithDecreasingIntegerArray() |
|||
{ |
|||
var sortedIndices = new [] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 1 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithRandomIntegerArray() |
|||
{ |
|||
var sortedIndices = new []{ 5, 2, 8, 6, 0, 4, 1, 7, 3, 9 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 1 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithDuplicateEntries() |
|||
{ |
|||
var sortedIndices = new []{ 1, 1, 1, 1, 2, 2, 2, 2, 3, 4 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(4, sortedIndices[i], "#01-" + i); |
|||
} |
|||
else |
|||
{ |
|||
if (i == 1) |
|||
{ |
|||
Assert.AreEqual(3, sortedIndices[i], "#01-" + i); |
|||
} |
|||
else |
|||
{ |
|||
if (i < 6) |
|||
{ |
|||
if (sortedIndices[i] != 2) |
|||
{ |
|||
Assert.Fail("#01-" + i); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
if (sortedIndices[i] != 1) |
|||
{ |
|||
Assert.Fail("#01-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithSpecialConstructedIntegerArray() |
|||
{ |
|||
var sortedIndices = new []{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(1, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
sortedIndices = new []{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(1, sortedIndices[i], "#02-" + i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
sortedIndices = new []{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(1, sortedIndices[i], "#03-" + i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
sortedIndices = new []{ 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 }; |
|||
IlutpElementSorter.SortIntegersDecreasing(sortedIndices); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 9) |
|||
{ |
|||
Assert.AreEqual(0, sortedIndices[i], "#04-" + i); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithIncreasingDoubleArray() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 0; |
|||
values[1] = 1; |
|||
values[2] = 2; |
|||
values[3] = 3; |
|||
values[4] = 4; |
|||
values[5] = 5; |
|||
values[6] = 6; |
|||
values[7] = 7; |
|||
values[8] = 8; |
|||
values[9] = 9; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 1 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithDecreasingDoubleArray() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 9; |
|||
values[1] = 8; |
|||
values[2] = 7; |
|||
values[3] = 6; |
|||
values[4] = 5; |
|||
values[5] = 4; |
|||
values[6] = 3; |
|||
values[7] = 2; |
|||
values[8] = 1; |
|||
values[9] = 0; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
Assert.AreEqual(i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithRandomDoubleArray() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 5; |
|||
values[1] = 2; |
|||
values[2] = 8; |
|||
values[3] = 6; |
|||
values[4] = 0; |
|||
values[5] = 4; |
|||
values[6] = 1; |
|||
values[7] = 7; |
|||
values[8] = 3; |
|||
values[9] = 9; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
switch (i) |
|||
{ |
|||
case 0: |
|||
Assert.AreEqual(9, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 1: |
|||
Assert.AreEqual(2, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 2: |
|||
Assert.AreEqual(7, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 3: |
|||
Assert.AreEqual(3, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 4: |
|||
Assert.AreEqual(0, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 5: |
|||
Assert.AreEqual(5, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 6: |
|||
Assert.AreEqual(8, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 7: |
|||
Assert.AreEqual(1, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 8: |
|||
Assert.AreEqual(6, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
case 9: |
|||
Assert.AreEqual(4, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithDuplicateDoubleEntries() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 1; |
|||
values[1] = 1; |
|||
values[2] = 1; |
|||
values[3] = 1; |
|||
values[4] = 2; |
|||
values[5] = 2; |
|||
values[6] = 2; |
|||
values[7] = 2; |
|||
values[8] = 3; |
|||
values[9] = 4; |
|||
|
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(9, sortedIndices[i], "#01-" + i); |
|||
} |
|||
else |
|||
{ |
|||
if (i == 1) |
|||
{ |
|||
Assert.AreEqual(8, sortedIndices[i], "#01-" + i); |
|||
} |
|||
else |
|||
{ |
|||
if (i < 6) |
|||
{ |
|||
if ((sortedIndices[i] != 4) && |
|||
(sortedIndices[i] != 5) && |
|||
(sortedIndices[i] != 6) && |
|||
(sortedIndices[i] != 7)) |
|||
{ |
|||
Assert.Fail("#01-" + i); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
if ((sortedIndices[i] != 0) && |
|||
(sortedIndices[i] != 1) && |
|||
(sortedIndices[i] != 2) && |
|||
(sortedIndices[i] != 3)) |
|||
{ |
|||
Assert.Fail("#01-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithSpecialConstructedDoubleArray() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 0; |
|||
values[1] = 0; |
|||
values[2] = 0; |
|||
values[3] = 0; |
|||
values[4] = 0; |
|||
values[5] = 1; |
|||
values[6] = 0; |
|||
values[7] = 0; |
|||
values[8] = 0; |
|||
values[9] = 0; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(5, sortedIndices[i], "#01-" + i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
values[0] = 1; |
|||
values[1] = 0; |
|||
values[2] = 0; |
|||
values[3] = 0; |
|||
values[4] = 0; |
|||
values[5] = 0; |
|||
values[6] = 0; |
|||
values[7] = 0; |
|||
values[8] = 0; |
|||
values[9] = 0; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(0, sortedIndices[i], "#02-" + i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
values[0] = 0; |
|||
values[1] = 0; |
|||
values[2] = 0; |
|||
values[3] = 0; |
|||
values[4] = 0; |
|||
values[5] = 0; |
|||
values[6] = 0; |
|||
values[7] = 0; |
|||
values[8] = 0; |
|||
values[9] = 1; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 0) |
|||
{ |
|||
Assert.AreEqual(9, sortedIndices[i], "#03-" + i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
values[0] = 1; |
|||
values[1] = 1; |
|||
values[2] = 1; |
|||
values[3] = 0; |
|||
values[4] = 1; |
|||
values[5] = 1; |
|||
values[6] = 1; |
|||
values[7] = 1; |
|||
values[8] = 1; |
|||
values[9] = 1; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
if (i == 9) |
|||
{ |
|||
Assert.AreEqual(3, sortedIndices[i], "#04-" + i); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithIncreasingDoubleArrayWithLowerBound() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 0; |
|||
values[1] = 1; |
|||
values[2] = 2; |
|||
values[3] = 3; |
|||
values[4] = 4; |
|||
values[5] = 5; |
|||
values[6] = 6; |
|||
values[7] = 7; |
|||
values[8] = 8; |
|||
values[9] = 9; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(4, sortedIndices.Length - 1, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length - 4; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 1 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithIncreasingDoubleArrayWithUpperBound() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 0; |
|||
values[1] = 1; |
|||
values[2] = 2; |
|||
values[3] = 3; |
|||
values[4] = 4; |
|||
values[5] = 5; |
|||
values[6] = 6; |
|||
values[7] = 7; |
|||
values[8] = 8; |
|||
values[9] = 9; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(0, sortedIndices.Length - 5, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length - 5; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 5 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void HeapSortWithIncreasingDoubleArrayWithLowerAndUpperBound() |
|||
{ |
|||
var sortedIndices = new int[10]; |
|||
Vector values = new DenseVector(10); |
|||
values[0] = 0; |
|||
values[1] = 1; |
|||
values[2] = 2; |
|||
values[3] = 3; |
|||
values[4] = 4; |
|||
values[5] = 5; |
|||
values[6] = 6; |
|||
values[7] = 7; |
|||
values[8] = 8; |
|||
values[9] = 9; |
|||
for (var i = 0; i < sortedIndices.Length; i++) |
|||
{ |
|||
sortedIndices[i] = i; |
|||
} |
|||
|
|||
IlutpElementSorter.SortDoubleIndicesDecreasing(2, sortedIndices.Length - 3, sortedIndices, values); |
|||
for (var i = 0; i < sortedIndices.Length - 4; i++) |
|||
{ |
|||
Assert.AreEqual(sortedIndices.Length - 3 - i, sortedIndices[i], "#01-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,248 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners |
|||
{ |
|||
using System; |
|||
using System.Reflection; |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Preconditioners; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class IlutpPreconditionerTest : PreconditionerTest |
|||
{ |
|||
private double _dropTolerance = 0.1; |
|||
private double _fillLevel = 1.0; |
|||
private double _pivotTolerance = 1.0; |
|||
|
|||
[SetUp] |
|||
public void Setup() |
|||
{ |
|||
_dropTolerance = 0.1; |
|||
_fillLevel = 1.0; |
|||
_pivotTolerance = 1.0; |
|||
} |
|||
|
|||
private static T GetMethod<T>(Ilutp ilutp, string methodName) |
|||
{ |
|||
var type = ilutp.GetType(); |
|||
var methodInfo = type.GetMethod(methodName, |
|||
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, |
|||
null, |
|||
CallingConventions.Standard, |
|||
new Type[0], |
|||
null); |
|||
var obj = methodInfo.Invoke(ilutp, null); |
|||
return (T)obj; |
|||
} |
|||
|
|||
private static SparseMatrix GetUpperTriangle(Ilutp ilutp) |
|||
{ |
|||
return GetMethod<SparseMatrix>(ilutp, "UpperTriangle"); |
|||
} |
|||
|
|||
private static SparseMatrix GetLowerTriangle(Ilutp ilutp) |
|||
{ |
|||
return GetMethod<SparseMatrix>(ilutp, "LowerTriangle"); |
|||
} |
|||
|
|||
private static int[] GetPivots(Ilutp ilutp) |
|||
{ |
|||
return GetMethod<int[]>(ilutp, "Pivots"); |
|||
} |
|||
|
|||
private static SparseMatrix CreateReverseUnitMatrix(int size) |
|||
{ |
|||
var matrix = new SparseMatrix(size); |
|||
for (var i = 0; i < size; i++) |
|||
{ |
|||
matrix[i, size - 1 - i] = 2; |
|||
} |
|||
|
|||
return matrix; |
|||
} |
|||
|
|||
private Ilutp InternalCreatePreconditioner() |
|||
{ |
|||
var result = new Ilutp |
|||
{ |
|||
DropTolerance = _dropTolerance, |
|||
FillLevel = _fillLevel, |
|||
PivotTolerance = _pivotTolerance |
|||
}; |
|||
return result; |
|||
} |
|||
|
|||
internal override IPreConditioner CreatePreconditioner() |
|||
{ |
|||
_pivotTolerance = 0; |
|||
_dropTolerance = 0.0; |
|||
_fillLevel = 100; |
|||
return InternalCreatePreconditioner(); |
|||
} |
|||
|
|||
protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector vector, Vector result) |
|||
{ |
|||
Assert.AreEqual(typeof(Ilutp), preconditioner.GetType(), "#01"); |
|||
|
|||
// Compute M * result = product
|
|||
// compare vector and product. Should be equal
|
|||
Vector product = new DenseVector(result.Count); |
|||
matrix.Multiply(result, product); |
|||
for (var i = 0; i < product.Count; i++) |
|||
{ |
|||
Assert.IsTrue(vector[i].AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveReturningOldVectorWithoutPivoting() |
|||
{ |
|||
const int Size = 10; |
|||
|
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
// set the pivot tolerance to zero so we don't pivot
|
|||
_pivotTolerance = 0.0; |
|||
_dropTolerance = 0.0; |
|||
_fillLevel = 100; |
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
Vector result = new DenseVector(vector.Count); |
|||
preconditioner.Approximate(vector, result); |
|||
CheckResult(preconditioner, newMatrix, vector, result); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveReturningOldVectorWithPivoting() |
|||
{ |
|||
const int Size = 10; |
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
// Set the pivot tolerance to 1 so we always pivot (if necessary)
|
|||
_pivotTolerance = 1.0; |
|||
_dropTolerance = 0.0; |
|||
_fillLevel = 100; |
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
Vector result = new DenseVector(vector.Count); |
|||
preconditioner.Approximate(vector, result); |
|||
CheckResult(preconditioner, newMatrix, vector, result); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CompareWithOriginalDenseMatrixWithoutPivoting() |
|||
{ |
|||
var sparseMatrix = new SparseMatrix(3); |
|||
sparseMatrix[0, 0] = -1; |
|||
sparseMatrix[0, 1] = 5; |
|||
sparseMatrix[0, 2] = 6; |
|||
sparseMatrix[1, 0] = 3; |
|||
sparseMatrix[1, 1] = -6; |
|||
sparseMatrix[1, 2] = 1; |
|||
sparseMatrix[2, 0] = 6; |
|||
sparseMatrix[2, 1] = 8; |
|||
sparseMatrix[2, 2] = 9; |
|||
var ilu = new Ilutp |
|||
{ |
|||
PivotTolerance = 0.0, |
|||
DropTolerance = 0, |
|||
FillLevel = 10 |
|||
}; |
|||
ilu.Initialize(sparseMatrix); |
|||
var l = GetLowerTriangle(ilu); |
|||
|
|||
// Assert l is lower triagonal
|
|||
for (var i = 0; i < l.RowCount; i++) |
|||
{ |
|||
for (var j = i + 1; j < l.RowCount; j++) |
|||
{ |
|||
Assert.IsTrue(0.0.AlmostEqual(l[i,j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); |
|||
} |
|||
} |
|||
|
|||
var u = GetUpperTriangle(ilu); |
|||
|
|||
// Assert u is upper triagonal
|
|||
for (var i = 0; i < u.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < i; j++) |
|||
{ |
|||
Assert.IsTrue(0.0.AlmostEqual(u[i,j], -Epsilon.Magnitude()), "#02-" + i + "-" + j); |
|||
} |
|||
} |
|||
|
|||
var original = l.Multiply(u); |
|||
for (var i = 0; i < sparseMatrix.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < sparseMatrix.ColumnCount; j++) |
|||
{ |
|||
Assert.IsTrue(sparseMatrix[i,j].AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#03-" + i + "-" + j); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CompareWithOriginalDenseMatrixWithPivoting() |
|||
{ |
|||
var sparseMatrix = new SparseMatrix(3); |
|||
sparseMatrix[0, 0] = -1; |
|||
sparseMatrix[0, 1] = 5; |
|||
sparseMatrix[0, 2] = 6; |
|||
sparseMatrix[1, 0] = 3; |
|||
sparseMatrix[1, 1] = -6; |
|||
sparseMatrix[1, 2] = 1; |
|||
sparseMatrix[2, 0] = 6; |
|||
sparseMatrix[2, 1] = 8; |
|||
sparseMatrix[2, 2] = 9; |
|||
var ilu = new Ilutp |
|||
{ |
|||
PivotTolerance = 1.0, |
|||
DropTolerance = 0, |
|||
FillLevel = 10 |
|||
}; |
|||
ilu.Initialize(sparseMatrix); |
|||
var l = GetLowerTriangle(ilu); |
|||
var u = GetUpperTriangle(ilu); |
|||
var pivots = GetPivots(ilu); |
|||
var p = new SparseMatrix(l.RowCount); |
|||
for (var i = 0; i < p.RowCount; i++) |
|||
{ |
|||
p[i, pivots[i]] = 1.0; |
|||
} |
|||
|
|||
var temp = l.Multiply(u); |
|||
var original = temp.Multiply(p); |
|||
for (var i = 0; i < sparseMatrix.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < sparseMatrix.ColumnCount; j++) |
|||
{ |
|||
Assert.IsTrue(sparseMatrix[i, j].AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void SolveWithPivoting() |
|||
{ |
|||
const int Size = 10; |
|||
var newMatrix = CreateReverseUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
var preconditioner = new Ilutp |
|||
{ |
|||
PivotTolerance = 1.0, |
|||
DropTolerance = 0, |
|||
FillLevel = 10 |
|||
}; |
|||
preconditioner.Initialize(newMatrix); |
|||
Vector result = new DenseVector(vector.Count); |
|||
preconditioner.Approximate(vector, result); |
|||
CheckResult(preconditioner, newMatrix, vector, result); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,82 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners |
|||
{ |
|||
using System; |
|||
using System.Reflection; |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Preconditioners; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class IncompleteLUFactorizationTest : PreconditionerTest |
|||
{ |
|||
private static T GetMethod<T>(IncompleteLU ilu, string methodName) |
|||
{ |
|||
var type = ilu.GetType(); |
|||
var methodInfo = type.GetMethod(methodName, |
|||
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, |
|||
null, |
|||
CallingConventions.Standard, |
|||
new Type[0], |
|||
null); |
|||
var obj = methodInfo.Invoke(ilu, null); |
|||
return (T)obj; |
|||
} |
|||
|
|||
private static Matrix GetUpperTriangle(IncompleteLU ilu) |
|||
{ |
|||
return GetMethod<Matrix>(ilu, "UpperTriangle"); |
|||
} |
|||
|
|||
private static Matrix GetLowerTriangle(IncompleteLU ilu) |
|||
{ |
|||
return GetMethod<Matrix>(ilu, "LowerTriangle"); |
|||
} |
|||
|
|||
internal override IPreConditioner CreatePreconditioner() |
|||
{ |
|||
return new IncompleteLU(); |
|||
} |
|||
|
|||
protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector vector, Vector result) |
|||
{ |
|||
Assert.AreEqual(typeof(IncompleteLU), preconditioner.GetType(), "#01"); |
|||
|
|||
// Compute M * result = product
|
|||
// compare vector and product. Should be equal
|
|||
Vector product = new DenseVector(result.Count); |
|||
matrix.Multiply(result, product); |
|||
|
|||
for (var i = 0; i < product.Count; i++) |
|||
{ |
|||
Assert.IsTrue(vector[i].AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void CompareWithOriginalDenseMatrix() |
|||
{ |
|||
var sparseMatrix = new SparseMatrix(3); |
|||
sparseMatrix[0, 0] = -1; |
|||
sparseMatrix[0, 1] = 5; |
|||
sparseMatrix[0, 2] = 6; |
|||
sparseMatrix[1, 0] = 3; |
|||
sparseMatrix[1, 1] = -6; |
|||
sparseMatrix[1, 2] = 1; |
|||
sparseMatrix[2, 0] = 6; |
|||
sparseMatrix[2, 1] = 8; |
|||
sparseMatrix[2, 2] = 9; |
|||
var ilu = new IncompleteLU(); |
|||
ilu.Initialize(sparseMatrix); |
|||
var original = GetLowerTriangle(ilu).Multiply(GetUpperTriangle(ilu)); |
|||
|
|||
for (var i = 0; i < sparseMatrix.RowCount; i++) |
|||
{ |
|||
for (var j = 0; j < sparseMatrix.ColumnCount; j++) |
|||
{ |
|||
Assert.IsTrue(sparseMatrix[i, j].AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,126 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Preconditioners; |
|||
using MbUnit.Framework; |
|||
|
|||
public abstract class PreconditionerTest |
|||
{ |
|||
protected const double Epsilon = 1e-10; |
|||
|
|||
internal SparseMatrix CreateUnitMatrix(int size) |
|||
{ |
|||
var matrix = new SparseMatrix(size); |
|||
for (var i = 0; i < size; i++) |
|||
{ |
|||
matrix[i, i] = 2; |
|||
} |
|||
|
|||
return matrix; |
|||
} |
|||
|
|||
protected Vector CreateStandardBcVector(int size) |
|||
{ |
|||
Vector vector = new DenseVector(size); |
|||
for (var i = 0; i < size; i++) |
|||
{ |
|||
vector[i] = i + 1; |
|||
} |
|||
|
|||
return vector; |
|||
} |
|||
|
|||
internal abstract IPreConditioner CreatePreconditioner(); |
|||
|
|||
protected abstract void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector vector, Vector result); |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ApproximateWithUnitMatrixReturningNewVector() |
|||
{ |
|||
const int Size = 10; |
|||
|
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
|
|||
var result = preconditioner.Approximate(vector); |
|||
|
|||
CheckResult(preconditioner, newMatrix, vector, result); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ApproximateReturningOldVector() |
|||
{ |
|||
const int Size = 10; |
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
|
|||
Vector result = new DenseVector(vector.Count); |
|||
preconditioner.Approximate(vector, result); |
|||
|
|||
CheckResult(preconditioner, newMatrix, vector, result); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void ApproximateWithVectorWithIncorrectLength() |
|||
{ |
|||
const int Size = 10; |
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
|
|||
Vector result = new DenseVector(vector.Count + 10); |
|||
preconditioner.Approximate(vector, result); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void ApproximateWithNullVector() |
|||
{ |
|||
const int Size = 10; |
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
|
|||
Vector result = new DenseVector(vector.Count + 10); |
|||
preconditioner.Approximate(null, result); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void ApproximateWithNullResultVector() |
|||
{ |
|||
const int Size = 10; |
|||
var newMatrix = CreateUnitMatrix(Size); |
|||
var vector = CreateStandardBcVector(Size); |
|||
|
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Initialize(newMatrix); |
|||
|
|||
Vector result = null; |
|||
preconditioner.Approximate(vector, result); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void ApproximateWithNonInitializedPreconditioner() |
|||
{ |
|||
const int Size = 10; |
|||
var vector = CreateStandardBcVector(Size); |
|||
var preconditioner = CreatePreconditioner(); |
|||
preconditioner.Approximate(vector); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,27 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Preconditioners; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class UnitPreconditionerTest : PreconditionerTest |
|||
{ |
|||
internal override IPreConditioner CreatePreconditioner() |
|||
{ |
|||
return new UnitPreconditioner(); |
|||
} |
|||
|
|||
protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector vector, Vector result) |
|||
{ |
|||
Assert.AreEqual(typeof(UnitPreconditioner), preconditioner.GetType(), "#01"); |
|||
|
|||
// Unit preconditioner is doing nothing. Vector and result should be equal
|
|||
|
|||
for (var i = 0; i < vector.Count; i++) |
|||
{ |
|||
Assert.IsTrue(vector[i] == result[i], "#02-" + i); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,233 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCriterium |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class DivergenceStopCriteriumTest |
|||
{ |
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void CreateWithNegativeMaximumIncrease() |
|||
{ |
|||
new DivergenceStopCriterium(-0.1); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void CreateWithIllegalMinimumIterations() |
|||
{ |
|||
new DivergenceStopCriterium(2); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Create() |
|||
{ |
|||
var criterium = new DivergenceStopCriterium(0.1, 3); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
Assert.AreEqual(0.1, criterium.MaximumRelativeIncrease, "Incorrect maximum"); |
|||
Assert.AreEqual(3, criterium.MinimumNumberOfIterations, "Incorrect iteration count"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetMaximumIncrease() |
|||
{ |
|||
var criterium = new DivergenceStopCriterium(0.5, 3); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
Assert.AreEqual(0.5, criterium.MaximumRelativeIncrease, "Incorrect maximum"); |
|||
|
|||
criterium.ResetMaximumRelativeIncreaseToDefault(); |
|||
Assert.AreEqual(DivergenceStopCriterium.DefaultMaximumRelativeIncrease, criterium.MaximumRelativeIncrease, "Incorrect value"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetMinimumIterationsBelowMaximum() |
|||
{ |
|||
var criterium = new DivergenceStopCriterium(0.5, 15); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
Assert.AreEqual(15, criterium.MinimumNumberOfIterations, "Incorrect iteration count"); |
|||
|
|||
criterium.ResetNumberOfIterationsToDefault(); |
|||
Assert.AreEqual(DivergenceStopCriterium.DefaultMinimumNumberOfIterations, criterium.MinimumNumberOfIterations, "Incorrect value"); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void DetermineStatusWithIllegalIterationNumber() |
|||
{ |
|||
var criterium = new DivergenceStopCriterium(0.5, 15); |
|||
criterium.DetermineStatus(-1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
new DenseVector(3, 6)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullResidualVector() |
|||
{ |
|||
var criterium = new DivergenceStopCriterium(0.5, 15); |
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
null); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithTooFewIterations() |
|||
{ |
|||
const double Increase = 0.5; |
|||
const int Iterations = 10; |
|||
|
|||
var criterium = new DivergenceStopCriterium(Increase, Iterations); |
|||
|
|||
// Add residuals. We should not diverge because we'll have to few iterations
|
|||
for (var i = 0; i < Iterations - 1; i++) |
|||
{ |
|||
criterium.DetermineStatus(i, |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { (i + 1) * (Increase + 0.1) })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Status check fail."); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithNoDivergence() |
|||
{ |
|||
const double Increase = 0.5; |
|||
const int Iterations = 10; |
|||
|
|||
var criterium = new DivergenceStopCriterium(Increase, Iterations); |
|||
|
|||
// Add residuals. We should not diverge because we won't have enough increase
|
|||
for (var i = 0; i < Iterations * 2; i++) |
|||
{ |
|||
criterium.DetermineStatus(i, |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { (i + 1) * (Increase - 0.01) })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Status check fail."); |
|||
} |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithDivergenceThroughNaN() |
|||
{ |
|||
const double Increase = 0.5; |
|||
const int Iterations = 10; |
|||
|
|||
var criterium = new DivergenceStopCriterium(Increase, Iterations); |
|||
|
|||
// Add residuals. We should not diverge because we'll have to few iterations
|
|||
for (var i = 0; i < Iterations - 5; i++) |
|||
{ |
|||
criterium.DetermineStatus(i, |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { (i + 1) * (Increase - 0.01) })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Status check fail."); |
|||
} |
|||
|
|||
// Now make it fail by throwing in a NaN
|
|||
criterium.DetermineStatus(Iterations, |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { double.NaN })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationDiverged), criterium.Status, "Status check fail."); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithDivergence() |
|||
{ |
|||
const double Increase = 0.5; |
|||
const int Iterations = 10; |
|||
|
|||
var criterium = new DivergenceStopCriterium(Increase, Iterations); |
|||
|
|||
// Add residuals. We should not diverge because we'll have one to few iterations
|
|||
double previous = 1; |
|||
for (var i = 0; i < Iterations - 1; i++) |
|||
{ |
|||
previous *= (1 + Increase + 0.01); |
|||
criterium.DetermineStatus(i, |
|||
new DenseVector(new[] { 1.0 }), |
|||
new DenseVector(new[] { 1.0 }), |
|||
new DenseVector(new[] { previous })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Status check fail."); |
|||
} |
|||
|
|||
// Add the final residual. Now we should have divergence
|
|||
previous *= (1 + Increase + 0.01); |
|||
criterium.DetermineStatus(Iterations - 1, |
|||
new DenseVector(new[] { 1.0 }), |
|||
new DenseVector(new[] { 1.0 }), |
|||
new DenseVector(new[] { previous })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationDiverged), criterium.Status, "Status check fail."); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetCalculationState() |
|||
{ |
|||
const double Increase = 0.5; |
|||
const int Iterations = 10; |
|||
|
|||
var criterium = new DivergenceStopCriterium(Increase, Iterations); |
|||
|
|||
// Add residuals. Blow it up instantly
|
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { 1.0 }), |
|||
new DenseVector(new [] { double.NaN })); |
|||
|
|||
Assert.IsInstanceOfType(typeof(CalculationDiverged), criterium.Status, "Status check fail."); |
|||
|
|||
// Reset the state
|
|||
criterium.ResetToPrecalculationState(); |
|||
|
|||
Assert.AreEqual(Increase, criterium.MaximumRelativeIncrease, "Incorrect maximum"); |
|||
Assert.AreEqual(Iterations, criterium.MinimumNumberOfIterations, "Incorrect iteration count"); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criterium.Status, "Status check fail."); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Clone() |
|||
{ |
|||
const double Increase = 0.5; |
|||
const int Iterations = 10; |
|||
|
|||
var criterium = new DivergenceStopCriterium(Increase, Iterations); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var clone = criterium.Clone(); |
|||
Assert.IsInstanceOfType(typeof(DivergenceStopCriterium), clone, "Wrong criterium type"); |
|||
|
|||
var clonedCriterium = clone as DivergenceStopCriterium; |
|||
Assert.IsNotNull(clonedCriterium); |
|||
// ReSharper disable PossibleNullReferenceException
|
|||
Assert.AreEqual(criterium.MaximumRelativeIncrease, clonedCriterium.MaximumRelativeIncrease, "Incorrect maximum"); |
|||
Assert.AreEqual(criterium.MinimumNumberOfIterations, clonedCriterium.MinimumNumberOfIterations, "Incorrect iteration count"); |
|||
// ReSharper restore PossibleNullReferenceException
|
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,133 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCriterium |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class FailureStopCriteriumTest |
|||
{ |
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Create() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "Should have a criterium now"); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void DetermineStatusWithIllegalIterationNumber() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(-1, new DenseVector(3, 4), new DenseVector(3, 5), new DenseVector(3, 6)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullSolutionVector() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, null, new DenseVector(3, 6), new DenseVector(4, 4)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullResidualVector() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), null); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void DetermineStatusWithNonMatchingVectors() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), new DenseVector(4, 4)); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithResidualNaN() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new [] { 1.0, 1.0, 2.0 }); |
|||
var source = new DenseVector(new [] { 1001.0, 0, 2003.0 }); |
|||
var residual = new DenseVector(new [] { 1000, double.NaN, 2001 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationFailure), criterium.Status, "Should be failed"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithSolutionNaN() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 1.0, 1.0, double.NaN }); |
|||
var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 }); |
|||
var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationFailure), criterium.Status, "Should be failed"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatus() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 3.0, 2.0, 1.0 }); |
|||
var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 }); |
|||
var residual = new DenseVector(new[] { 1.0, 2.0, 3.0 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should be running"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetCalculationState() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 }); |
|||
var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 }); |
|||
var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should be running"); |
|||
|
|||
criterium.ResetToPrecalculationState(); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criterium.Status, "Should not have started"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Clone() |
|||
{ |
|||
var criterium = new FailureStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var clone = criterium.Clone(); |
|||
Assert.IsInstanceOfType(typeof(FailureStopCriterium), clone, "Wrong criterium type"); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,96 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCriterium |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class IterationCountStopCriteriumTest |
|||
{ |
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void CreateWithIllegalMinimumIterations() |
|||
{ |
|||
new IterationCountStopCriterium(-1); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Create() |
|||
{ |
|||
var criterium = new IterationCountStopCriterium(10); |
|||
Assert.IsNotNull(criterium, "A criterium should have been created"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetMaximumIterations() |
|||
{ |
|||
var criterium = new IterationCountStopCriterium(10); |
|||
Assert.IsNotNull(criterium, "A criterium should have been created"); |
|||
Assert.AreEqual(10, criterium.MaximumNumberOfIterations, "Incorrect maximum number of iterations"); |
|||
|
|||
criterium.ResetMaximumNumberOfIterationsToDefault(); |
|||
Assert.AreNotEqual(10, criterium.MaximumNumberOfIterations, "Should have reset"); |
|||
Assert.AreEqual(IterationCountStopCriterium.DefaultMaximumNumberOfIterations, criterium.MaximumNumberOfIterations, "Reset to the wrong value"); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void DetermineStatusWithIllegalIterationNumber() |
|||
{ |
|||
var criterium = new IterationCountStopCriterium(10); |
|||
Assert.IsNotNull(criterium, "A criterium should have been created"); |
|||
|
|||
criterium.DetermineStatus(-1, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3,3)); |
|||
Assert.Fail(); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatus() |
|||
{ |
|||
var criterium = new IterationCountStopCriterium(10); |
|||
Assert.IsNotNull(criterium, "A criterium should have been created"); |
|||
|
|||
criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should be running"); |
|||
|
|||
criterium.DetermineStatus(10, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)); |
|||
Assert.IsInstanceOfType(typeof(CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetCalculationState() |
|||
{ |
|||
var criterium = new IterationCountStopCriterium(10); |
|||
Assert.IsNotNull(criterium, "A criterium should have been created"); |
|||
|
|||
criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should be running"); |
|||
|
|||
criterium.ResetToPrecalculationState(); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criterium.Status, "Should not have started"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Clone() |
|||
{ |
|||
var criterium = new IterationCountStopCriterium(10); |
|||
Assert.IsNotNull(criterium, "A criterium should have been created"); |
|||
Assert.AreEqual(10, criterium.MaximumNumberOfIterations, "Incorrect maximum"); |
|||
|
|||
var clone = criterium.Clone(); |
|||
Assert.IsInstanceOfType(typeof(IterationCountStopCriterium), clone, "Wrong criterium type"); |
|||
|
|||
var clonedCriterium = clone as IterationCountStopCriterium; |
|||
Assert.IsNotNull(clonedCriterium); |
|||
// ReSharper disable PossibleNullReferenceException
|
|||
Assert.AreEqual(criterium.MaximumNumberOfIterations, clonedCriterium.MaximumNumberOfIterations, "Clone failed"); |
|||
// ReSharper restore PossibleNullReferenceException
|
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,261 @@ |
|||
namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCriterium |
|||
{ |
|||
using LinearAlgebra.Double; |
|||
using LinearAlgebra.Double.Solvers.Status; |
|||
using LinearAlgebra.Double.Solvers.StopCriterium; |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public sealed class ResidualStopCriteriumTest |
|||
{ |
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void CreateWithNegativeMaximum() |
|||
{ |
|||
new ResidualStopCriterium(-0.1); |
|||
Assert.Fail(); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void CreateWithIllegalMinimumIterations() |
|||
{ |
|||
new ResidualStopCriterium(-1); |
|||
Assert.Fail(); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Create() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
Assert.AreEqual(1e-8, criterium.Maximum, "Incorrect maximum"); |
|||
Assert.AreEqual(50, criterium.MinimumIterationsBelowMaximum, "Incorrect iteration count"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetMaximum() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.ResetMaximumResidualToDefault(); |
|||
Assert.AreEqual(ResidualStopCriterium.DefaultMaximumResidual, criterium.Maximum, "Incorrect maximum"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetMinimumIterationsBelowMaximum() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.ResetMinimumIterationsBelowMaximumToDefault(); |
|||
Assert.AreEqual(ResidualStopCriterium.DefaultMinimumIterationsBelowMaximum, criterium.MinimumIterationsBelowMaximum, "Incorrect iteration count"); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentOutOfRangeException] |
|||
public void DetermineStatusWithIllegalIterationNumber() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(-1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
new DenseVector(3, 6)); |
|||
Assert.Fail(); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullSolutionVector() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, |
|||
null, |
|||
new DenseVector(3, 5), |
|||
new DenseVector(3, 6)); |
|||
Assert.Fail(); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullSourceVector() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
null, |
|||
new DenseVector(3, 6)); |
|||
Assert.Fail(); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentNullException] |
|||
public void DetermineStatusWithNullResidualVector() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 5), |
|||
null); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void DetermineStatusWithNonMatchingSolutionVector() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(4, 4), |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void DetermineStatusWithNonMatchingSourceVector() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(4, 4), |
|||
new DenseVector(3, 4)); |
|||
} |
|||
|
|||
[Test] |
|||
[ExpectedArgumentException] |
|||
public void DetermineStatusWithNonMatchingResidualVector() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-8, 50); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
criterium.DetermineStatus(1, |
|||
new DenseVector(3, 4), |
|||
new DenseVector(3, 4), |
|||
new DenseVector(4, 4)); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithSourceNaN() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-3, 10); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 }); |
|||
var source = new DenseVector(new[] { 1.0, 1.0, double.NaN }); |
|||
var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationDiverged), criterium.Status, "Should be diverged"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithResidualNaN() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-3, 10); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 }); |
|||
var source = new DenseVector(new[] { 1.0, 1.0, 2.0 }); |
|||
var residual = new DenseVector(new[] { 1000.0, double.NaN, 2001.0 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationDiverged), criterium.Status, "Should be diverged"); |
|||
} |
|||
|
|||
// Bugfix: The unit tests for the BiCgStab solver run with a super simple matrix equation
|
|||
// which converges at the first iteration. The default settings for the
|
|||
// residual stop criterium should be able to handle this.
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatusWithConvergenceAtFirstIteration() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 1.0, 1.0, 1.0 }); |
|||
var source = new DenseVector(new[] { 1.0, 1.0, 1.0 }); |
|||
var residual = new DenseVector(new[] { 0.0, 0.0, 0.0 }); |
|||
|
|||
criterium.DetermineStatus(0, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationConverged), criterium.Status, "Should be done"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void DetermineStatus() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-3, 10); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
// Note that the solution vector isn't actually being used so ...
|
|||
var solution = new DenseVector(new[] { double.NaN, double.NaN, double.NaN }); |
|||
|
|||
// Set the source values
|
|||
var source = new DenseVector(new[] { 1.000, 1.000, 2.001 }); |
|||
|
|||
// Set the residual values
|
|||
var residual = new DenseVector(new[] { 0.001, 0.001, 0.002 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should still be running"); |
|||
|
|||
criterium.DetermineStatus(16, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationConverged), criterium.Status, "Should be done"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void ResetCalculationState() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-3, 10); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var solution = new DenseVector(new[] { 0.001, 0.001, 0.002 }); |
|||
var source = new DenseVector(new[] { 0.001, 0.001, 0.002 }); |
|||
var residual = new DenseVector(new[] { 1.000, 1.000, 2.001 }); |
|||
|
|||
criterium.DetermineStatus(5, solution, source, residual); |
|||
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should be running"); |
|||
|
|||
criterium.ResetToPrecalculationState(); |
|||
Assert.IsInstanceOfType(typeof(CalculationIndetermined), criterium.Status, "Should not have started"); |
|||
} |
|||
|
|||
[Test] |
|||
[MultipleAsserts] |
|||
public void Clone() |
|||
{ |
|||
var criterium = new ResidualStopCriterium(1e-3, 10); |
|||
Assert.IsNotNull(criterium, "There should be a criterium"); |
|||
|
|||
var clone = criterium.Clone(); |
|||
Assert.IsInstanceOfType(typeof(ResidualStopCriterium), clone, "Wrong criterium type"); |
|||
|
|||
var clonedCriterium = clone as ResidualStopCriterium; |
|||
Assert.IsNotNull(clonedCriterium); |
|||
// ReSharper disable PossibleNullReferenceException
|
|||
Assert.AreEqual(criterium.Maximum, clonedCriterium.Maximum, "Clone failed"); |
|||
Assert.AreEqual(criterium.MinimumIterationsBelowMaximum, clonedCriterium.MinimumIterationsBelowMaximum, "Clone failed"); |
|||
// ReSharper restore PossibleNullReferenceException
|
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue