static Matrix2Facts() { _identity = new Matrix2( 1, 0, 0, 1); _incremented = new Matrix2( 0, 1, 2, 3); _determinant34 = new Matrix2( 3, -8, 5, -2); _priorInvert = new Matrix2( 1, 3, 2, 4); _postInvert = new Matrix2( -2, 1.5, 1, -0.5); _trans = new Matrix2( 0, 2, 1, 3); _a = new Matrix2( 3, 1, -10, -2); _b = new Matrix2( 2, 3, -4, 5); _product = new Matrix2( 2, 14, -12, -40); _sum = new Matrix2( 5, 4, -14, 3); }
public void RunTests() { Matrix2 a, b; DXMtx dxa, dxb; a = new Matrix2(1, 2, 2, 1); b = new Matrix2(3, 1, 4, 2); dxa = new DXMtx(); dxb = new DXMtx(); dxa.M11 = 1; dxa.M12 = 2; dxa.M21 = 2; dxa.M22 = 1; dxa.M33 = 1; dxa.M44 = 1; dxb.M11 = 3; dxb.M12 = 1; dxb.M21 = 4; dxb.M22 = 2; RotationAngle = (float)(30 * Math.PI / 180); TestAdd(a, b, dxa, dxb); TestSub(a, b, dxa, dxb); TestMul(a, b, dxa, dxb); TestTranspose(a, dxa); TestInvert(a, dxa); TestRotation(); PrintResults(a, b); }
public static void set_identity() { var m = new Matrix2(_incremented); m.SetIdentity(); m.Should().Be(_identity); }
public static void elements_set_batch() { var m = new Matrix2(); m.SetElements(0, 1, 2, 3); m.Should().Be(_incremented); }
public void Construct1() { Matrix2<double> m = new Matrix2<double>(1.0); for (int i = 0; i < m.NumberOfComponents; ++i) { Assert.AreEqual(1.0, m.ReadOnlyColumnMajorValues[0], 1e-14); } }
public void PrintResults(Matrix2 a, Matrix2 b) { Console.WriteLine("Matrix 2 Tests:"); Console.WriteLine("A: {0}\nB: {1}", a, b); Console.WriteLine("A + B: {0} ({1}) -- {2}", AdditionResults[0], AdditionResults[1], Passed(AdditionResults[0] == AdditionResults[1])); Console.WriteLine("A - B: {0} ({1}) -- {2}", SubtractionResults[0], SubtractionResults[1], Passed(SubtractionResults[0] == SubtractionResults[1])); Console.WriteLine("A * B: {0} ({1}) -- {2}", MultiplyResults[0], MultiplyResults[1], Passed(MultiplyResults[0] == MultiplyResults[1])); Console.WriteLine("A^T: {0} ({1}) -- {2}", TransposeResults[0], TransposeResults[1], Passed(TransposeResults[0] == TransposeResults[1])); Console.WriteLine("A^-1: {0} ({1}) -- {2}", InverseResults[0], InverseResults[1], Passed(InverseResults[0] == InverseResults[1])); Console.WriteLine("Rotation: {0} ({1}) -- {2}", RotationResults[0], RotationResults[1], Passed(RotationResults[0] == RotationResults[1])); }
public static void TransformPoints(ref Matrix2 matrix, IList <IPointShape> points) { if (points == null || points.Count == 0) { return; } for (int i = 0; i < points.Count; i++) { TransformPoint(ref matrix, points[i]); } }
public void MatrixSetMatrix() { Vector2 v1 = new Vector2(4, 5); Vector2 v2 = new Vector2(6, 7); Matrix2 matrix = new Matrix2(new double[] { 0, 1, 2, 3 }); matrix.SetMatrix(v1, v2); Assert.AreEqual(matrix[0], v1); Assert.AreEqual(matrix[1], v2); }
public void NegateMatrix2(float m11, float m12, float m21, float m22) { var matrix = new Matrix2(m11, m12, m21, m22); var result = matrix.Negate().Matrix; var expected = new[, ] { { -m11, -m12 }, { -m21, -m22 } };; Assert.Equal(expected, result); }
public void CreateWithFourValues( float m11, float m12, float m21, float m22) { var result = new Matrix2(m11, m12, m21, m22).Matrix; var expected = new[, ] { { m11, m12 }, { m21, m22 } }; Assert.Equal(expected, result); }
public void TransposeMatrix2(float m11, float m12, float m21, float m22) { var matrix = new Matrix2(m11, m12, m21, m22); var result = matrix.Transpose().Matrix; var expected = new[, ] { { m11, m21 }, { m12, m22 } };; Assert.Equal(expected, result); }
public bool ContainsRotated(Vector2 pt, Vector2 rotationCenter, float angle) { if (angle == 0) { return(Contains(pt)); } Matrix2 rotationMatrix = Matrix2.CreateRotation(-angle); Vector2 rotatedPt = (pt - rotationCenter) * rotationMatrix + rotationCenter; return(Contains(rotatedPt.X, rotatedPt.Y)); }
public void SetVariable(string name, Matrix2 matrix) { if (ProgramId > 0) { GLStates.UseProgram(ProgramId); int location = GetUniformLocation(name); if (location != -1) { GL.UniformMatrix2(location, false, ref matrix); } } }
public void TransposeStatic_ByRef() { var input = GetTestMatrix(); var inputSimd = (MatrixFloat2x2)input; Matrix2 expected; MatrixFloat2x2 actual; Matrix2.Transpose(ref input, out expected); MatrixFloat2x2.Transpose(ref inputSimd, out actual); Asserts.AreEqual(expected, actual, "transpose out/ref"); }
public bool OnScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { //Debug.WriteLine("Control_ManipulationDelta"); // UWP delta とは逆値 Element.ViewPoint = Element.ViewPoint.Offset(distanceX / Element.ViewScale, distanceY / Element.ViewScale); DrawImage = Element.DrawImmageRequest(Element.ViewPoint, Matrix2.Enlargement(ViewSize, 1 / Element.ViewScale, 1 / Element.ViewScale)); Invalidate(); return(true); }
public void IdentityMultMatrix2() { Matrix2 m1 = new Matrix2(1, 7, 2, -4); Matrix2 identityM = new Matrix2(); Matrix2 result = m1 * identityM; Matrix2 answer = new Matrix2(1, 7, 2, -4); Assert.True(answer == result); }
/// <summary> /// Transforms a point from the agent's local space into world space. /// </summary> public static Vector2 PointToWorldSpace( Vector2 point, Vector2 agentHeading, Vector2 agentSide, Vector2 agentPosition) { Vector2 transformPoint = new Vector2(point); Matrix2 matrix = new Matrix2(); matrix.Rotate(agentHeading, agentSide); matrix.Translate(agentPosition.X, agentPosition.Y); Vector2 result = matrix.Transform(transformPoint); return result; }
public void SubtractTwoMatrices(float m11, float m12, float m21, float m22) { var matrix1 = new Matrix2(m11, m12, m21, m22); var matrix2 = new Matrix2(m11, m12, m21, m22); var expected = new[, ] { { m11 - m11, m12 - m12 }, { m21 - m21, m22 - m22 } }; var result = (matrix1 - matrix2).Matrix; Assert.Equal(expected, result); }
public void AddTwoMatrices(float m11, float m12, float m21, float m22) { var matrix1 = new Matrix2(m11, m12, m21, m22); var matrix2 = new Matrix2(m11, m12, m21, m22); var expected = new[, ] { { m11 + m11, m12 + m12 }, { m21 + m21, m22 + m22 } }; var result = (matrix1 + matrix2).Matrix; Assert.Equal(expected, result); }
public void DoubleToFloat() { Matrix2<double> m = new Matrix2<double>( 1.0, 2.0, 3.0, 4.0); Matrix2<float> mf = Matrix2<double>.DoubleToFloat(m); Assert.AreEqual(1.0f, mf.Column0Row0, 1e-7); Assert.AreEqual(2.0f, mf.Column1Row0, 1e-7); Assert.AreEqual(3.0f, mf.Column0Row1, 1e-7); Assert.AreEqual(4.0f, mf.Column1Row1, 1e-7); }
public static Matrix2 ZeroMatrix() { Matrix2 matrix = new Matrix2(); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { matrix[i, j] = 0; } } return(matrix); }
public static Matrix2 Transpose(Matrix2 m) { Matrix2 t = new Matrix2(); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { t[j, i] = m[i, j]; } } return(t); }
private static Matrix2 Multiply(float n, Matrix2 m) { Matrix2 r = new Matrix2(); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { r[i, j] = m[i, j] * n; } } return(r); }
public void Determinant_ShouldReturnExpectedValue() { // arrange var sut = new Matrix2(new[, ] { { 1f, 5f }, { -3f, 2f } }); // act var result = sut.Determinant(); // assert result.Should().Be(17); }
private static Matrix2 Add(Matrix2 m1, Matrix2 m2) { Matrix2 r = new Matrix2(); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { r[i, j] = m1[i, j] + m2[i, j]; } } return(r); }
public void MatrixCreateRotation() { Matrix2 rot0deg = new Matrix2(1, 0, 0, 1); Matrix2 rot90deg = new Matrix2(0, -1, 1, 0); Matrix2 rot180deg = new Matrix2(-1, 0, 0, -1); Matrix2 rot270deg = new Matrix2(0, 1, -1, 0); CompareMatrices(Matrix2.CreateRotation((float)Math.PI * 0.0f), rot0deg, 10e-7f); CompareMatrices(Matrix2.CreateRotation((float)Math.PI * 0.5f), rot90deg, 10e-7f); CompareMatrices(Matrix2.CreateRotation((float)Math.PI * 1.0f), rot180deg, 10e-7f); CompareMatrices(Matrix2.CreateRotation((float)Math.PI * 1.5f), rot270deg, 10e-7f); CompareMatrices(Matrix2.CreateRotation((float)Math.PI * 2.0f), rot0deg, 10e-7f); }
public void Rotate(float deg) { float turn = deg * MathHelper.DEG_RAD; r += turn; Matrix2 temp = References.matrix; temp.SetRotation(turn); p[0].MulMatrix2(temp); p[1].MulMatrix2(temp); p[2].MulMatrix2(temp); p[3].MulMatrix2(temp); }
public void SetMatrix(string name, Matrix2 data) { if (disposed) { throw new ObjectDisposedException("Shader: " + name); } if (_uniformLocations.ContainsKey(name)) { GL.UseProgram(Handle); GL.UniformMatrix2(_uniformLocations[name], true, ref data); } }
public void SubMatrix_ShouldReturnExpectedMatrix2(int row, int column, Matrix2 expected) { // arrange var sut = new Matrix3(new[, ] { { 1f, 2f, 3f }, { 4f, 5f, 6f }, { 7f, 8f, 9f } }); // act var actual = sut.SubMatrix(row, column); // assert actual.Should().Be(expected); }
public void SetRotation(float deg) { float prevr = r; r = deg * MathHelper.DEG_RAD; Matrix2 temp = References.matrix; temp.SetRotation(-prevr + r); p[0].MulMatrix2(temp); p[1].MulMatrix2(temp); p[2].MulMatrix2(temp); p[3].MulMatrix2(temp); }
public void MatrixToFloat() { float[] array = new float[] { 10, 20, 30, 40 }; Matrix2 matrix = new Matrix2(array); float[] comparison = matrix.ToFloat(); Assert.AreEqual(comparison.Length, array.Length); for (int i = 0; i < array.Length; i++) { Assert.AreEqual(comparison[i], array[i]); } }
private Line RotateLine(Line stick, float rotationAngle) { var mtxRotation = Matrix2.CreateRotation(rotationAngle); Vector2 a; a.X = Vector2.Dot(mtxRotation.Column0, stick.Item1); a.Y = Vector2.Dot(mtxRotation.Column1, stick.Item1); Vector2 b; b.X = Vector2.Dot(mtxRotation.Column0, stick.Item2); b.Y = Vector2.Dot(mtxRotation.Column1, stick.Item2); return(new Line(a, b)); }
public void Multiply_Operator() { var inputL = GetTestMatrix(); var inputR = GetTestMatrix(); var inputSimdL = (MatrixFloat2x2)inputL; var inputSimdR = (MatrixFloat2x2)inputR; Matrix2 expected; Matrix2.Multiply(ref inputR, ref inputL, out expected); // OpenTK.Matrix2 got left/right mixed up... var actual = inputSimdL * inputSimdR; Asserts.AreEqual(expected, actual, "multiply"); }
public static Vector2 GetRotatedVector(Vector2 vector, float angle, bool clockwise) { if (clockwise) { angle *= -1; } Matrix2 rotationMatrix = Matrix2.CreateRotation(angle); float x = rotationMatrix.M11 * vector.X + rotationMatrix.M12 * vector.Y; float y = rotationMatrix.M21 * vector.X + rotationMatrix.M22 * vector.Y; return(new Vector2(x, y)); }
public static Matrix2 operator *(Matrix2 a, int b) { Matrix2 ret = new Matrix2(0); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { ret[i, j] = a[i, j] * b; } } return(ret); }
public static Matrix2 operator -(Matrix2 a) { Matrix2 ret = new Matrix2(0); for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { ret[i, j] = 0 - a[i, j]; } } return(ret); }
public static Matrix2 Inverse(this Matrix2 m) { float OneOverDeterminant = (1f) / ( +m[0][0] * m[1][1] - m[1][0] * m[0][1]); Matrix2 Inverse = new Matrix2( +m[1][1] * OneOverDeterminant, -m[0][1] * OneOverDeterminant, -m[1][0] * OneOverDeterminant, +m[0][0] * OneOverDeterminant); return(Inverse); }
public static void equality_typed() { var a = new Matrix2(_a); var b = new Matrix2(_b); var c = new Matrix2(_b); a.Equals(a).Should().BeTrue(); b.Equals(b).Should().BeTrue(); b.Equals(c).Should().BeTrue(); a.Equals(b).Should().BeFalse(); b.Equals(a).Should().BeFalse(); a.Equals(c).Should().BeFalse(); a.Equals(null).Should().BeFalse(); }
public void Construct2() { Matrix2<double> m = new Matrix2<double>( 1.0, 2.0, 3.0, 4.0); Assert.AreEqual(1.0, m.Column0Row0); Assert.AreEqual(2.0, m.Column1Row0); Assert.AreEqual(3.0, m.Column0Row1); Assert.AreEqual(4.0, m.Column1Row1); Assert.AreEqual(1.0, m.ReadOnlyColumnMajorValues[0]); Assert.AreEqual(3.0, m.ReadOnlyColumnMajorValues[1]); Assert.AreEqual(2.0, m.ReadOnlyColumnMajorValues[2]); Assert.AreEqual(4.0, m.ReadOnlyColumnMajorValues[3]); }
public void Equals() { Matrix2<double> a = new Matrix2<double>( 1.0, 2.0, 3.0, 4.0); Matrix2<double> b = new Matrix2<double>(0.0); Matrix2<double> c = new Matrix2<double>( 1.0, 2.0, 3.0, 4.0); Assert.IsTrue(a.Equals(c)); Assert.IsTrue(c.Equals(a)); Assert.IsTrue(a == c); Assert.IsTrue(c == a); Assert.IsFalse(c != a); Assert.IsFalse(c != a); Assert.IsFalse(a.Equals(b)); Assert.IsFalse(b.Equals(a)); Assert.IsFalse(a == b); Assert.IsFalse(b == a); Assert.IsTrue(a != b); Assert.IsTrue(b != a); object objA = a; object objB = b; object objC = c; Assert.IsTrue(a.Equals(objA)); Assert.IsTrue(a.Equals(objC)); Assert.IsFalse(a.Equals(objB)); Assert.IsTrue(objA.Equals(objC)); Assert.IsFalse(objA.Equals(objB)); Assert.IsFalse(a.Equals(null)); Assert.IsFalse(a.Equals(5)); }
public static void elements_set() { var m = new Matrix2(); m.Set(0, 0, 0); m.Set(0, 1, 1); m.Set(1, 0, 2); m.Set(1, 1, 3); m.Should().Be(_incremented); }
public static void constructor_element() { var m = new Matrix2(0, 1, 2, 3); m.Should().Be(_incremented); }
public static void element_field_set() { var m = new Matrix2(); m.E00 = 0; m.E01 = 1; m.E10 = 2; m.E11 = 3; m.Should().Be(_incremented); }
public static void add_assign_op() { var d = new Matrix2(_a); d += _b; d.Should().Be(_sum); }
public static void constructor_default() { var m = new Matrix2(); m.Should().Be(_identity); }
public static void transpose() { var a = new Matrix2(_incremented); a.Transpose(); a.Should().Be(_trans); }
public static void add_assign() { var d = new Matrix2(_a); d.AddAssign(_b); d.Should().Be(_sum); }
public static void equality_op() { var a = new Matrix2(_a); var a2 = a; var b = new Matrix2(_b); var b2 = b; var c = new Matrix2(_b); var d = (Matrix2)null; Assert.False(a == b); Assert.False(b == a); Assert.True(a == a2); Assert.True(b == b2); Assert.False(a == c); Assert.True(b == c); Assert.False(a == null); Assert.False(null == a); Assert.False(b == d); Assert.False(d == b); Assert.True(null == d); }
public static void multiply_assign() { var d = new Matrix2(_a); d.MultiplyAssign(_b); d.Should().Be(_product); }
public static void multiply_assign_op() { var d = new Matrix2(_a); d *= _b; d.Should().Be(_product); }
public static void determinants(double expectedDeterminant, Matrix2 m) { var determinant = m.CalculateDeterminant(); determinant.Should().Be(expectedDeterminant); }
public static void invert_basic() { var a = new Matrix2(_priorInvert); a.Invert(); a.Should().Be(_postInvert); }
public static void inverse_safety() { var a = new Matrix2(_priorInvert); var b = a.GetInverse(); a.Should().Be(_priorInvert, "Source matrix should not be mutated."); b.Should().Be(_postInvert); }
public static void elements_get() { var m = new Matrix2(_incremented); m.Get(0, 0).Should().Be(0); m.Get(0, 1).Should().Be(1); m.Get(1, 0).Should().Be(2); m.Get(1, 1).Should().Be(3); }
public static void inequality_op() { var a = new Matrix2(_a); var a2 = a; var b = new Matrix2(_b); var b2 = b; var c = new Matrix2(_b); var d = (Matrix2)null; Assert.True(a != b); Assert.True(b != a); Assert.False(a != a2); Assert.False(b != b2); Assert.True(a != c); Assert.False(b != c); Assert.True(a != null); Assert.True(null != a); Assert.True(b != d); Assert.True(d != b); Assert.False(null != d); }
public static void transposed_get() { var a = new Matrix2(_incremented); var b = a.GetTransposed(); a.Should().Be(_incremented, "Source matrix should not be mutated."); b.Should().Be(_trans); }
private static void Equal(Matrix2 a, Matrix2 b, int precision) { Assert.Equal(a.E00, b.E00, precision); Assert.Equal(a.E01, b.E01, precision); Assert.Equal(a.E10, b.E10, precision); Assert.Equal(a.E11, b.E11, precision); }
public static void UniformMatrix2(int location, bool transpose, ref Matrix2 matrix) { unsafe { fixed (float* matrix_ptr = &matrix.Row0.X) { GL.UniformMatrix2(location, 1, transpose, matrix_ptr); } } }
public static void multiply_op() { var a = new Matrix2(_a); var b = new Matrix2(_b); var product = a * b; product.Should().Be(_product); a.Should().Be(_a, "No argument mutation is allowed."); b.Should().Be(_b, "No argument mutation is allowed."); }