Solve(
Matrix B
)
{
if (B.RowCount != _rowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension, "B");
}
if (!this.IsNonSingular)
{
throw new InvalidOperationException(Resources.ArgumentMatrixNotSingular);
}
// Copy right hand side with pivoting
int nx = B.ColumnCount;
Matrix Xmat = B.GetMatrix(piv, 0, nx - 1);
double[][] X = Xmat;
// Solve L*Y = B(piv,:)
for (int k = 0; k < _columnCount; k++)
{
for (int i = k + 1; i < _columnCount; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
// Solve U*X = Y;
for (int k = _columnCount - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= LU[k][k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
return(Xmat);
}
Solve(Matrix b)
{
if (b.RowCount != _rowCount)
{
throw new ArgumentException(Properties.LocalStrings.ArgumentMatrixSameRowDimension, "B");
}
if (!IsNonSingular)
{
throw new InvalidOperationException(Properties.LocalStrings.ArgumentMatrixNotSingular);
}
// Copy right hand side with pivoting
int nx = b.ColumnCount;
Matrix xmat = b.GetMatrix(_pivot, 0, nx - 1);
double[][] x = xmat;
// Solve L*Y = B(_pivot,:)
for (int k = 0; k < _columnCount; k++)
{
for (int i = k + 1; i < _columnCount; i++)
{
for (int j = 0; j < nx; j++)
{
x[i][j] -= x[k][j] * _lu[i][k];
}
}
}
// Solve U*x = Y;
for (int k = _columnCount - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
x[k][j] /= _lu[k][k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
x[i][j] -= x[k][j] * _lu[i][k];
}
}
}
return(xmat);
}
/// <summary>Solve A*X = B</summary>
/// <param name="B">A Matrix with as many rows as A and any number of columns.</param>
/// <returns>X so that L*U*X = B(piv,:)</returns>
/// <exception cref="System.ArgumentException">Matrix row dimensions must agree.</exception>
/// <exception cref="System.SystemException">Matrix is singular.</exception>
public Matrix Solve(Matrix B)
{
if (B.RowCount != m)
{
throw new System.ArgumentException("Matrix row dimensions must agree.");
}
if (!this.IsNonSingular)
{
throw new System.SystemException("Matrix is singular.");
}
// Copy right hand side with pivoting
int nx = B.ColumnCount;
Matrix Xmat = B.GetMatrix(piv, 0, nx - 1);
double[,] X = Xmat;
// Solve L*Y = B(piv,:)
for (int k = 0; k < n; k++)
{
for (int i = k + 1; i < n; i++)
{
for (int j = 0; j < nx; j++)
{
X[i, j] -= X[k, j] * LU[i, k];
}
}
}
// Solve U*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k, j] /= LU[k, k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i, j] -= X[k, j] * LU[i, k];
}
}
}
return(Xmat);
}
public void MatrixSolve1()
{
double[][] subavals = {
new double[] { 5.0, 8.0, 11.0 },
new double[] { 6.0, 9.0, 12.0 }
};
double[][] sqSolution = {
new double[] { 13.0 },
new double[] { 15.0 }
};
Matrix sub = new Matrix(subavals);
Matrix o = new Matrix(sub.RowCount, 1, 1.0);
Matrix sol = new Matrix(sqSolution);
Matrix sq = sub.GetMatrix(0, sub.RowCount - 1, 0, sub.RowCount - 1);
Assert.That(sq.Solve(sol), NumericIs.AlmostEqualTo(o), "Solve");
}
public void MatrixLUDecomposition1()
{
double[] columnwise = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
Matrix b = new Matrix(columnwise, 4);
b[0, 0] = 0.0;
LUDecomposition lu = b.LUDecomposition;
Assert.That(lu.L * lu.U, NumericIs.AlmostEqualTo(b.GetMatrix(lu.Pivot, 0, b.ColumnCount - 1)), "LUDecomposition");
}
Solve(
Matrix B
)
{
if(B.RowCount != _rowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension, "B");
}
if(!this.IsNonSingular)
{
throw new InvalidOperationException(Resources.ArgumentMatrixNotSingular);
}
// Copy right hand side with pivoting
int nx = B.ColumnCount;
Matrix Xmat = B.GetMatrix(piv, 0, nx - 1);
double[][] X = Xmat;
// Solve L*Y = B(piv,:)
for(int k = 0; k < _columnCount; k++)
{
for(int i = k + 1; i < _columnCount; i++)
{
for(int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
// Solve U*X = Y;
for(int k = _columnCount - 1; k >= 0; k--)
{
for(int j = 0; j < nx; j++)
{
X[k][j] /= LU[k][k];
}
for(int i = 0; i < k; i++)
{
for(int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
return Xmat;
}
private static Matrix[] GetMatrices(byte[] input, int cols)
{
// Create a test reader for the given byte array
MemoryStream stream = new MemoryStream(input);
StreamReader reader = new StreamReader(stream);
// Each item in the dblLines should be a line of doubles read from the bytes
List<double[]> dblLines = new List<double[]>();
while (!reader.EndOfStream)
{
//
List<double> dblVals = new List<double>();
string thisLine = reader.ReadLine();
string[] allVals = thisLine.Split("\t".ToCharArray());
for (int i=0; i<allVals.Length; i++)
{
double tmp = Double.Parse(allVals[i], System.Globalization.NumberFormatInfo.InvariantInfo);
dblVals.Add(tmp);
}
dblLines.Add(dblVals.ToArray());
}
double[][] arr = dblLines.ToArray();
Matrix bigMat = new Matrix(arr);
int num_matrices = dblLines[0].Length / cols;
Matrix[] outMatrices = new Matrix[num_matrices];
for (int i=0; i<num_matrices; i++)
{
outMatrices[i] = bigMat.GetMatrix(0,dblLines.Count-1,i*cols,(i*cols)+cols-1);
}
return outMatrices;
}
public void AllTests()
{
Matrix A, B, C, Z, O, I, R, S, X, SUB, M, T, SQ, DEF, SOL;
double tmp;
double[] columnwise = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
double[] rowwise = { 1.0, 4.0, 7.0, 10.0, 2.0, 5.0, 8.0, 11.0, 3.0, 6.0, 9.0, 12.0 };
double[][] avals = { new double[] { 1.0, 4.0, 7.0, 10.0 }, new double[] { 2.0, 5.0, 8.0, 11.0 }, new double[] { 3.0, 6.0, 9.0, 12.0 } };
double[][] rankdef = avals;
double[][] tvals = { new double[] { 1.0, 2.0, 3.0 }, new double[] { 4.0, 5.0, 6.0 }, new double[] { 7.0, 8.0, 9.0 }, new double[] { 10.0, 11.0, 12.0 } };
double[][] subavals = { new double[] { 5.0, 8.0, 11.0 }, new double[] { 6.0, 9.0, 12.0 } };
double[][] pvals = { new double[] { 25, -5, 10 }, new double[] { -5, 17, 10 }, new double[] { 10, 10, 62 } };
double[][] ivals = { new double[] { 1.0, 0.0, 0.0, 0.0 }, new double[] { 0.0, 1.0, 0.0, 0.0 }, new double[] { 0.0, 0.0, 1.0, 0.0 } };
double[][] evals = { new double[] { 0.0, 1.0, 0.0, 0.0 }, new double[] { 1.0, 0.0, 2e-7, 0.0 }, new double[] { 0.0, -2e-7, 0.0, 1.0 }, new double[] { 0.0, 0.0, 1.0, 0.0 } };
double[][] square = { new double[] { 166.0, 188.0, 210.0 }, new double[] { 188.0, 214.0, 240.0 }, new double[] { 210.0, 240.0, 270.0 } };
double[][] sqSolution = { new double[] { 13.0 }, new double[] { 15.0 } };
double[][] condmat = { new double[] { 1.0, 3.0 }, new double[] { 7.0, 9.0 } };
int rows = 3, cols = 4;
int invalidld = 5; /* should trigger bad shape for construction with val */
int validld = 3; /* leading dimension of intended test Matrices */
int nonconformld = 4; /* leading dimension which is valid, but nonconforming */
int ib = 1, ie = 2, jb = 1, je = 3; /* index ranges for sub Matrix */
int[] rowindexset = new int[] { 1, 2 };
int[] badrowindexset = new int[] { 1, 3 };
int[] columnindexset = new int[] { 1, 2, 3 };
int[] badcolumnindexset = new int[] { 1, 2, 4 };
double columnsummax = 33.0;
double rowsummax = 30.0;
double sumofdiagonals = 15;
double sumofsquares = 650;
#region Testing constructors and constructor-like methods
// Constructors and constructor-like methods:
// double[], int
// double[,]
// int, int
// int, int, double
// int, int, double[,]
// Create(double[,])
// Random(int,int)
// Identity(int)
try
{
// check that exception is thrown in packed constructor with invalid length
A = new Matrix(columnwise, invalidld);
Assert.Fail("Catch invalid length in packed constructor: exception not thrown for invalid input");
}
catch(ArgumentException) { }
A = new Matrix(columnwise, validld);
B = new Matrix(avals);
tmp = B[0, 0];
avals[0][0] = 0.0;
C = B - A;
avals[0][0] = tmp;
B = Matrix.Create(avals);
tmp = B[0, 0];
avals[0][0] = 0.0;
Assert.AreEqual((tmp - B[0, 0]), 0.0, "Create");
avals[0][0] = columnwise[0];
I = new Matrix(ivals);
NumericAssert.AreAlmostEqual(I, Matrix.Identity(3, 4), "Identity");
#endregion
#region Testing access methods
// Access Methods:
// getColumnDimension()
// getRowDimension()
// getArray()
// getArrayCopy()
// getColumnPackedCopy()
// getRowPackedCopy()
// get(int,int)
// GetMatrix(int,int,int,int)
// GetMatrix(int,int,int[])
// GetMatrix(int[],int,int)
// GetMatrix(int[],int[])
// set(int,int,double)
// SetMatrix(int,int,int,int,Matrix)
// SetMatrix(int,int,int[],Matrix)
// SetMatrix(int[],int,int,Matrix)
// SetMatrix(int[],int[],Matrix)
// Various get methods
B = new Matrix(avals);
Assert.AreEqual(B.RowCount, rows, "getRowDimension");
Assert.AreEqual(B.ColumnCount, cols, "getColumnDimension");
B = new Matrix(avals);
double[][] barray = (Matrix)B;
Assert.AreSame(barray, avals, "getArray");
barray = B.Clone();
Assert.AreNotSame(barray, avals, "getArrayCopy");
NumericAssert.AreAlmostEqual(new Matrix(barray), B, "getArrayCopy II");
// double[] bpacked = B.ColumnPackedCopy;
// try
// {
// check(bpacked, columnwise);
// try_success("getColumnPackedCopy... ", "");
// }
// catch (System.SystemException e)
// {
// errorCount = try_failure(errorCount, "getColumnPackedCopy... ", "data not successfully (deep) copied by columns");
// System.Console.Out.WriteLine(e.Message);
// }
// bpacked = B.RowPackedCopy;
// try
// {
// check(bpacked, rowwise);
// try_success("getRowPackedCopy... ", "");
// }
// catch (System.SystemException e)
// {
// errorCount = try_failure(errorCount, "getRowPackedCopy... ", "data not successfully (deep) copied by rows");
// System.Console.Out.WriteLine(e.Message);
// }
try
{
tmp = B[B.RowCount, B.ColumnCount - 1];
Assert.Fail("get(int,int): OutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
tmp = B[B.RowCount - 1, B.ColumnCount];
Assert.Fail("get(int,int): OutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
Assert.AreEqual(B[B.RowCount - 1, B.ColumnCount - 1], avals[B.RowCount - 1][B.ColumnCount - 1], "get(int,int)");
SUB = new Matrix(subavals);
try
{
M = B.GetMatrix(ib, ie + B.RowCount + 1, jb, je);
Assert.Fail("GetMatrix(int,int,int,int): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
M = B.GetMatrix(ib, ie, jb, je + B.ColumnCount + 1);
Assert.Fail("GetMatrix(int,int,int,int): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
M = B.GetMatrix(ib, ie, jb, je);
NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int,int,int,int)");
try
{
M = B.GetMatrix(ib, ie, badcolumnindexset);
Assert.Fail("GetMatrix(int,int,int[]): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
M = B.GetMatrix(ib, ie + B.RowCount + 1, columnindexset);
Assert.Fail("GetMatrix(int,int,int[]): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
M = B.GetMatrix(ib, ie, columnindexset);
NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int,int,int[])");
try
{
M = B.GetMatrix(badrowindexset, jb, je);
Assert.Fail("GetMatrix(int[],int,int): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
M = B.GetMatrix(rowindexset, jb, je + B.ColumnCount + 1);
Assert.Fail("GetMatrix(int[],int,int): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
M = B.GetMatrix(rowindexset, jb, je);
NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int[],int,int)");
try
{
M = B.GetMatrix(badrowindexset, columnindexset);
Assert.Fail("GetMatrix(int[],int[]): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
M = B.GetMatrix(rowindexset, badcolumnindexset);
Assert.Fail("GetMatrix(int[],int[]): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
M = B.GetMatrix(rowindexset, columnindexset);
NumericAssert.AreAlmostEqual(SUB, M, "GetMatrix(int[],int[])");
// Various set methods:
try
{
B[B.RowCount, B.ColumnCount - 1] = 0.0;
Assert.Fail("set(int,int,double): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
B[B.RowCount - 1, B.ColumnCount] = 0.0;
Assert.Fail("set(int,int,double): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
B[ib, jb] = 0.0;
tmp = B[ib, jb];
NumericAssert.AreAlmostEqual(tmp, 0.0, "set(int,int,double)");
M = new Matrix(2, 3, 0.0);
try
{
B.SetMatrix(ib, ie + B.RowCount + 1, jb, je, M);
Assert.Fail("SetMatrix(int,int,int,int,Matrix): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
B.SetMatrix(ib, ie, jb, je + B.ColumnCount + 1, M);
Assert.Fail("SetMatrix(int,int,int,int,Matrix): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
B.SetMatrix(ib, ie, jb, je, M);
NumericAssert.AreAlmostEqual(M - B.GetMatrix(ib, ie, jb, je), M, "SetMatrix(int,int,int,int,Matrix)");
B.SetMatrix(ib, ie, jb, je, SUB);
try
{
B.SetMatrix(ib, ie + B.RowCount + 1, columnindexset, M);
Assert.Fail("SetMatrix(int,int,int[],Matrix): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
B.SetMatrix(ib, ie, badcolumnindexset, M);
Assert.Fail("SetMatrix(int,int,int[],Matrix): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
B.SetMatrix(ib, ie, columnindexset, M);
NumericAssert.AreAlmostEqual(M - B.GetMatrix(ib, ie, columnindexset), M, "SetMatrix(int,int,int[],Matrix)");
B.SetMatrix(ib, ie, jb, je, SUB);
try
{
B.SetMatrix(rowindexset, jb, je + B.ColumnCount + 1, M);
Assert.Fail("SetMatrix(int[],int,int,Matrix): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
B.SetMatrix(badrowindexset, jb, je, M);
Assert.Fail("SetMatrix(int[],int,int,Matrix): IndexOutOfBoundsException expected but not thrown II");
}
catch(IndexOutOfRangeException) { }
B.SetMatrix(rowindexset, jb, je, M);
NumericAssert.AreAlmostEqual(M - B.GetMatrix(rowindexset, jb, je), M, "SetMatrix(int[],int,int,Matrix)");
B.SetMatrix(ib, ie, jb, je, SUB);
try
{
B.SetMatrix(rowindexset, badcolumnindexset, M);
Assert.Fail("SetMatrix(int[],int[],Matrix): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
try
{
B.SetMatrix(badrowindexset, columnindexset, M);
Assert.Fail("SetMatrix(int[],int[],Matrix): IndexOutOfBoundsException expected but not thrown");
}
catch(IndexOutOfRangeException) { }
B.SetMatrix(rowindexset, columnindexset, M);
NumericAssert.AreAlmostEqual(M - B.GetMatrix(rowindexset, columnindexset), M, "SetMatrix(int[],int[],Matrix)");
#endregion
#region Testing array-like methods
// Array-like methods:
// Subtract
// SubtractEquals
// Add
// AddEquals
// ArrayLeftDivide
// ArrayLeftDivideEquals
// ArrayRightDivide
// ArrayRightDivideEquals
// arrayTimes
// ArrayMultiplyEquals
// uminus
S = new Matrix(columnwise, nonconformld);
R = Matrix.Random(A.RowCount, A.ColumnCount);
A = R;
try
{
S = A - S;
Assert.Fail("Subtract conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
Assert.AreEqual((A - R).Norm1(), 0.0, "Subtract: difference of identical Matrices is nonzero,\nSubsequent use of Subtract should be suspect");
A = R.Clone();
A.Subtract(R);
Z = new Matrix(A.RowCount, A.ColumnCount);
try
{
A.Subtract(S);
Assert.Fail("SubtractEquals conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
Assert.AreEqual((A - Z).Norm1(), 0.0, "SubtractEquals: difference of identical Matrices is nonzero,\nSubsequent use of Subtract should be suspect");
A = R.Clone();
B = Matrix.Random(A.RowCount, A.ColumnCount);
C = A - B;
try
{
S = A + S;
Assert.Fail("Add conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
NumericAssert.AreAlmostEqual(C + B, A, "Add");
C = A - B;
C.Add(B);
try
{
A.Add(S);
Assert.Fail("AddEquals conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
NumericAssert.AreAlmostEqual(C, A, "AddEquals");
A = ((Matrix)R.Clone());
A.UnaryMinus();
NumericAssert.AreAlmostEqual(A + R, Z, "UnaryMinus");
A = (Matrix)R.Clone();
O = new Matrix(A.RowCount, A.ColumnCount, 1.0);
try
{
Matrix.ArrayDivide(A, S);
Assert.Fail("ArrayRightDivide conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
C = Matrix.ArrayDivide(A, R);
NumericAssert.AreAlmostEqual(C, O, "ArrayRightDivide");
try
{
A.ArrayDivide(S);
Assert.Fail("ArrayRightDivideEquals conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
A.ArrayDivide(R);
NumericAssert.AreAlmostEqual(A, O, "ArrayRightDivideEquals");
A = (Matrix)R.Clone();
B = Matrix.Random(A.RowCount, A.ColumnCount);
try
{
S = Matrix.ArrayMultiply(A, S);
Assert.Fail("arrayTimes conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
C = Matrix.ArrayMultiply(A, B);
C.ArrayDivide(B);
NumericAssert.AreAlmostEqual(C, A, "arrayTimes");
try
{
A.ArrayMultiply(S);
Assert.Fail("ArrayMultiplyEquals conformance check: nonconformance not raised");
}
catch(ArgumentException) { }
A.ArrayMultiply(B);
A.ArrayDivide(B);
NumericAssert.AreAlmostEqual(A, R, "ArrayMultiplyEquals");
#endregion
#region Testing linear algebra methods
// LA methods:
// Transpose
// Multiply
// Condition
// Rank
// Determinant
// trace
// Norm1
// norm2
// normF
// normInf
// Solve
// solveTranspose
// Inverse
// chol
// Eigen
// lu
// qr
// svd
A = new Matrix(columnwise, 3);
T = new Matrix(tvals);
T = Matrix.Transpose(A);
NumericAssert.AreAlmostEqual(Matrix.Transpose(A), T, "Transpose");
NumericAssert.AreAlmostEqual(A.Norm1(), columnsummax, "Norm1");
NumericAssert.AreAlmostEqual(A.NormInf(), rowsummax, "NormInf");
NumericAssert.AreAlmostEqual(A.NormF(), Math.Sqrt(sumofsquares), "NormF");
NumericAssert.AreAlmostEqual(A.Trace(), sumofdiagonals, "Trace");
NumericAssert.AreAlmostEqual(A.GetMatrix(0, A.RowCount - 1, 0, A.RowCount - 1).Determinant(), 0.0, "Determinant");
SQ = new Matrix(square);
NumericAssert.AreAlmostEqual(A * Matrix.Transpose(A), SQ, "Multiply(Matrix)");
NumericAssert.AreAlmostEqual(0.0 * A, Z, "Multiply(double)");
A = new Matrix(columnwise, 4);
QRDecomposition QR = A.QRDecomposition;
R = QR.R;
NumericAssert.AreAlmostEqual(A, QR.Q * R, "QRDecomposition");
SingularValueDecomposition SVD = A.SingularValueDecomposition;
NumericAssert.AreAlmostEqual(A, SVD.LeftSingularVectors * (SVD.S * Matrix.Transpose(SVD.RightSingularVectors)), "SingularValueDecomposition");
DEF = new Matrix(rankdef);
NumericAssert.AreAlmostEqual(DEF.Rank(), Math.Min(DEF.RowCount, DEF.ColumnCount) - 1, "Rank");
B = new Matrix(condmat);
SVD = B.SingularValueDecomposition;
double[] singularvalues = SVD.SingularValues;
NumericAssert.AreAlmostEqual(B.Condition(), singularvalues[0] / singularvalues[Math.Min(B.RowCount, B.ColumnCount) - 1], "Condition");
int n = A.ColumnCount;
A = A.GetMatrix(0, n - 1, 0, n - 1);
A[0, 0] = 0.0;
LUDecomposition LU = A.LUDecomposition;
NumericAssert.AreAlmostEqual(A.GetMatrix(LU.Pivot, 0, n - 1), LU.L * LU.U, "LUDecomposition");
X = A.Inverse();
NumericAssert.AreAlmostEqual(A * X, Matrix.Identity(3, 3), "Inverse");
O = new Matrix(SUB.RowCount, 1, 1.0);
SOL = new Matrix(sqSolution);
SQ = SUB.GetMatrix(0, SUB.RowCount - 1, 0, SUB.RowCount - 1);
NumericAssert.AreAlmostEqual(SQ.Solve(SOL), O, "Solve");
A = new Matrix(pvals);
CholeskyDecomposition Chol = A.CholeskyDecomposition;
Matrix L = Chol.TriangularFactor;
NumericAssert.AreAlmostEqual(A, L * Matrix.Transpose(L), "CholeskyDecomposition");
X = Chol.Solve(Matrix.Identity(3, 3));
NumericAssert.AreAlmostEqual(A * X, Matrix.Identity(3, 3), "CholeskyDecomposition Solve");
EigenvalueDecomposition Eig = A.EigenvalueDecomposition;
Matrix D = Eig.BlockDiagonal;
Matrix V = Eig.EigenVectors;
NumericAssert.AreAlmostEqual(A * V, V * D, "EigenvalueDecomposition (symmetric)");
A = new Matrix(evals);
Eig = A.EigenvalueDecomposition;
D = Eig.BlockDiagonal;
V = Eig.EigenVectors;
NumericAssert.AreAlmostEqual(A * V, V * D, "EigenvalueDecomposition (nonsymmetric)");
#endregion
}
/// <summary>
/// Solve A*X = B
/// </summary>
/// <param name="b">A Matrix with as many rows as A and any number of columns.</param>
/// <returns>X so that L*U*X = B(pivot,:)</returns>
/// <exception cref="System.ArgumentException">Matrix row dimensions must agree.</exception>
/// <exception cref="System.SystemException">Matrix is singular.</exception>
public Matrix Solve(Matrix b)
{
if(b.RowCount != _rowCount)
{
throw new ArgumentException(Properties.LocalStrings.ArgumentMatrixSameRowDimension, "B");
}
if(!IsNonSingular)
{
throw new InvalidOperationException(Properties.LocalStrings.ArgumentMatrixNotSingular);
}
// Copy right hand side with pivoting
int nx = b.ColumnCount;
Matrix xmat = b.GetMatrix(_pivot, 0, nx - 1);
double[][] x = xmat;
// Solve L*Y = B(_pivot,:)
for(int k = 0; k < _columnCount; k++)
{
for(int i = k + 1; i < _columnCount; i++)
{
for(int j = 0; j < nx; j++)
{
x[i][j] -= x[k][j] * _lu[i][k];
}
}
}
// Solve U*x = Y;
for(int k = _columnCount - 1; k >= 0; k--)
{
for(int j = 0; j < nx; j++)
{
x[k][j] /= _lu[k][k];
}
for(int i = 0; i < k; i++)
{
for(int j = 0; j < nx; j++)
{
x[i][j] -= x[k][j] * _lu[i][k];
}
}
}
return xmat;
}
public void MatrixNormTraceDeterminant()
{
double[] columnwise = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 };
const double ColumnSumMax = 33.0;
const double RowSumMax = 30.0;
const double SumOfDiagonals = 15;
const double SumOfSquares = 650;
Matrix a = new Matrix(columnwise, 3);
// Norms
Assert.That(ColumnSumMax, NumericIs.AlmostEqualTo(a.Norm1()), "Norm1");
Assert.That(RowSumMax, NumericIs.AlmostEqualTo(a.NormInf()), "NormInf");
Assert.That(Math.Sqrt(SumOfSquares), NumericIs.AlmostEqualTo(a.NormF()), "NormF");
// Trace
Assert.That(SumOfDiagonals, NumericIs.AlmostEqualTo(a.Trace()), "Trace");
// Determinant
Assert.That(0.0, NumericIs.AlmostEqualTo(a.GetMatrix(0, a.RowCount - 1, 0, a.RowCount - 1).Determinant()), "Determinant");
}
public void MatrixGetSubmatrix()
{
const int RowTop = 1;
const int RowBottom = 2;
const int ColumnLeft = 1;
const int ColumnRight = 3;
int[] rowindexset = new int[] { 1, 2 };
int[] badrowindexset = new int[] { 1, 3 };
int[] columnindexset = new int[] { 1, 2, 3 };
int[] badcolumnindexset = new int[] { 1, 2, 4 };
double[][] avals = {
new double[] { 1.0, 4.0, 7.0, 10.0 },
new double[] { 2.0, 5.0, 8.0, 11.0 },
new double[] { 3.0, 6.0, 9.0, 12.0 }
};
double[][] subavals = {
new double[] { 5.0, 8.0, 11.0 },
new double[] { 6.0, 9.0, 12.0 }
};
Matrix a = new Matrix(avals);
Matrix sub = new Matrix(subavals);
// cells
Assert.That(a[a.RowCount - 1, a.ColumnCount - 1], Is.EqualTo(avals[a.RowCount - 1][a.ColumnCount - 1]), "get(int,int)");
Assert.That(delegate { double x = a[a.RowCount, a.ColumnCount - 1]; }, Throws.TypeOf<IndexOutOfRangeException>());
Assert.That(delegate { double x = a[a.RowCount - 1, a.ColumnCount]; }, Throws.TypeOf<IndexOutOfRangeException>());
// submatrices by intervals
Assert.That(a.GetMatrix(RowTop, RowBottom, ColumnLeft, ColumnRight), NumericIs.AlmostEqualTo(sub), "GetMatrix(int,int,int,int)");
Assert.That(delegate { Matrix m = a.GetMatrix(RowTop, RowBottom + a.RowCount + 1, ColumnLeft, ColumnRight); }, Throws.TypeOf<IndexOutOfRangeException>());
Assert.That(delegate { Matrix m = a.GetMatrix(RowTop, RowBottom, ColumnLeft, ColumnRight + a.ColumnCount + 1); }, Throws.TypeOf<IndexOutOfRangeException>());
// submatrices by column index sets
Assert.That(a.GetMatrix(RowTop, RowBottom, columnindexset), Is.EqualTo(sub), "GetMatrix(int,int,int[])");
Assert.That(delegate { Matrix m = a.GetMatrix(RowTop, RowBottom, badcolumnindexset); }, Throws.TypeOf<IndexOutOfRangeException>());
Assert.That(delegate { Matrix m = a.GetMatrix(RowTop, RowBottom + a.RowCount + 1, columnindexset); }, Throws.TypeOf<IndexOutOfRangeException>());
// submatrices by row index sets
Assert.That(a.GetMatrix(rowindexset, ColumnLeft, ColumnRight), Is.EqualTo(sub), "GetMatrix(int[],int,int)");
Assert.That(delegate { Matrix m = a.GetMatrix(badrowindexset, ColumnLeft, ColumnRight); }, Throws.TypeOf<IndexOutOfRangeException>());
Assert.That(delegate { Matrix m = a.GetMatrix(rowindexset, ColumnLeft, ColumnRight + a.ColumnCount + 1); }, Throws.TypeOf<IndexOutOfRangeException>());
// submatrices by column/row index sets
Assert.That(a.GetMatrix(rowindexset, columnindexset), Is.EqualTo(sub), "GetMatrix(int[],int[])");
Assert.That(delegate { Matrix m = a.GetMatrix(badrowindexset, columnindexset); }, Throws.TypeOf<IndexOutOfRangeException>());
Assert.That(delegate { Matrix m = a.GetMatrix(rowindexset, badcolumnindexset); }, Throws.TypeOf<IndexOutOfRangeException>());
}