void Valid(Matrix m) { MyMatrix temp = new MyMatrix(m); for (int i = 0; i < 4; i++) { for (int k = 0; k < 4; k++) { Debug_c.Assert(float.IsNaN(temp[i, k]) == false); } } }
public static MyMatrix Clone(this MyMatrix theMatrix) { MyMatrix theClone = new MyMatrix(theMatrix.rows, theMatrix.columns); for (int i = 0; i < theMatrix.rows; ++i) { for (int j = 0; j < theMatrix.columns; ++j) { theClone[i, j] = theMatrix[i, j]; } } return theClone; }
public void FindIndexInVectorWithNumberTest() { //Arrange int[] a = { 4, 3, 2, 5, 6 }; const int expectedIndexValue = 1; //Act var result = MyMatrix <int> .FindIndexWithNumberInVector(a, 3); //Assert Assert.AreEqual(expectedIndexValue, result); }
public static void SumElements(this MyMatrix obj) { int k = 0; for (int x = 0; x < obj.Rows; x++) { for (int y = 0; y < obj.Cols; y++) { k += obj.Matrix[x, y]; } } Console.WriteLine("Cумма всех элементов матрицы " + k); }
public static void Zeroing(this MyMatrix obj) { for (int x = 0; x < obj.Rows; x++) { for (int y = 0; y < obj.Cols; y++) { if (obj.Matrix[x, y] < 0) { obj.Matrix[x, y] = 0; } } } }
public void FindsMax_InColumns_Of_Double_Matrix() { var m = new MyMatrix <double>(new[, ] { { 1.0, 2.0 }, { 3.0, 4.0 }, { 2.0, 6.0 }, { 3.5, 4.5 } }); Assert.Equal(3, m.FindMaxInColumn(0)); Assert.Equal(2, m.FindMaxInColumn(1)); }
/// <summary> /// Converts a screen space point into a corresponding point in world space. /// </summary> /// <param name="source">The vector to project.</param> /// <param name="projection">The projection matrix.</param> /// <param name="view">The view matrix.</param> /// <param name="world">The world matrix.</param> /// <returns>The unprojected Vector.</returns> public MyVector3 Unproject(MyVector3 source, MyMatrix projection, MyMatrix view, MyMatrix world) { MyMatrix matrix; MyMatrix.Multiply(ref world, ref view, out matrix); MyMatrix.Multiply(ref matrix, ref projection, out matrix); MyMatrix.Invert(ref matrix, out matrix); MyVector3 vector; Unproject(ref source, ref matrix, out vector); return(vector); }
/// <summary> Create a transposed matrix </summary> public MyMatrix Transpose() { MyMatrix result = new MyMatrix(this.cols, this.rows); for (int row = 0; row < this.rows; row++) { for (int col = 0; col < this.cols; col++) { result[col, row] = this.data[row, col]; } } return(result); }
public static MyMatrix ZeroMatrix(int iRows, int iCols) // Function generates the zero matrix { MyMatrix matrix = new MyMatrix(iRows, iCols); for (int i = 0; i < iRows; i++) { for (int j = 0; j < iCols; j++) { matrix[i, j] = 0; } } return(matrix); }
private static MyMatrix Multiply(int n, MyMatrix m) // Multiplication by constant n { MyMatrix r = new MyMatrix(m.rows, m.cols); for (int i = 0; i < m.rows; i++) { for (int j = 0; j < m.cols; j++) { r[i, j] = m[i, j] * n; } } return(r); }
public void VerifyThatSubtractThrowsException(MyMatrix <MDouble> a, MyMatrix <MDouble> b, MyMatrix <MDouble> res) { TestContext.WriteLine(a); TestContext.WriteLine(" minus "); TestContext.WriteLine(b); TestContext.WriteLine(" equals "); TestContext.WriteLine("Exception!"); Assert.Throws <ArgumentException>( () => { var x = a - b; }); }
public void CheckEqualityOfSolvingMethods(int size) { var templateMatrix = MyMatrix <MDouble> .GetRandomMatrix(size, size); var templateVector = MyMatrix <MDouble> .GetRandomMatrix(1, size); var solved1 = templateMatrix.SolveLinearEquation(templateVector, LinearSolver.Gauss); var solved2 = templateMatrix.SolveLinearEquation(templateVector, LinearSolver.PartialGauss); var solved3 = templateMatrix.SolveLinearEquation(templateVector, LinearSolver.FullGauss); Assert.AreEqual(solved1, solved2); Assert.AreEqual(solved2, solved3); }
public static void SumElements <T>(this MyMatrix <T> obj) where T : IComparable { dynamic k = 0; for (int x = 0; x < obj.Rows; x++) { for (int y = 0; y < obj.Cols; y++) { k += obj.Matrix[x, y]; } } Console.WriteLine("Cумма всех элементов матрицы " + k); }
public static void Zeroing <T>(this MyMatrix <T> obj) where T : IComparable { for (int x = 0; x < obj.Rows; x++) { for (int y = 0; y < obj.Cols; y++) { if ((dynamic)obj.Matrix[x, y] < 0) //Во время компиляции предполагается что элементы с типом dynamic поддерживают любые операции { obj.Matrix[x, y] = default(T); } } } }
public static MyMatrix Transpose(MyMatrix m) // Matrix transpose, for any rectangular matrix { MyMatrix t = new MyMatrix(m.cols, m.rows); for (int i = 0; i < m.rows; i++) { for (int j = 0; j < m.cols; j++) { t[j, i] = m[i, j]; } } return(t); }
private static void ExecuteMatrixOptions(ref MyMatrix baseMatrix) { int[] valuePosition; bool executeOptions = true; do { Write("Enter the option: "); switch (ReadLine()) { case "1": baseMatrix += GetInputMatrix(); WriteLine(baseMatrix.GetFormattedMatrix()); break; case "2": baseMatrix *= GetInputMatrix(); WriteLine(baseMatrix.GetFormattedMatrix()); break; case "3": baseMatrix.TransponeMe(); WriteLine(baseMatrix.GetFormattedMatrix()); break; case "4": WriteLine(baseMatrix.GetFormattedMatrix()); break; case "5": valuePosition = GetValuePosition(); WriteLine($"Value: {baseMatrix.GetValue(valuePosition[0], valuePosition[1])}"); break; case "6": valuePosition = GetValuePosition(); int value = GetInputNumber(); baseMatrix.SetValue(valuePosition[0], valuePosition[1], value); WriteLine(baseMatrix.GetFormattedMatrix()); break; case "7": baseMatrix = GetInputMatrix(); break; default: executeOptions = false; break; } } while (executeOptions); }
/// <summary> /// Projects a 3D vector from object space into screen space. /// </summary> /// <param name="source">The vector to project.</param> /// <param name="matrix">A combined WorldViewProjection matrix.</param> /// <param name="vector">The projected vector.</param> public void Project(ref MyVector3 source, ref MyMatrix matrix, out MyVector3 vector) { MyVector3.Transform(ref source, ref matrix, out vector); float a = (((source.X * matrix.M14) + (source.Y * matrix.M24)) + (source.Z * matrix.M34)) + matrix.M44; if (!MyMathf.IsOne(a)) { vector = (vector / a); } vector.X = (((vector.X + 1f) * 0.5f) * Width) + X; vector.Y = (((-vector.Y + 1f) * 0.5f) * Height) + Y; vector.Z = (vector.Z * (MaxDepth - MinDepth)) + MinDepth; }
private static void SafeACopytoC(MyMatrix A, int xa, int ya, MyMatrix C, int size) { for (int i = 0; i < size; i++) // rows { for (int j = 0; j < size; j++) // cols { C[i, j] = 0; if (xa + j < A.cols && ya + i < A.rows) { C[i, j] += A[ya + i, xa + j]; } } } }
public void TestMethodAvgFunction() { bool check = false; MyMatrix myMatrix = new MyMatrix(); int[,] matrix = new int[3, 3] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; if (myMatrix.AvgArr(matrix) == 5) { check = true; } Assert.IsTrue(check); }
public void OperatorMinus_ShouldReturn_ExpectedMatrix() { int[,] arr1 = { { 2, 3 }, { 1, 1 } }; MyMatrix m1 = new MyMatrix(arr1); int[,] arr2 = { { 1, 1 }, { 3, 3 } }; MyMatrix m2 = new MyMatrix(arr2); MyMatrix m3 = m1 - m2; int[,] excpected = { { 1, 2 }, { -2, -2 } }; Assert.IsTrue(m3 == new MyMatrix(excpected)); }
public void OperatorIsEqualTo_ShouldReturn_True() { int[,] arr1 = { { 2, 3 }, { 1, 1 } }; MyMatrix m1 = new MyMatrix(arr1); int[,] arr2 = { { 1, 1 }, { 3, 3 } }; MyMatrix m2 = new MyMatrix(arr2); MyMatrix m3 = m1 * m2; int[,] excpected = { { 11, 11 }, { 4, 4 } }; Assert.IsTrue(m3 == new MyMatrix(excpected)); }
public static MyMatrix Transposed(MyMatrix mat) { MyMatrix newMatrix = new MyMatrix(mat.m_columnCountX, mat.m_rowCountY); for (int x = 0; x < newMatrix.m_columnCountX; x++) { for (int y = 0; y < newMatrix.m_rowCountY; y++) { newMatrix.m_data[y][x] = mat.m_data[x][y]; } } return(newMatrix); }
public void OperatorIsNotEqualTo_ShouldReturn_False() { int[,] arr1 = { { 2, 3 }, { 1, 1 } }; MyMatrix m1 = new MyMatrix(arr1); int[,] arr2 = { { 1, 1 }, { 3, 3 } }; MyMatrix m2 = new MyMatrix(arr2); MyMatrix m3 = m1 * m2; int[,] excpected = { { 5, 15 }, { 2, 6 } }; Assert.IsFalse(m3 == new MyMatrix(excpected)); }
public void Append(MyMatrix M, int l) { //矩阵在右边或下边concatenate // 0 for col; 1 for row if (l == 0) { int c = this.Cols; this.Cols += M.Cols; var newValue = new double[this.Rows, this.Cols]; for (int i = 0; i < this.Cols; i++) { for (int j = 0; j < this.Rows; j++) { if (i < c) { newValue[j, i] = Value[j, i]; } else { newValue[j, i] = M.Value[j, i - c]; } } } Value = null; Value = newValue; } if (l == 1) { int r = this.Rows; this.Rows += M.Rows; var newValue = new double[this.Rows, this.Cols]; for (int i = 0; i < this.Cols; i++) { for (int j = 0; j < this.Rows; j++) { if (j < r) { newValue[j, i] = Value[j, i]; } else { newValue[j, i] = M.Value[j - r, i]; } } } Value = null; Value = newValue; } }
private MyMatrix GetWeightDecayRate(MyMatrix weights) { MyMatrix mat = new MyMatrix(weights, false); for (int y = 0; y < weights.m_rowCountY; y++) { for (int x = 0; x < weights.m_columnCountX; x++) { //mat.m_data[y][x] = } } return(mat); }
public MyMatrix(MyMatrix M) { //复制构造函数 this.Rows = M.Rows; this.Cols = M.Cols; this.Value = new double[Rows, Cols]; for (int i = 0; i < Rows; i++) { for (int j = 0; j < Cols; j++) { Value[i, j] = M.Value[i, j]; } } }
public void MatrixToStringTest() { //Arrange var matrixArray = _matrixFileReader.ReadIntMatrix(); var matrix = new MyMatrix <int>(_matrixFileReader); //Act var result = matrix.ToString(); foreach (var value in matrixArray) { StringAssert.Contains(result, value.ToString()); } }
public static MyMatrix RandomMatrix(int iRows, int iCols, int dispersion) // Function generates the random matrix { Random random = new Random(); MyMatrix matrix = new MyMatrix(iRows, iCols); for (int i = 0; i < iRows; i++) { for (int j = 0; j < iCols; j++) { matrix[i, j] = random.Next(-dispersion, dispersion); } } return(matrix); }
public void VerifyThatRandomMatrixIsNotNull(int size) { var x = MyMatrix <MDouble> .GetRandomMatrix(size, size); Assert.AreEqual(size, x.Height); Assert.AreEqual(size, x.Width); for (int i = 0; i < x.Height; i++) { for (int j = 0; j < x.Width; j++) { Assert.NotNull(x[i, j]); } } }
/// <summary> Iteratively solve the coefficients using Gauss-Newton method </summary> /// <remarks> http://en.wikipedia.org/wiki/Gauss%E2%80%93Newton_algorithm </remarks> public double[] Solve() { if (this.ys == null) { throw new InvalidOperationException("Not yet initialized"); } double lastSSE = double.MaxValue; double[] errors = new double[this.ys.Length]; // let C0 be the current coefficient guess, C1 be the better answer we are after // let E0 be the error using current guess // we have: // JacT * Jac * (C1 - C0) = JacT * E0 // MyMatrix jacobian = Jacobian(); MyMatrix jacobianT = jacobian.Transpose(); MyMatrix product = jacobianT * jacobian; SquareMatrix inverse = SquareMatrix.FromMatrix(product).Inverse(); for (int iteration = 0; iteration < GaussNewton.MaxIteration; iteration++) { this.sse = 0; for (int i = 0; i < this.ys.Length; i++) { double y = function(this.coefficients, this.xs[i]); errors[i] = this.ys[i] - y; sse += errors[i] * errors[i]; } if (lastSSE - sse < GaussNewton.ConvergeThreshold) { this.solved = true; return(this.coefficients); } double[] shift = inverse * (jacobianT * errors); for (int i = 0; i < this.coefficientCount; i++) { this.coefficients[i] += shift[i]; } lastSSE = sse; } throw new InvalidOperationException("No answer can be found"); }
public static double throwCError( [Parameter("Just any random string ")] string err ) { MyMatrix theMatrix = new MyMatrix(2,2); return theMatrix[3,3]; }