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"); }