public void PuttingItTogether() { var a = new RTF.Matrix(4, 4); a.SetRow(0, new double[] { 3, -9, 7, 3 }); a.SetRow(1, new double[] { 3, -8, 2, -9 }); a.SetRow(2, new double[] { -4, 4, 4, 1 }); a.SetRow(3, new double[] { -6, 5, -1, 1 }); var identity = RTF.Matrix.GetIdentity(4, 4); Assert.Equal(identity, identity.Inverse()); var idInverted = a * a.Inverse(); CustomAssert.Equal(identity, idInverted, 0); var transposeInvert = a.Transpose().Inverse(); var invertTranspose = a.Inverse().Transpose(); CustomAssert.Equal(transposeInvert, invertTranspose, 5); var modifiedIdentity = RTF.Matrix.GetIdentity(4, 4); modifiedIdentity[2, 2] = 6; var tuple = new double[] { 1, 2, 3, 4 }; var tupleIdentity = identity * tuple; var newTuple = modifiedIdentity * tuple; Assert.Equal(tuple, tupleIdentity); Assert.NotEqual(tuple, newTuple); }
public void Determinant2x2() { var b = new RTF.Matrix(2, 2); b.SetRow(0, new double[] { 1, 5 }); b.SetRow(1, new double[] { -3, 2 }); Assert.Equal(17, b.Determinant()); }
public void InvertibleMatrix() { var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { 6, 4, 4, 4 }); e.SetRow(1, new double[] { 5, 5, 7, 6 }); e.SetRow(2, new double[] { 4, -9, 3, -7 }); e.SetRow(3, new double[] { 9, 1, 7, -6 }); Assert.True(e.IsInvertible()); }
public void NonInvertibleMatrix() { var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { -4, 2, -2, -3 }); e.SetRow(1, new double[] { 9, 6, 2, 6 }); e.SetRow(2, new double[] { 0, -5, 1, -5 }); e.SetRow(3, new double[] { 0, 0, 0, 0 }); Assert.False(e.IsInvertible()); }
public void OughtTo3x3() { var M = new RTF.Matrix(3, 3); M.SetRow(0, new double[] { -3, 5, 0 }); M.SetRow(1, new double[] { 1, -2, 7 }); M.SetRow(2, new double[] { 0, 1, 1 }); Assert.Equal(-3, M[0, 0]); Assert.Equal(-2, M[1, 1]); Assert.Equal(1, M[2, 2]); }
public void Determinant3x3() { var e = new RTF.Matrix(3, 3); e.SetRow(0, new double[] { 1, 2, 6 }); e.SetRow(1, new double[] { -5, 8, -4 }); e.SetRow(2, new double[] { 2, 6, 4 }); Assert.Equal(56, RTF.Matrix.Cofactor(e, 0, 0)); Assert.Equal(12, RTF.Matrix.Cofactor(e, 0, 1)); Assert.Equal(-46, RTF.Matrix.Cofactor(e, 0, 2)); Assert.Equal(-196, RTF.Matrix.Determinant(e)); }
public void Cofactor3x3() { var e = new RTF.Matrix(3, 3); e.SetRow(0, new double[] { 3, 5, 0 }); e.SetRow(1, new double[] { 2, -1, -7 }); e.SetRow(2, new double[] { 6, -1, 5 }); Assert.Equal(-12, RTF.Matrix.Minor(e, 0, 0)); Assert.Equal(-12, RTF.Matrix.Cofactor(e, 0, 0)); Assert.Equal(25, RTF.Matrix.Minor(e, 1, 0)); Assert.Equal(-25, RTF.Matrix.Cofactor(e, 1, 0)); }
public void Minor3x3() { var e = new RTF.Matrix(3, 3); e.SetRow(0, new double[] { 3, 5, 0 }); e.SetRow(1, new double[] { 2, -1, -7 }); e.SetRow(2, new double[] { 6, -1, 5 }); var b = RTF.Matrix.Submatrix(e, 1, 0); Assert.Equal(25, b.Determinant()); Assert.Equal(25, RTF.Matrix.Minor(e, 1, 0)); }
public void MultiplyingIdentityByMatrice() { var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { 0, 1, 2, 4 }); e.SetRow(1, new double[] { 1, 2, 4, 8 }); e.SetRow(2, new double[] { 2, 4, 8, 16 }); e.SetRow(3, new double[] { 4, 8, 16, 32 }); var M = RTF.Matrix.GetIdentity(4, 4) * e; Assert.Equal(e, M); }
public void GetIdentity() { var a = new RTF.Matrix(4, 4); a.SetRow(0, new double[] { 1, 0, 0, 0 }); a.SetRow(1, new double[] { 0, 1, 0, 0 }); a.SetRow(2, new double[] { 0, 0, 1, 0 }); a.SetRow(3, new double[] { 0, 0, 0, 1 }); var M = RTF.Matrix.GetIdentity(4, 4); Assert.Equal(a, M); }
public void EqualityTrueSmall() { var M1 = new RTF.Matrix(2, 2); M1.SetRow(0, new double[] { 0, 0 }); M1.SetRow(1, new double[] { 1, 1 }); var M2 = new RTF.Matrix(2, 2); M2.SetRow(0, new double[] { 0, 0 }); M2.SetRow(1, new double[] { 1, 1 }); Assert.True(M1 == M2); }
public void Submatrix3x3in2x2() { var b = new RTF.Matrix(3, 3); b.SetRow(0, new double[] { 1, 5, 0 }); b.SetRow(1, new double[] { -3, 2, 7 }); b.SetRow(2, new double[] { 0, 6, -3 }); var e = new RTF.Matrix(2, 2); e.SetRow(0, new double[] { -3, 2 }); e.SetRow(1, new double[] { 0, 6 }); Assert.Equal(e, RTF.Matrix.Submatrix(b, 0, 2)); }
public void Determinant4x4() { var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { -2, -8, 3, 5 }); e.SetRow(1, new double[] { -3, 1, 7, 3 }); e.SetRow(2, new double[] { 1, 2, -9, 6 }); e.SetRow(3, new double[] { -6, 7, 7, -9 }); Assert.Equal(690, RTF.Matrix.Cofactor(e, 0, 0)); Assert.Equal(447, RTF.Matrix.Cofactor(e, 0, 1)); Assert.Equal(210, RTF.Matrix.Cofactor(e, 0, 2)); Assert.Equal(51, RTF.Matrix.Cofactor(e, 0, 3)); Assert.Equal(-4071, e.Determinant()); }
public void MultiplyTuple() { var a = new RTF.Matrix(4, 4); a.SetRow(0, new double[] { 1, 2, 3, 4 }); a.SetRow(1, new double[] { 2, 4, 4, 2 }); a.SetRow(2, new double[] { 8, 6, 4, 1 }); a.SetRow(3, new double[] { 0, 0, 0, 1 }); double[] b = { 1, 2, 3, 1 }; double[] e = { 18, 24, 33, 1 }; var M = a * b; Assert.Equal(e, M); }
public void ArbitraryTransformation() { var from = RTF.PointType.Point(1, 3, 2); var to = RTF.PointType.Point(4, -2, 8); var up = RTF.PointType.Vector(1, 1, 0); RTF.Matrix t = RTH.Transformations.ViewTransform(from, to, up); var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { -0.50709, 0.50709, 0.67612, -2.36643 }); e.SetRow(1, new double[] { 0.76772, 0.60609, 0.12122, -2.82843 }); e.SetRow(2, new double[] { -0.35857, 0.59761, -0.71714, 0 }); e.SetRow(3, new double[] { 0, 0, 0, 1 }); CustomAssert.Equal(e, t, 5); }
public void Submatrix4x4in3x3() { var b = new RTF.Matrix(4, 4); b.SetRow(0, new double[] { -6, 1, 1, 6 }); b.SetRow(1, new double[] { -8, 5, 8, 6, }); b.SetRow(2, new double[] { -1, 0, 8, 2 }); b.SetRow(3, new double[] { -7, 1, -1, 1 }); var e = new RTF.Matrix(3, 3); e.SetRow(0, new double[] { -6, 1, 6 }); e.SetRow(1, new double[] { -8, 8, 6 }); e.SetRow(2, new double[] { -7, -1, 1 }); Assert.Equal(e, RTF.Matrix.Submatrix(b, 2, 1)); }
public void ConstructAndInspectMatrice4x4() { var M = new RTF.Matrix(4, 4); M.SetRow(0, new double[] { 1, 2, 3, 4 }); M.SetRow(1, new double[] { 5.5, 6.5, 7.5, 8.5 }); M.SetRow(2, new double[] { 9, 10, 11, 12 }); M.SetRow(3, new double[] { 13.5, 14.5, 15.5, 16.5 }); Assert.Equal(1, M[0, 0]); Assert.Equal(4, M[0, 3]); Assert.Equal(5.5, M[1, 0]); Assert.Equal(7.5, M[1, 2]); Assert.Equal(11, M[2, 2]); Assert.Equal(13.5, M[3, 0]); Assert.Equal(15.5, M[3, 2]); }
public void EqualityFalse() { var M1 = new RTF.Matrix(4, 4); M1.SetRow(0, new double[] { 1, 2, 3, 4 }); M1.SetRow(1, new double[] { 5, 6, 7, 8 }); M1.SetRow(2, new double[] { 9, 8, 7, 6 }); M1.SetRow(3, new double[] { 5, 4, 3, 2 }); var M2 = new RTF.Matrix(4, 4); M2.SetRow(0, new double[] { 2, 3, 4, 5 }); M2.SetRow(1, new double[] { 6, 7, 8, 9 }); M2.SetRow(2, new double[] { 8, 7, 6, 5 }); M2.SetRow(3, new double[] { 4, 3, 2, 1 }); Assert.False(M1 == M2); }
public void TestTranspose() { var b = new RTF.Matrix(4, 4); b.SetRow(0, new double[] { 0, 9, 3, 0 }); b.SetRow(1, new double[] { 9, 8, 0, 8 }); b.SetRow(2, new double[] { 1, 8, 5, 3 }); b.SetRow(3, new double[] { 0, 0, 5, 8 }); var e = new RTF.Matrix(4, 4); e.SetColumn(0, new double[] { 0, 9, 3, 0 }); e.SetColumn(1, new double[] { 9, 8, 0, 8 }); e.SetColumn(2, new double[] { 1, 8, 5, 3 }); e.SetColumn(3, new double[] { 0, 0, 5, 8 }); Assert.Equal(e, b.Transpose()); }
public void EqualityTrue() { var M1 = new RTF.Matrix(4, 4); M1.SetRow(0, new double[] { 1, 2, 3, 4 }); M1.SetRow(1, new double[] { 5, 6, 7, 8 }); M1.SetRow(2, new double[] { 9, 8, 7, 6 }); M1.SetRow(3, new double[] { 5, 4, 3, 2 }); var M2 = new RTF.Matrix(4, 4); M2.SetRow(0, new double[] { 1, 2, 3, 4 }); M2.SetRow(1, new double[] { 5, 6, 7, 8 }); M2.SetRow(2, new double[] { 9, 8, 7, 6 }); M2.SetRow(3, new double[] { 5, 4, 3, 2 }); Assert.True(M1 == M2); }
public void Inverse() { var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { -5, 2, 6, -8 }); e.SetRow(1, new double[] { 1, -5, 1, 8 }); e.SetRow(2, new double[] { 7, 7, -6, -7 }); e.SetRow(3, new double[] { 1, -3, 7, 4 }); double r1 = -160d / 532; double r2 = 105d / 532; var b = e.Inverse(); Assert.Equal(532, e.Determinant()); Assert.Equal(-160, RTF.Matrix.Cofactor(e, 2, 3)); Assert.Equal(r1, b[3, 2]); Assert.Equal(105, RTF.Matrix.Cofactor(e, 3, 2)); Assert.Equal(r2, b[2, 3]); }
public void Multiply() { var M1 = new RTF.Matrix(4, 4); M1.SetRow(0, new double[] { 1, 2, 3, 4 }); M1.SetRow(1, new double[] { 2, 3, 4, 5 }); M1.SetRow(2, new double[] { 3, 4, 5, 6 }); M1.SetRow(3, new double[] { 4, 5, 6, 7 }); var M2 = new RTF.Matrix(4, 4); M2.SetRow(0, new double[] { 0, 1, 2, 4 }); M2.SetRow(1, new double[] { 1, 2, 4, 8 }); M2.SetRow(2, new double[] { 2, 4, 8, 16 }); M2.SetRow(3, new double[] { 4, 8, 16, 32 }); var M = M1 * M2; Assert.Equal(31, M[1, 0]); }
public void Inverse3() { var a = new RTF.Matrix(4, 4); a.SetRow(0, new double[] { 9, 3, 0, 9 }); a.SetRow(1, new double[] { -5, -2, -6, -3 }); a.SetRow(2, new double[] { -4, 9, 6, 4 }); a.SetRow(3, new double[] { -7, 6, 6, 2 }); var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { -0.04074, -0.07778, 0.14444, -0.22222 }); e.SetRow(1, new double[] { -0.07778, 0.03333, 0.36667, -0.33333 }); e.SetRow(2, new double[] { -0.02901, -0.14630, -0.10926, 0.12963 }); e.SetRow(3, new double[] { 0.17778, 0.06667, -0.26667, 0.33333 }); var inverse = a.Inverse(); CustomAssert.Equal(e, inverse, 5); }
public void Inverse2() { var a = new RTF.Matrix(4, 4); a.SetRow(0, new double[] { 8, -5, 9, 2 }); a.SetRow(1, new double[] { 7, 5, 6, 1 }); a.SetRow(2, new double[] { -6, 0, 9, 6 }); a.SetRow(3, new double[] { -3, 0, -9, -4 }); var e = new RTF.Matrix(4, 4); e.SetRow(0, new double[] { -0.15385, -0.15385, -0.28205, -0.53846 }); e.SetRow(1, new double[] { -0.07692, 0.12308, 0.02564, 0.03077 }); e.SetRow(2, new double[] { 0.35897, 0.35897, 0.43590, 0.92308 }); e.SetRow(3, new double[] { -0.69231, -0.69231, -0.76923, -1.92308 }); var inverse = a.Inverse(); CustomAssert.Equal(e, inverse, 5); }
public void MultiplyingProductByInverse() { var a = new RTF.Matrix(4, 4); a.SetRow(0, new double[] { 3, -9, 7, 3 }); a.SetRow(1, new double[] { 3, -8, 2, -9 }); a.SetRow(2, new double[] { -4, 4, 4, 1 }); a.SetRow(3, new double[] { -6, 5, -1, 1 }); var b = new RTF.Matrix(4, 4); b.SetRow(0, new double[] { 8, 2, 2, 2 }); b.SetRow(1, new double[] { 3, -1, 7, 0 }); b.SetRow(2, new double[] { 7, 0, 5, 4 }); b.SetRow(3, new double[] { 6, -2, 0, 5 }); var c = a * b; var e = c * b.Inverse(); CustomAssert.Equal(e, a, 0); }