/// <summary> /// creates an identity transformation /// </summary> /// <param name="D">spatial dimension</param> /// <returns></returns> public static AffineTrafo ID(int D) { AffineTrafo tr = new AffineTrafo(); tr.Matrix = FullMatrix.Eye(D); tr.Affine = new double[D]; return(tr); }
/// <summary> /// entriesAsColMajor is assumed to be col major form /// </summary> public static IMatrix<double> GetMatrix(Guid id, int nodeCount, string entriesAsColMajor) { double[] components = null; if (!MatrixHelper.ParseEntryString(nodeCount, entriesAsColMajor, out components)) throw new ArgumentException(string.Format("Could not parse the matrix entry string: \"{0}\"", entriesAsColMajor), "entriesAsColMajor"); IMatrix<double> target = new FullMatrix<Double>(id, components, nodeCount); return target; }
void PlotCell0() { BoundingBox BB = new BoundingBox(2); GridDat.Cells.GetCellBoundingBox(0, BB); int Nx = 50; int Ny = 55; var xNodes = Grid1D.Linspace(BB.Min[0], BB.Max[0], Nx); var yNodes = Grid1D.Linspace(BB.Min[1], BB.Max[1], Ny); var GlobalNodes = MultidimensionalArray.Create(Nx, Ny, 2); for (int i = 0; i < Nx; i++) { for (int j = 0; j < Ny; j++) { GlobalNodes[i, j, 0] = xNodes[i]; GlobalNodes[i, j, 1] = yNodes[j]; } } var GlobalNodes_C = GlobalNodes.ResizeShallow(Nx * Ny, 2); var LocalNodes = MultidimensionalArray.Create(1, Nx * Ny, 2); GridDat.TransformGlobal2Local(GlobalNodes_C, LocalNodes, 0, 1, 0); var Values = MultidimensionalArray.Create(1, Nx, Ny); var Values_ = Values.ResizeShallow(1, Nx * Ny); var Gradients = MultidimensionalArray.Create(1, Nx, Ny, 2); var Gradients_ = Gradients.ResizeShallow(1, Nx * Ny, 2); var NodeSet = GridDat.NSC.CreateContainer(LocalNodes.ExtractSubArrayShallow(0, -1, -1), 0); var lh = GridDat.NSC.LockNodeSetFamily(NodeSet); f1.Evaluate(0, 1, 0, Values_); f1.EvaluateGradient(0, 1, 0, Gradients_); GridDat.NSC.UnlockNodeSetFamily(lh); xNodes.SaveToTextFile("C:\\tmp\\xNodes.txt"); yNodes.SaveToTextFile("C:\\tmp\\yNodes.txt"); FullMatrix output1 = new FullMatrix(Values.ExtractSubArrayShallow(0, -1, -1)); output1.ToTxtFile("C:\\tmp\\f.txt"); FullMatrix output2 = new FullMatrix(Gradients.ExtractSubArrayShallow(0, -1, -1, 0)); output2.ToTxtFile("C:\\tmp\\df.txt"); }
/// <summary> /// returns a 2D transformation /// </summary> public static AffineTrafo Some2DRotation(double angle) { AffineTrafo Trafo = new AffineTrafo(); FullMatrix dreh = new FullMatrix(2, 2); dreh[0, 0] = Math.Cos(angle); dreh[0, 1] = -Math.Sin(angle); dreh[1, 0] = Math.Sin(angle); dreh[1, 1] = Math.Cos(angle); Trafo.Affine = new double[2]; Trafo.Matrix = dreh; return(Trafo); }
public void BuildEmptyFullMatrix(Int32 nodeCount) { var fullMatrix = new FullMatrix<Boolean>(Guid.NewGuid(), nodeCount); Assert.NotNull(fullMatrix); Int32 count = Enumerable.Range(0, nodeCount).AsParallel() .Select(i => Enumerable.Range(i, nodeCount - i).AsParallel() .Count(j => fullMatrix[i, j] != false) ).Count(v => v != 0); Assert.Equal(0, count); }
public void BuildFullMatrixFromDoubleArray() { Int32[,] dblArray = new Int32[,] { {1, 2, 3}, {2, 1, 2}, {3, 2, 1} }; var fullMatrix = new FullMatrix<Int32>(Guid.NewGuid(), dblArray); Assert.NotNull(fullMatrix); Assert.Equal(dblArray[0, 0], fullMatrix[0, 0]); Assert.Equal(dblArray[0, 1], fullMatrix[0, 1]); Assert.Equal(dblArray[2, 1], fullMatrix[2, 1]); }
public static IMatrix<double> GetMatrix(int nodeCount, string entriesAsColMajor, bool symmetric) { double[] components = null; if (!MatrixHelper.ParseEntryString(nodeCount, entriesAsColMajor, out components)) throw new ArgumentException(string.Format("Could not parse the matrix entry string: \"{0}\"", entriesAsColMajor), "entriesAsColMajor"); IMatrix<double> target = null; if (symmetric) { target = new SymmetricMatrix<double>(Guid.NewGuid(), components, nodeCount); } else { target = new FullMatrix<double>(Guid.NewGuid(), components, nodeCount); } return target; }
public void BuildFullMatrixFromSingleArray() { Int32[] sglArray = new Int32[] { 1, 2, 3, 2, 1, 2, 3, 2, 1 }; var fullMatrix = new FullMatrix<Int32>(Guid.NewGuid(), sglArray, 3); Assert.NotNull(fullMatrix); Assert.Equal(sglArray[0], fullMatrix[0, 0]); Assert.Equal(sglArray[2], fullMatrix[0, 2]); Assert.Equal(sglArray[6], fullMatrix[2, 0]); Assert.Equal(sglArray[7], fullMatrix[2, 1]); }
void OrthonormalityTest() { Basis B = f1.Basis; int N = B.Length; var Mtx = new FullMatrix(N, N); double TotErrSum = 0.0; CellQuadrature.GetQuadrature(new int[] { N, N }, this.GridDat, (new CellQuadratureScheme(true)).Compile(GridDat, Math.Min(B.Degree * 2, 16)), delegate(MultidimensionalArray NodesUntransformed, int iKref) { var ret = new NodeSetController.NodeSetContainer[] { GridDat.NSC.CreateContainer(NodesUntransformed, iKref) }; return(ret); }, delegate(int i0, int Length, int NoOfNodes, MultidimensionalArray EvalResult) { // void Del_Evaluate var BasisVal = B.CellEval(0, i0, Length); EvalResult.Multiply(1.0, BasisVal, BasisVal, 0.0, "jknm", "jkn", "jkm"); }, delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) { // SaveIntegrationResults for (int i = 0; i < Length; i++) { var MassMtx = ResultsOfIntegration.ExtractSubArrayShallow(i, -1, -1); double errsum = 0; for (int n = 0; n < N; n++) { for (int m = 0; m < N; m++) { double soll = (n == m) ? 1.0 : 0.0; errsum += Math.Abs(MassMtx[m, n] - soll); } } TotErrSum += errsum; } }).Execute(); Console.WriteLine("orthonormality error sum:" + TotErrSum); }
public void IsBinaryReturnsTrueAndFalseForInt32Matrix() { Int32[,] dblArray = new Int32[,] { {0, 0, 1, 0}, {1, 1, 0, 0}, {0, 0, 0, 0}, {1, 0, 0, 1} }; var fullMatrix = new FullMatrix<Int32>(Guid.NewGuid(), dblArray); Assert.True(fullMatrix.IsBinary); fullMatrix.SetEdge(2, 2, 3); Assert.False(fullMatrix.IsBinary); }
public void SuccessorsThrowsExceptionIfIndexIsOutOfRange() { Int32[,] dblArray = new Int32[,] { {1, 2, 3}, {2, 1, 2}, {3, 2, 1} }; var fullMatrix = new FullMatrix<Int32>(Guid.NewGuid(), dblArray); Assert.Throws<IndexOutOfRangeException>(() => fullMatrix.Successors(4)); Assert.Throws<IndexOutOfRangeException>(() => fullMatrix.Successors(-1)); }
public void SetUpdatesMatrixEntry(int i, int j, double newValue) { Double[,] dblArray = new Double[,] { {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, }; var fullMatrix = new FullMatrix<Double>(Guid.NewGuid(), dblArray); fullMatrix.SetEdge(i, j, newValue); Assert.Equal(newValue, fullMatrix[i, j]); }
public void SetEdgeThrowsExceptionIfIndexIsOutOfRange() { Int32[,] dblArray = new Int32[,] { {1, 2, 3}, {2, 1, 2}, {3, 2, 1} }; var fullMatrix = new FullMatrix<Int32>(Guid.NewGuid(), dblArray); Assert.Throws<IndexOutOfRangeException>(() => fullMatrix.SetEdge(4, 0, 3)); Assert.Throws<IndexOutOfRangeException>(() => fullMatrix.SetEdge(1, -1, -10)); }
public void IsBinaryReturnsTrueForBooleanMatrix() { Boolean[,] dblArray = new Boolean[,] { {false, false, true, false}, {true, true, false, false}, {false, false, false, false}, {true, true, false, true} }; var fullMatrix = new FullMatrix<Boolean>(Guid.NewGuid(), dblArray); Assert.True(fullMatrix.IsBinary); }
public void IsBinaryReturnsTrueAndFalseForDoubleMatrix() { Double[,] dblArray = new Double[,] { {0, 0, 1, 0}, {1, 1, 0, 0}, {0, 0, 0, 0}, {1, 0, 0, 1} }; var fullMatrix = new FullMatrix<Double>(Guid.NewGuid(), dblArray); Assert.True(fullMatrix.IsBinary); fullMatrix.SetEdge(2, 2, 1.444); Assert.False(fullMatrix.IsBinary); }
public void InDegreeThrowsExceptionIfIndexIsOutOfRange() { Int32[,] dblArray = new Int32[,] { {1, 2, 3}, {2, 1, 2}, {3, 2, 1} }; var fullMatrix = new FullMatrix<Int32>(Guid.NewGuid(), dblArray); Assert.Throws<AggregateException>(() => fullMatrix.InDegree(4)); Assert.Throws<AggregateException>(() => fullMatrix.InDegree(-1)); }
/// <summary> /// computes matrix and affine vector of the affine-linear transformation /// that maps the vectors in the <paramref name="preimage"/> to <paramref name="image"/>; /// </summary> /// <param name="preimage"> /// The preimage: (D+1) vectors of dimension D; /// <list type="bullet"> /// <item>1st index: vector/vertex index, length is D+1</item> /// <item>2nd index: spatial dimension, length is D</item> /// </list> /// Tip: use <see cref="ilPSP.Utils.ArrayTools.Transpose{t}(t[,],t[,])"/> /// if the sequence of indices is not appropriate; /// </param> /// <param name="image"> /// The image: (D+1) vectors of dimension D; /// <list type="bullet"> /// <item>1st index: vector/vertex index, length is D+1</item> /// <item>2nd index: spatial dimension, length is D</item> /// </list> /// </param> /// <returns></returns> public static AffineTrafo FromPoints(double[,] preimage, double[,] image) { int D = preimage.GetLength(1); if (image.GetLength(1) != D || image.GetLength(0) != D + 1) { throw new ArgumentException("wrong size; expecting " + D + "x" + (D + 1) + " - array;", "image"); } if (preimage.GetLength(0) != D + 1) { throw new ArgumentException("wrong size; expecting " + D + "x" + (D + 1) + " - array;", "preimage"); } FullMatrix M = new FullMatrix(D * (D + 1), D * (D + 1)); double[] rhs = new double[M.NoOfCols]; double[] x = (double[])rhs.Clone(); // gesucht: affine lineare Transformation: "xi -> x" // preimage = xi, image = x; // // x = Tr*xi + o // // Sei z.B. D=2 (andere D's ergeben sich analog) // x1 = (x11,x12)^T, x2 = (x21,x22)^T, x3 seien die Bilder von // xi1 = (xi11,xi12), xi2, xi3. // // gesucht sind die Matrix Tr und der Vektor o = (o1,o2)^T, // // [ Tr11 Tr12 ] // Tr = [ ], // [ Tr21 Tr22 ] // // welche mit einem Glsys. der folgenden Form berechnet werden: // // [ 1 0 xi11 xi12 0 0 ] [ o1 ] [ x11 ] // [ 0 1 0 0 xi11 xi12 ] [ o2 ] [ x12 ] // [ ] [ 0 ] [ ] // [ 1 0 xi21 xi22 0 0 ] * [ T11 ] = [ x21 ] // [ 0 1 0 0 xi21 xi22 ] [ T12 ] [ x22 ] // [ ] [ ] [ ] // [ 1 0 xi31 xi32 0 0 ] [ T21 ] [ x31 ] // [ 0 1 0 0 xi31 xi32 ] [ T22 ] [ x31 ] // // // build rhs for (int d = 0; d < (D + 1); d++) { for (int dd = 0; dd < D; dd++) { rhs[d * D + dd] = image[d, dd]; } } // build matrix M.Clear(); for (int d = 0; d < (D + 1); d++) { for (int dd = 0; dd < D; dd++) { M[d * D + dd, dd] = 1.0; for (int ddd = 0; ddd < D; ddd++) { M[d * D + dd, D + D * dd + ddd] = preimage[d, ddd]; } } } // solve Matrix M.Solve(x, rhs); // save results, return AffineTrafo Trafo = new AffineTrafo(); Trafo.Affine = new double[D]; Trafo.Matrix = new FullMatrix(D, D); for (int d = 0; d < D; d++) { Trafo.Affine[d] = x[d]; for (int dd = 0; dd < D; dd++) { Trafo.Matrix[d, dd] = x[D + d * D + dd]; } } return(Trafo); }