public void Simple()
{
var matrix = new Matrix(3, 3);
// [ 3, 1, 8 ]
// [ 2, -5, 4 ]
// [-1, 6, -2 ]
// Determinant = 14
matrix[0, 0] = 3;
matrix[0, 1] = 1;
matrix[0, 2] = 8;
matrix[1, 0] = 2;
matrix[1, 1] = -5;
matrix[1, 2] = 4;
matrix[2, 0] = -1;
matrix[2, 1] = 6;
matrix[2, 2] = -2;
var decomposition = new LUDecomposition(matrix);
Assert.AreEqual(14.0d, decomposition.Determinant(), 0.00000001d);
}
private void computeMllrTransforms(double[][][][][] array, double[][][][] array2)
{
for (int c = 0; c < this.nrOfClusters; c++)
{
this.As[c] = new float[this.loader.getNumStreams()][][];
this.Bs[c] = new float[this.loader.getNumStreams()][];
for (int i = 0; i < this.loader.getNumStreams(); i++)
{
int len = this.loader.getVectorLength()[i];
float[][][] array3 = this.As[c];
int num2 = i;
int num3 = len;
int num4 = len;
int[] array4 = new int[2];
int num5 = num4;
array4[1] = num5;
num5 = num3;
array4[0] = num5;
array3[num2] = (float[][])ByteCodeHelper.multianewarray(typeof(float[][]).TypeHandle, array4);
this.Bs[c][i] = new float[len];
for (int j = 0; j < len; j++)
{
#if USE_MAPACK
//TODO: need to check if the math is correct
Matrix m = new Matrix(array[c][i][j]);
int rs = array2[c][i][j].Length;
Matrix rv = new Matrix(rs, 1);
for (int r = 0; r < rs; r++)
{
rv[r, 0] = array2[c][i][j][r];
}
Matrix solved = m.Solve(rv);
for (int k = 0; k < len; k++)
{
this.As[c][i][j][k] = (float)solved[k, 0];
}
//TODO: there may be a problem of index out of range?
//(index == len)?
this.Bs[c][i][j] = (float)solved[len, 0];
#else
Array2DRowRealMatrix matrix = new Array2DRowRealMatrix(array[c][i][j], false);
DecompositionSolver solver = new LUDecomposition(matrix).getSolver();
ArrayRealVector rv = new ArrayRealVector(array2[c][i][j], false);
RealVector realVector = solver.solve(rv);
for (int k = 0; k < len; k++)
{
this.As[c][i][j][k] = (float)realVector.getEntry(k);
}
this.Bs[c][i][j] = (float)realVector.getEntry(len);
#endif
}
}
}
}
public void Test03()
{
Matrix X = new Matrix(3, 3).Zero();
LUDecomposition lud = new LUDecomposition(X);
Assert.AreEqual(0, lud.ZeroValueIndexOfU); // いきなり 0 要素
}
public void SquareRandomMatrixLUDecomposition()
{
for (int d = 1; d <= 256; d += 11)
{
SquareMatrix M = CreateSquareRandomMatrix(d);
// LU decompose the matrix
//Stopwatch sw = Stopwatch.StartNew();
LUDecomposition LU = M.LUDecomposition();
//sw.Stop();
//Console.WriteLine(sw.ElapsedMilliseconds);
Assert.IsTrue(LU.Dimension == d);
// test that the decomposition works
SquareMatrix P = LU.PMatrix();
SquareMatrix L = LU.LMatrix();
SquareMatrix U = LU.UMatrix();
Assert.IsTrue(TestUtilities.IsNearlyEqual(P * M, L * U));
// check that the inverse works
SquareMatrix MI = LU.Inverse();
Assert.IsTrue(TestUtilities.IsNearlyEqual(M * MI, UnitMatrix.OfDimension(d)));
// test that a solution works
ColumnVector t = new ColumnVector(d);
for (int i = 0; i < d; i++)
{
t[i] = i;
}
ColumnVector s = LU.Solve(t);
Assert.IsTrue(TestUtilities.IsNearlyEqual(M * s, t));
}
}
public void When_Solve_SLE()
{
// Arrange
Matrix A = new Matrix(3, 3);
A.Elem[0][0] = 2;
A.Elem[0][1] = 3;
A.Elem[0][2] = -1;
A.Elem[1][0] = 1;
A.Elem[1][1] = -2;
A.Elem[1][2] = 1;
A.Elem[2][0] = 1;
A.Elem[2][1] = 0;
A.Elem[2][2] = 2;
Vector F = new Vector(3);
F.Elem[0] = 9;
F.Elem[1] = 3;
F.Elem[2] = 2;
LUDecomposition lu = new LUDecomposition();
// Act
Vector luRes = lu.StartSolver(A, F);
Vector gaussRes = Gauss.StartSolver(A, F);
// Assert
Assert.That(A * luRes == F);
Assert.That(A * gaussRes == F);
}
/// <summary>
/// Used for computing the actual transformations (A and B matrices). These are stored in As and Bs.
/// </summary>
/// <param name="regLs">The reg ls.</param>
/// <param name="regRs">The reg rs.</param>
private void ComputeMllrTransforms(double[][][][][] regLs, double[][][][] regRs)
{
int len;
for (int c = 0; c < _nrOfClusters; c++)
{
As[c] = new float[_loader.NumStreams][][];
Bs[c] = new float[_loader.NumStreams][];
for (int i = 0; i < _loader.NumStreams; i++)
{
len = _loader.VectorLength[i];
As[c][i] = Java.CreateArray <float[][]>(len, len); //this.As[c][i] = new float[len][len];
Bs[c][i] = new float[len];
for (int j = 0; j < len; ++j)
{
var coef = new Array2DRowRealMatrix(regLs[c][i][j], false);
var solver = new LUDecomposition(coef).getSolver();
var vect = new ArrayRealVector(regRs[c][i][j], false);
var aBloc = solver.solve(vect);
for (int k = 0; k < len; ++k)
{
As[c][i][j][k] = (float)aBloc.getEntry(k);
}
Bs[c][i][j] = (float)aBloc.getEntry(len);
}
}
}
}
public void Simple()
{
var matrixA = new Matrix(2, 2);
matrixA[0, 0] = 0;
matrixA[0, 1] = 1;
matrixA[1, 0] = 2;
matrixA[1, 1] = 0;
var matrixB = new Matrix(2, 2);
matrixB[0, 0] = 1;
matrixB[0, 1] = 0;
matrixB[1, 0] = 0;
matrixB[1, 1] = -1;
var decomposition = new LUDecomposition(matrixA);
var solveMatrix = decomposition.Solve(matrixB);
Assert.AreEqual(solveMatrix.Rows, 2);
Assert.AreEqual(solveMatrix.Columns, 2);
Assert.AreEqual(solveMatrix[0, 0], 0);
Assert.AreEqual(solveMatrix[0, 1], -0.5);
Assert.AreEqual(solveMatrix[1, 0], 1);
Assert.AreEqual(solveMatrix[1, 1], 0);
}
public void ExceptionDifferentRowCounts()
{
var matrixA = new Matrix(2, 2);
matrixA[0, 0] = 0;
matrixA[0, 1] = 1;
matrixA[1, 0] = 2;
matrixA[1, 1] = 0;
var matrixB = new Matrix(3, 2);
matrixB[0, 0] = 1;
matrixB[0, 1] = 0;
matrixB[1, 0] = 0;
matrixB[1, 1] = -1;
matrixB[2, 0] = 1;
matrixB[2, 1] = 3;
var decomposition = new LUDecomposition(matrixA);
Assert.Throws <ArgumentException>(() => decomposition.Solve(matrixB));
}
public static void LUDecomposition()
{
SquareMatrix A = new SquareMatrix(new double[, ] {
{ 1, -2, 3 },
{ 2, -5, 12 },
{ 0, 2, -10 }
});
ColumnVector b = new ColumnVector(2, 8, -4);
LUDecomposition lud = A.LUDecomposition();
ColumnVector x = lud.Solve(b);
PrintMatrix("x", x);
PrintMatrix("Ax", A * x);
SquareMatrix L = lud.LMatrix();
SquareMatrix U = lud.UMatrix();
SquareMatrix P = lud.PMatrix();
PrintMatrix("LU", L * U);
PrintMatrix("PA", P * A);
SquareMatrix AI = lud.Inverse();
PrintMatrix("A * AI", A * AI);
Console.WriteLine($"det(a) = {lud.Determinant()}");
}
/// <summary>
/// Used for computing the actual transformations (A and B matrices). These are stored in As and Bs.
/// </summary>
/// <param name="regLs">The reg ls.</param>
/// <param name="regRs">The reg rs.</param>
private void computeMllrTransforms(double[][][][][] regLs,
double[][][][] regRs)
{
int len;
for (int c = 0; c < nrOfClusters; c++)
{
this.As[c] = new float[loader.getNumStreams()][][];
this.Bs[c] = new float[loader.getNumStreams()][];
for (int i = 0; i < loader.getNumStreams(); i++)
{
len = loader.getVectorLength()[i];
//TODO: CHECK SEMANTICS
//this.As[c][i] = new float[len][len];
this.As[c][i] = new float[len][];
this.Bs[c][i] = new float[len];
for (int j = 0; j < len; ++j)
{
var coef = new Array2DRowRealMatrix(regLs[c][i][j], false);
var solver = new LUDecomposition(coef).getSolver();
var vect = new ArrayRealVector(regRs[c][i][j], false);
var ABloc = solver.solve(vect);
for (int k = 0; k < len; ++k)
{
this.As[c][i][j][k] = (float)ABloc.getEntry(k);
}
this.Bs[c][i][j] = (float)ABloc.getEntry(len);
}
}
}
}
public static Double Det(Double[,] matrix)
{
var rows = matrix.GetLength(0);
var columns = matrix.GetLength(1);
if (rows == columns)
{
switch (rows)
{
case 0: return(0.0);
case 1: return(matrix[0, 0]);
case 2: return(Helpers.Det2(matrix));
case 3: return(Helpers.Det3(matrix));
case 4: return(Helpers.Det4(matrix));
}
return(LUDecomposition.Determinant(matrix));
}
return(0.0);
}
public void LUDecompositionDeterminantTest()
{
for (Int32 i = 0; i < _matrix.Length; i++)
{
Double determinant = LUDecomposition.ComputeDeterminant(_matrix[i]);
Assert.AreEqual(_determinantExpected[i], determinant, 0.01);
}
}
public void Test04()
{
Matrix X = new Matrix(new double[, ] {
{ 1, 2, 3 }, { 2, 2, 2 }, { 0, 0, 0 }
});
LUDecomposition lud = new LUDecomposition(X);
Assert.AreEqual(2, lud.ZeroValueIndexOfU); // X.Rows[2]が使えない
}
/// <inheritdoc />
public override void Iteration()
{
if (!_initComplete)
{
_hessian.Init(_network, Training);
_initComplete = true;
}
PreIteration();
_hessian.Clear();
_weights = NetworkCODEC.NetworkToArray(_network);
_hessian.Compute();
double currentError = _hessian.SSE;
SaveDiagonal();
double startingError = currentError;
bool done = false;
bool singular;
while (!done)
{
ApplyLambda();
var decomposition = new LUDecomposition(_hessian.HessianMatrix);
singular = decomposition.IsNonsingular;
if (singular)
{
_deltas = decomposition.Solve(_hessian.Gradients);
UpdateWeights();
currentError = CalculateError();
}
if (!singular || currentError >= startingError)
{
_lambda *= ScaleLambda;
if (_lambda > LambdaMax)
{
_lambda = LambdaMax;
done = true;
}
}
else
{
_lambda /= ScaleLambda;
done = true;
}
}
Error = currentError;
PostIteration();
}
public override double getDeterminant(Matrix m)
{
ArgChecker.notNull(m, "m");
if (m is DoubleMatrix)
{
RealMatrix temp = CommonsMathWrapper.wrap((DoubleMatrix)m);
LUDecomposition lud = new LUDecomposition(temp);
return(lud.Determinant);
}
throw new System.ArgumentException("Can only find determinant of DoubleMatrix; have " + m.GetType());
}
public void LUDecompositionComputeDeterminantTest()
{
for (Int32 matrixIndex = 0; matrixIndex < this.matrices.Length; matrixIndex++)
{
Double determinant = LUDecomposition.ComputeDeterminant(this.matrices[matrixIndex]);
determinant.ShouldBe(this.expectedDeterminant[matrixIndex], 0.01);
}
Should.Throw <ArgumentNullException>(() => LUDecomposition.ComputeDeterminant(null));
}
public void LUDecompositionInvertTest()
{
for (Int32 matrixIndex = 0; matrixIndex < this.matrices.Length; matrixIndex++)
{
Matrix inverse = LUDecomposition.Invert(this.matrices[matrixIndex]);
inverse.ShouldBe(this.expectedInverse[matrixIndex], 0.01);
}
Should.Throw <ArgumentNullException>(() => LUDecomposition.ComputeDeterminant(null));
}
public void LUDecomposition()
{
GeneralMatrix A = new GeneralMatrix(columnwise, 4);
int n = A.ColumnDimension;
A = A.GetMatrix(0, n - 1, 0, n - 1);
A.SetElement(0, 0, 0.0);
LUDecomposition LU = A.LUD();
Assert.IsTrue(GeneralTests.Check(A.GetMatrix(LU.Pivot, 0, n - 1), LU.L.Multiply(LU.U)));
}
public static Object Lu(Double[,] matrix)
{
var lu = new LUDecomposition(matrix);
return(ObjectHelpers.CreateObject(
"l", lu.L,
"u", lu.U,
"pivot", lu.Pivot,
"singular", !lu.IsNonSingular
));
}
public static void run()
{
int dim1 = 5;
Matrix A1 = Matrix.Random(dim1, dim1);
//LUDecomposition lud1 = new LUDecomposition(A1);
LUDecomposition lud1 = A1.LUDecomposition;
Console.WriteLine("Singular matrix = {0}", !lud1.IsNonSingular);
Console.WriteLine("Upper triangular matrix = {0}", lud1.U.ToString());
Console.WriteLine("Lower triangular matrix = {0}", lud1.L.ToString());
}
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");
}
public void SquareUnitMatrixLUDecomposition()
{
for (int d = 1; d <= 10; d++)
{
SquareMatrix I = UnitMatrix.OfDimension(d).ToSquareMatrix();
Assert.IsTrue(I.Trace() == d);
LUDecomposition LU = I.LUDecomposition();
Assert.IsTrue(LU.Determinant() == 1.0);
SquareMatrix II = LU.Inverse();
Assert.IsTrue(TestUtilities.IsNearlyEqual(II, I));
}
}
public void luDecompositionTest()
{
var l = new LUDecomposition();
Func <string, int> parse = int.Parse;
var matrix = Util.ParseJaggedArray("[[4,3], [6,3]]", parse);
var expected = "[[4,3],[1.5,-1.5]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
matrix = Util.ParseJaggedArray(@"
[[-81,8,-25,96,28,9,84],
[-8,-74,-32,-89,80,-14,-13],
[79,-52,-88,74,-49,-88,-75],
[45,9,-23,54,-12,52,45],
[54,-96,16,-29,-46,51,-29],
[63,41,-47,-91,34,-8,-95],
[-16,62,47,6,-8,-2,3]]", parse);
expected = "[[-81,8,-25,96,28,9,84],[0.0987654320987654,-74.7901234567901,-29.5308641975309,-98.4814814814815,77.2345679012346,-14.8888888888889,-21.2962962962963],[-0.975308641975309,0.590954110267415,-94.931330472103,225.827665896335,-67.3334433806537,-70.4235721360185,19.5110597556949],[-0.555555555555556,-0.179762297788049,0.444504724445047,-10.7513884686677,47.3694526460022,85.6271496485792,79.1656372697333],[-0.666666666666667,1.21228128095081,-0.370089063700891,-22.1332906575855,902.559138445875,1944.19711877244,1812.23399097437],[-0.777777777777778,-0.631396500495213,0.896333468963335,26.1297498535919,-1.18868146151449,126.337283989992,24.9891606437004],[0.197530864197531,-0.807857378672829,-0.29580903295809,2.3922576187612,-0.0934832076890959,-0.472783817162961,-33.1820965619204]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
matrix = Util.ParseJaggedArray("[[-21,-98],[23,43]]", parse);
expected = "[[-21,-98],[-1.0952380952381,-64.3333333333333]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
matrix = Util.ParseJaggedArray(@"[[-31,-100,28,11,-21],
[-99,-37,-58,-10,25],
[-5,-96,-81,-12,100],
[34,-84,71,9,-38],
[-19,-66,-44,61,-74]]", parse);
expected = "[[-31,-100,28,11,-21],[3.19354838709677,282.354838709677,-147.41935483871,-45.1290322580645,92.0645161290323],[0.161290322580645,-0.282874443048098,-127.217296926768,-26.5400434136867,129.429795498686],[-1.09677419354839,-0.685936250428425,-0.00463300144674641,-10.0140831030603,2.71777935633699],[0.612903225806452,-0.0166799954301382,0.500091151317473,-6.66838417894268,-106.196895133823]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
matrix = Util.ParseJaggedArray("[[68]]", parse);
expected = "[[68]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
matrix = Util.ParseJaggedArray("[[-65,-87],[21, -94]]", parse);
expected = "[[-65,-87],[-0.323076923076923,-122.107692307692]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
matrix = Util.ParseJaggedArray(@"[[41,49,44,-68,-3,38,12,-5,-59,-93],
[53,-16,68,-23,-47,36,-29,-90,30,23],
[-94,55,82,-10,-11,99,-31,62,-60,21],
[-9,84,-22,-37,-35,71,49,-70,78,-31],
[-84,-27,-91,67,-19,-7,-87,-24,85,24],
[67,74,22,-9,-68,-84,-78,-11,-46,-4],
[51,92,72,18,24,16,72,4,-89,19],
[-45,-6,27,6,17,85,-89,-28,8,-44],
[-69,-47,0,-94,-73,61,1,35,-81,-49],
[92,-11,-42,82,70,-68,73,-63,61,5]]", parse);
expected = "[[41,49,44,-68,-3,38,12,-5,-59,-93],[1.29268292682927,-79.3414634146341,11.1219512195122,64.9024390243902,-43.1219512195122,-13.1219512195122,-44.5121951219512,-83.5365853658537,106.268292682927,143.219512195122],[-2.29268292682927,-2.10913003381494,206.335690132186,-29.014755610206,-108.827851214264,158.446049800184,-97.3698124807869,-125.652935751614,28.8653550568706,109.849062403935],[-0.219512195121951,-1.19428220104519,0.00456191057940135,25.7173611835342,-86.6618524753803,62.9473339193397,-1.08178364446299,-170.290600557203,191.831429805873,119.128758510749],[-2.04878048780488,-0.924992314786351,0.0457219052159533,-0.426023722971309,-96.9780032731328,78.2885567801642,-99.5970047069388,-178.317345923791,142.824266137558,11.6695315364896],[1.63414634146341,0.0765447279434367,-0.24597666900076,3.5002447608151,-2.23526750897973,-151.454321706079,-336.992725446293,170.129139106577,-302.825955066191,-226.862070529221],[1.24390243902439,-0.391331079003996,0.104783897736923,5.09476791171231,-4.78234407348074,-0.00458781142512872,-422.484813813976,6.29215979347331,-272.739433567603,-372.947701488384],[-1.09756097560976,-0.602213341530895,0.397364461196943,-0.700678378495808,0.306657820013277,-0.501420564469947,0.480809394853812,-16.2202538575184,65.6764975781027,41.9812602317544],[-1.68292682926829,-0.446972025822318,0.382968072585331,-6.54490651295495,6.42247928012437,0.214031013392838,-1.75934221027551,-2.63426584599228,-47.6338512810595,24.1761850346682],[2.24390243902439,1.52443897940363,-0.764222821471671,4.41226526858517,-4.55438171539577,-0.439994343129807,1.31978114282342,0.904256772107914,-0.521511197938609,-26.1398740424584]]";
Assert.AreEqual(expected, Util.JaggedArrayToString(l.luDecomposition(matrix)));
}
public void LUDecompositionComputeTest()
{
for (Int32 matrixIndex = 0; matrixIndex < this.matrices.Length; matrixIndex++)
{
LUDecomposition decomposition = new LUDecomposition(this.matrices[matrixIndex]);
decomposition.Compute();
decomposition.L.ShouldBe(this.expectedL[matrixIndex], 0.01);
decomposition.U.ShouldBe(this.expectedU[matrixIndex], 0.01);
decomposition.P.ShouldBe(this.expectedP[matrixIndex], 0.01);
}
}
public void SquareVandermondeMatrixLUDecomposition()
{
// fails now for d = 8 because determinant slightly off
for (int d = 1; d <= 7; d++)
{
Console.WriteLine("d={0}", d);
double[] x = new double[d];
for (int i = 0; i < d; i++)
{
x[i] = i;
}
double det = 1.0;
for (int i = 0; i < d; i++)
{
for (int j = 0; j < i; j++)
{
det = det * (x[i] - x[j]);
}
}
// LU decompose the matrix
SquareMatrix V = CreateVandermondeMatrix(d);
LUDecomposition LU = V.LUDecomposition();
// test that the decomposition works
SquareMatrix P = LU.PMatrix();
SquareMatrix L = LU.LMatrix();
SquareMatrix U = LU.UMatrix();
Assert.IsTrue(TestUtilities.IsNearlyEqual(P * V, L * U));
// check that the determinant agrees with the analytic expression
Console.WriteLine("det {0} {1}", LU.Determinant(), det);
Assert.IsTrue(TestUtilities.IsNearlyEqual(LU.Determinant(), det));
// check that the inverse works
SquareMatrix VI = LU.Inverse();
//PrintMatrix(VI);
//PrintMatrix(V * VI);
SquareMatrix I = TestUtilities.CreateSquareUnitMatrix(d);
Assert.IsTrue(TestUtilities.IsNearlyEqual(V * VI, I));
// test that a solution works
ColumnVector t = new ColumnVector(d);
for (int i = 0; i < d; i++)
{
t[i] = 1.0;
}
ColumnVector s = LU.Solve(t);
Assert.IsTrue(TestUtilities.IsNearlyEqual(V * s, t));
}
}
public void Test05()
{
Matrix X = new Matrix(
new RowVector(1, 2, 5),
new RowVector(2, 5, 7));
LUDecomposition lud = new LUDecomposition(X);
Assert.IsTrue(IsLowerTriangular(lud.L));
Assert.IsTrue(IsUpperTriangular(lud.U));
Assert.AreEqual(X, lud.P * lud.L * lud.U);
}
/// <summary>
/// Perform one iteration.
/// </summary>
public override void Iteration()
{
LUDecomposition decomposition;
PreIteration();
_hessian.Clear();
_weights = NetworkCODEC.NetworkToArray(_network);
_hessian.Compute();
double currentError = _hessian.SSE;
SaveDiagonal();
double startingError = currentError;
bool done = false;
while (!done)
{
ApplyLambda();
decomposition = new LUDecomposition(_hessian.HessianMatrix);
if (decomposition.IsNonsingular)
{
_deltas = decomposition.Solve(_hessian.Gradients);
UpdateWeights();
currentError = CalculateError();
if (currentError < startingError)
{
_lambda /= LevenbergMarquardtTraining.ScaleLambda;
done = true;
}
}
if (!done)
{
_lambda *= LevenbergMarquardtTraining.ScaleLambda;
if (_lambda > LevenbergMarquardtTraining.LambdaMax)
{
_lambda = LevenbergMarquardtTraining.LambdaMax;
done = true;
}
}
}
Error = currentError;
PostIteration();
}
/// <summary>
/// Creates a raster mapper from raster coordinates.
/// </summary>
/// <param name="mode">The raster mapping mode.</param>
/// <param name="coordinates">The list of coordinates.</param>
/// <returns>The raster mapper created by linear interpolation of the coordinates.</returns>
/// <exception cref="System.ArgumentNullException">The array of coordinates is null.</exception>
/// <exception cref="System.ArgumentException">
/// The number of coordinates with distinct column index is less than 2.
/// or
/// The number of coordinates with distinct row index is less than 2.
/// </exception>
public static RasterMapper FromCoordinates(RasterMapMode mode, IList <RasterCoordinate> coordinates)
{
if (coordinates == null)
{
throw new ArgumentNullException("The list of coordinates is null.", "coordinates");
}
if (coordinates.Select(coordinate => coordinate.ColumnIndex).Distinct().Count() < 2)
{
throw new ArgumentException("The number of coordinates with distinct column index is less than 2.", "coordinates");
}
if (coordinates.Select(coordinate => coordinate.RowIndex).Distinct().Count() < 2)
{
throw new ArgumentException("The number of coordinates with distinct row index is less than 2.", "coordinates");
}
// compute linear equation system in both dimensions
Int32[] columnIndices = coordinates.Select(coordinate => coordinate.ColumnIndex).Distinct().ToArray();
Int32[] rowIndices = coordinates.Select(coordinate => coordinate.ColumnIndex).Distinct().ToArray();
Matrix matrix = new Matrix(coordinates.Count, 3);
Vector vectorX = new Vector(coordinates.Count);
Vector vectorY = new Vector(coordinates.Count);
for (Int32 coordinateIndex = 0; coordinateIndex < coordinates.Count; coordinateIndex++)
{
matrix[coordinateIndex, 0] = coordinates[coordinateIndex].ColumnIndex;
matrix[coordinateIndex, 1] = coordinates[coordinateIndex].RowIndex;
matrix[coordinateIndex, 2] = 1;
vectorX[coordinateIndex] = coordinates[coordinateIndex].Coordinate.X;
vectorY[coordinateIndex] = coordinates[coordinateIndex].Coordinate.Y;
}
// solve equation using least squares method
Vector resultX = LUDecomposition.SolveEquation(matrix.Transpone() * matrix, matrix.Transpone() * vectorX);
Vector resultY = LUDecomposition.SolveEquation(matrix.Transpone() * matrix, matrix.Transpone() * vectorY);
// merge the results into a matrix
Matrix transformation = new Matrix(4, 4);
transformation[0, 0] = resultX[0];
transformation[0, 1] = resultX[1];
transformation[0, 3] = resultX[2];
transformation[1, 0] = resultY[0];
transformation[1, 1] = resultY[1];
transformation[1, 3] = resultY[2];
transformation[3, 3] = 1;
return(new RasterMapper(mode, transformation));
}
static void TestLU()
{
var mat = new double[2, 2];
mat[0, 0] = 1;
mat[0, 1] = 2;
mat[1, 0] = 3;
mat[1, 1] = -2;
var lu = new LUDecomposition(mat, true);
var ans = lu.SolveLinearEquations(new[] { 1.0, -2.0 });
Debug.Log(lu.Substitutions[0] + ", " + lu.Substitutions[1]);
Debug.Log(ans[0] + ", " + ans[1]);
}
public void Test01()
{
const double angle = Math.PI / 6;
Matrix X = new Matrix(new RowVector(Math.Cos(angle), -Math.Sin(angle), 0),
new RowVector(Math.Sin(angle), Math.Cos(angle), 0),
new RowVector(0, 0, 1));
LUDecomposition lud = new LUDecomposition(X);
Assert.IsTrue(IsLowerTriangular(lud.L));
Assert.IsTrue(IsUpperTriangular(lud.U));
Assert.AreEqual(X, lud.P * lud.L * lud.U);
Assert.AreEqual(1.0, X.Determinant, LisysConfig.CalculationLowerLimit);
}
public static Matrix Invert(Matrix A)
{
// New decomposition //
LUDecomposition lu = new LUDecomposition(A);
// New identity //
Matrix I = Matrix.Identity(A.RowCount);
return ~lu.solve(I);
}
/// <summary>
/// Solve A Linear System
/// </summary>
/// <param name="rhs"></param>
/// <returns></returns>
public Matrix Solve(Matrix rhs)
{
if (this.Width != this.Height)
{
if (QRDecomp == null) QRDecomp = new QRDecomposition(this);
return QRDecomp.Solve(rhs);
}
else
{
if (LUDecomp == null) LUDecomp = new LUDecomposition(this);
return LUDecomp.Solve(rhs);
}
}
/// <summary>
/// Indexer For a Vector Matrix. i is the row number.
/// </summary>
public virtual double this[int iRow]
{
get
{
return this._MatrixData[iRow, 0];
}
set
{
this._MatrixData[iRow, 0] = value;
this.LUDecomp = null;
this.QRDecomp = null;
this.EigenDecomp = null;
}
}
public static CellMatrix Invert(CellMatrix A)
{
// New decomposition //
LUDecomposition lu = new LUDecomposition(A);
// New identity //
CellMatrix I = CellMatrix.Identity(A.RowCount, A.Affinity);
return lu.solve(I);
}
public static void Main(string[] argv)
{
MagicSquareExample.print("\n Test of Matrix Class, using magic squares.\n");
MagicSquareExample.print(" See MagicSquareExample.main() for an explanation.\n");
MagicSquareExample.print("\n n trace max_eig rank cond lu_res qr_res\n\n");
DateTime now = DateTime.Now;
double num = Math.Pow(2.0, -52.0);
for (int i = 3; i <= 32; i++)
{
MagicSquareExample.print(MagicSquareExample.fixedWidthIntegertoString(i, 7));
JamaMatrix jamaMatrix = MagicSquareExample.magic(i);
int n = (int)jamaMatrix.trace();
MagicSquareExample.print(MagicSquareExample.fixedWidthIntegertoString(n, 10));
EigenvalueDecomposition eigenvalueDecomposition = new EigenvalueDecomposition(jamaMatrix.plus(jamaMatrix.transpose()).times(0.5));
double[] realEigenvalues = eigenvalueDecomposition.RealEigenvalues;
MagicSquareExample.print(MagicSquareExample.fixedWidthDoubletoString(realEigenvalues[i - 1], 14, 3));
int n2 = jamaMatrix.rank();
MagicSquareExample.print(MagicSquareExample.fixedWidthIntegertoString(n2, 7));
double num2 = jamaMatrix.cond();
MagicSquareExample.print((num2 < 1.0 / num) ? MagicSquareExample.fixedWidthDoubletoString(num2, 12, 3) : " Inf");
LUDecomposition lUDecomposition = new LUDecomposition(jamaMatrix);
JamaMatrix l = lUDecomposition.L;
JamaMatrix u = lUDecomposition.U;
int[] pivot = lUDecomposition.Pivot;
JamaMatrix jamaMatrix2 = l.times(u).minus(jamaMatrix.getMatrix(pivot, 0, i - 1));
double x = jamaMatrix2.norm1() / ((double)i * num);
MagicSquareExample.print(MagicSquareExample.fixedWidthDoubletoString(x, 12, 3));
QRDecomposition qRDecomposition = new QRDecomposition(jamaMatrix);
JamaMatrix q = qRDecomposition.Q;
jamaMatrix2 = qRDecomposition.R;
jamaMatrix2 = q.times(jamaMatrix2).minus(jamaMatrix);
x = jamaMatrix2.norm1() / ((double)i * num);
MagicSquareExample.print(MagicSquareExample.fixedWidthDoubletoString(x, 12, 3));
MagicSquareExample.print("\n");
}
double x2 = (double)(DateTime.Now.Ticks - now.Ticks) / 1000.0;
MagicSquareExample.print("\nElapsed Time = " + MagicSquareExample.fixedWidthDoubletoString(x2, 12, 3) + " seconds\n");
MagicSquareExample.print("Adios\n");
}
