| public SetColumn ( int passedColumnIndex, double passedColumn ) : void | ||
| passedColumnIndex | int | |
| passedColumn | double | |
| 리턴 | void | |
public void Matrix_IsSquareFalseTest()
{
Matrix matrix1 = new Matrix(3, 2);
double[] matrix1Column1 = { 2, 3, 1 };
double[] matrix1Column2 = { 4, 5, 1 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.IsSquare().Should().BeFalse();
}
/// <summary>
/// Takes values from a matrix and determines a cofactor by removing a certain row and column from the matrix.
/// Logic developed with help from Andrew Morton on stackoverflow:
/// http://stackoverflow.com/questions/24416946/next-step-in-calculating-a-matrix-determinant
/// </summary>
public Matrix GetSubMatrix(int[] indicesOfRowsToKeep, int[] indicesOfColumnsToKeep)
{
Matrix subMatrix = new Matrix(indicesOfRowsToKeep.Length, indicesOfColumnsToKeep.Length);
Matrix tempMatrix = new Matrix(indicesOfRowsToKeep.Length, this.NumberOfColumns);
int insertRowAt = 0;
foreach (int rowToKeep in indicesOfRowsToKeep)
{
tempMatrix.SetRow(insertRowAt, this.GetRow(rowToKeep));
insertRowAt++;
}
int insertColumnAt = 0;
foreach (int columnToKeep in indicesOfColumnsToKeep)
{
subMatrix.SetColumn(insertColumnAt, tempMatrix.GetColumn(columnToKeep));
insertColumnAt++;
}
return subMatrix;
}
public void Matrix_MinusOperatorTest()
{
Matrix matrix1 = new Matrix(2, 2);
Matrix matrix2 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 3 };
double[] matrix1Column2 = { 4, 5 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
double[] matrix2Column1 = { 1, 1 };
double[] matrix2Column2 = { 1, 1 };
matrix2.SetColumn(0, matrix2Column1);
matrix2.SetColumn(1, matrix2Column2);
Matrix expectedResult = new Matrix(2);
double[] expectedResultColumn1 = { 1, 2 };
double[] expectedResultColumn2 = { 3, 4 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
Matrix actualResult = matrix1 - matrix2;
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_ScalarMultiplyOperatorTest()
{
Matrix matrix1 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 3 };
double[] matrix1Column2 = { 4, 5 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
Matrix matrix2 = new Matrix(matrix1);
double multiplier = 3;
Matrix expectedResult = new Matrix(2,2);
double[] expectedResultColumn1 = { 6, 9 };
double[] expectedResultColumn2 = { 12, 15 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
Matrix actualResult1 = matrix1 * multiplier;
Matrix actualResult2 = multiplier * matrix2;
bool equalityResult = (actualResult1 == expectedResult && actualResult2 == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_DecomposeComplicatedTest()
{
Matrix matrixA = new Matrix(4, 4);
//Set up matrix A
double[] columnOneOfMatrixA = { 3, 1, 2, 5 };
double[] columnTwoOfMatrixA = { 7, 8, 1, 4 };
double[] columnThreeOfMatrixA = { 2, 4, 9, 7 };
double[] columnFourOfMatrixA = { 5, 2, 3, 1 };
matrixA.SetColumn(0, columnOneOfMatrixA);
matrixA.SetColumn(1, columnTwoOfMatrixA);
matrixA.SetColumn(2, columnThreeOfMatrixA);
matrixA.SetColumn(3, columnFourOfMatrixA);
//The LUP Decomposition
//Correct L Part
Matrix correctLPartOfLUPDecomposition = new Matrix(4, 4);
double[] columnOneOfLMatrix = { 1,0.2,0.4,0.6 };
double[] columnTwoOfLMatrix = { 0, 1, -0.083, 0.639 };
double[] columnThreeOfLMatrix = { 0, 0, 1, -0.602 };
double[] columnFourOfLMatrix = { 0,0,0,1 };
correctLPartOfLUPDecomposition.SetColumn(0, columnOneOfLMatrix);
correctLPartOfLUPDecomposition.SetColumn(1, columnTwoOfLMatrix);
correctLPartOfLUPDecomposition.SetColumn(2, columnThreeOfLMatrix);
correctLPartOfLUPDecomposition.SetColumn(3, columnFourOfLMatrix);
//Correct U Part
Matrix correctUPartOfLUPDecomposition = new Matrix(4, 4);
double[] columnOneOfUMatrix = { 5, 0,0,0 };
double[] columnTwoOfUMatrix = { 4, 7.2, 0,0 };
double[] columnThreeOfUMatrix = { 7, 2.6, 6.417, 0 };
double[] columnFourOfUMatrix = { 1, 1.8, 2.75, 4.905 };
correctUPartOfLUPDecomposition.SetColumn(0, columnOneOfUMatrix);
correctUPartOfLUPDecomposition.SetColumn(1, columnTwoOfUMatrix);
correctUPartOfLUPDecomposition.SetColumn(2, columnThreeOfUMatrix);
correctUPartOfLUPDecomposition.SetColumn(3, columnFourOfUMatrix);
//The other 2 output variables are a permutation array and the toggle value
int[] correctPermutationArray = { 3, 1, 2, 0 };
int correctToggleValue = -1;
//Calculate values for the above
int[] permutationArray;
int toggleValue;
Matrix decomposeResult = matrixA.Decompose(out permutationArray, out toggleValue);
Matrix calculatedLPartOfLUPDecomposition = decomposeResult.ExtractLower();
Matrix calculatedUPartOfLUPDecomposition = decomposeResult.ExtractUpper();
//Check all the variables
permutationArray.ShouldBeEquivalentTo(correctPermutationArray);
toggleValue.ShouldBeEquivalentTo(correctToggleValue);
//Compare the two matrices
double tolerance = .001;
Matrix LDifferenceMatrix = calculatedLPartOfLUPDecomposition - correctLPartOfLUPDecomposition;
Matrix UDifferenceMatrix = calculatedUPartOfLUPDecomposition - correctUPartOfLUPDecomposition;
for (int i = 0; i < LDifferenceMatrix.NumberOfRows; i++)
{
for (int j = 0; j < LDifferenceMatrix.NumberOfColumns; j++)
{
(Math.Abs(LDifferenceMatrix.GetElement(i, j)) < tolerance).Should().BeTrue();
}
}
for (int i = 0; i < UDifferenceMatrix.NumberOfRows; i++)
{
for (int j = 0; j < UDifferenceMatrix.NumberOfColumns; j++)
{
(Math.Abs(UDifferenceMatrix.GetElement(i, j)) < tolerance).Should().BeTrue();
}
}
}
public void Matrix_EqualsOperatorFalseTest()
{
Matrix matrix1 = new Matrix(2, 2);
Matrix matrix2 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 3 };
double[] matrix1Column2 = { 4, 5 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
double[] matrix2Column1 = { 2, 3 };
double[] matrix2Column2 = { 4, 1 };
matrix2.SetColumn(0, matrix2Column1);
matrix2.SetColumn(1, matrix2Column2);
bool result = (matrix1 == matrix2);
result.Should().BeFalse();
}
public void Matrix_GenerateCofactorMatrixTest()
{
Matrix matrix1 = new Matrix(3,3);
double[] matrix1Column1 = { 1, 5, 6 };
double[] matrix1Column2 = { 2, 4, 7 };
double[] matrix1Column3 = { 3, 6, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
Matrix expectedResult = new Matrix(3,3);
double[] expectedResultColumn1 = { -10, 5, 0 };
double[] expectedResultColumn2 = { -4, -10, 9};
double[] expectedResultColumn3 = { 11, 5, -6 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
expectedResult.SetColumn(2, expectedResultColumn3);
Matrix actualResult = matrix1.GenerateCofactorMatrix();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_GetColumnStandardTest()
{
Matrix testMatrix = new Matrix(3, 2);
double[] columnTwoOfTestMatrix = {7,8,9};
testMatrix.SetColumn(1, columnTwoOfTestMatrix);
testMatrix.GetColumn(1).ShouldBeEquivalentTo(columnTwoOfTestMatrix);
}
public void Matrix_IsInvertibleTrueTest()
{
Matrix matrix1 = new Matrix(2, 2);
double[] matrix1Column1 = { 1, 4 };
double[] matrix1Column2 = { 4, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.IsInvertible().Should().BeTrue();
}
public void Matrix_IsInvertibleFalseBecauseOfDeterminantTest()
{
Matrix matrix1 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 4 };
double[] matrix1Column2 = { 4, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.IsInvertible().Should().BeFalse();
}
public void Matrix_DeterminantIsZeroTest()
{
Matrix matrix1 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 4 };
double[] matrix1Column2 = { 4, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
double expectedResult = 0;
double actualResult = matrix1.Determinant();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_DeterminantStandardTest()
{
Matrix matrix1 = new Matrix(3, 3);
double[] matrix1Column1 = { 2, 4, 4 };
double[] matrix1Column2 = { 4, 5, 6 };
double[] matrix1Column3 = { 1, 2, 3 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
double expectedResult = -6;
double actualResult = matrix1.Determinant();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void MatricesMatrix_ConvertToMatrixTest_SingleColumn()
{
Matrix m1 = new Matrix(2, 1);
Matrix m2 = new Matrix(3, 1);
double[] m1Column1 = { 1, 1 };
double[] m2Column1 = { 2, 2, 2 };
m1.SetColumn(0, m1Column1);
m2.SetColumn(0, m2Column1);
MatricesMatrix testMatricesMatrix = new MatricesMatrix(2, 1);
testMatricesMatrix.SetElement(0, 0, m1);
testMatricesMatrix.SetElement(1, 0, m2);
Matrix expectedResult = new Matrix(5, 1);
double[] expectedColumn1 = { 1, 1, 2, 2, 2 };
expectedResult.SetColumn(0, expectedColumn1);
Matrix actualResult = testMatricesMatrix.ConvertToMatrix();
(actualResult == expectedResult).Should().BeTrue();
}
public void LUSolveTest()
{
double[,] a = {{4, 1, 1, 1}, {-1, 2, 1, 1}, {1, 1, 2, 2}, {1, 1, 2, 4}};
double[,] l, u;
Matrix.LUDecomp(a, out l, out u);
double[] b = {2.4, 1.4, 1.7, 25};
var x=Matrix.LUSolve(l, u, b);
var testResult=new Matrix(4,4);
testResult.SetColumn(0, a.GetColumn(0));
testResult.SetColumn(1, a.GetColumn(1));
testResult.SetColumn(2, a.GetColumn(2));
testResult.SetColumn(3, a.GetColumn(3));
var tX=new Matrix(x);
var tB=new Matrix(b);
(testResult.MultiplyBy(tX)==tB).Should().BeTrue();
}
public void Matrix_InvertTest()
{
Matrix matrix1 = new Matrix(3,3);
double[] matrix1Column1 = { 1, 5, 6 };
double[] matrix1Column2 = { 2, 4, 7 };
double[] matrix1Column3 = { 3, 6, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
Matrix expectedResult = new Matrix(3,3);
double[] expectedResultColumn1 = { (double)-2 / 3, (double)-4 / 15, (double)11 / 15 };
double[] expectedResultColumn2 = { (double)1 / 3, (double)-2 / 3, (double)1 / 3 };
double[] expectedResultColumn3 = { (double)0, (double)3 / 5, (double)-2 / 5 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
expectedResult.SetColumn(2, expectedResultColumn3);
Matrix actualResult = matrix1.Invert();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void PseudoInvSolveTest()
{
double[,] a = { { 0, 0 }, { 0,2 } };
double[,] P;
P=Matrix.GetPseudoInverse(a);
double[] b = { 0, 1 };
var x = Matrix.PseudoInvSolve(P, b);
var testResult = new Matrix(2, 2);
testResult.SetColumn(0, a.GetColumn(0));
testResult.SetColumn(1, a.GetColumn(1));
var tX = new Matrix(x);
var tB = new Matrix(b);
(testResult.MultiplyBy(tX) == tB).Should().BeTrue();
}
public void Matrix_MatrixTimesItsInverseTest()
{
Matrix matrix1 = new Matrix(4);
double[] matrix1Column1 = { 1, 5, 6, 7 };
double[] matrix1Column2 = { 2, 4, 7, 6 };
double[] matrix1Column3 = { 3, 6, 8, 7 };
double[] matrix1Column4 = { 7, 6, 8, 7 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
matrix1.SetColumn(3, matrix1Column4);
Matrix expectedResult = Matrix.IdentityMatrix(4);
Matrix actualResult = matrix1 * matrix1.Invert();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_SystemSolveStandardTest()
{
//Ax = b
Matrix matrixA = new Matrix(4, 4);
Matrix matrixB = new Matrix(4, 1);
//Set up matrix A
double[] columnOneOfMatrixA = { 3, 1, 2, 5 };
double[] columnTwoOfMatrixA = { 7, 8, 1, 4 };
double[] columnThreeOfMatrixA = { 2, 4, 9, 7 };
double[] columnFourOfMatrixA = { 5, 2, 3, 1 };
matrixA.SetColumn(0, columnOneOfMatrixA);
matrixA.SetColumn(1, columnTwoOfMatrixA);
matrixA.SetColumn(2, columnThreeOfMatrixA);
matrixA.SetColumn(3, columnFourOfMatrixA);
//Set up matrix b
double[] bColumn = { 49, 30, 43, 52 };
matrixB.SetColumn(0, bColumn);
//Solve for x
Matrix expectedResultMatrix = new Matrix(4, 1);
double[] expectedResult = { 6, 1, 2, 4 };
expectedResultMatrix.SetColumn(0, expectedResult);
Matrix actualResultMatrix = matrixA.SystemSolve(matrixB);
double tolerance = .001;
Matrix differenceMatrix = expectedResultMatrix - actualResultMatrix;
for (int i = 0; i < differenceMatrix.NumberOfRows; i++)
{
for (int j = 0; j < differenceMatrix.NumberOfColumns; j++)
{
(Math.Abs(differenceMatrix.GetElement(i, j)) < tolerance).Should().BeTrue();
}
}
}
public void Matrix_AbsoluteValueOfMatrixTest()
{
Matrix matrix1 = new Matrix(3,3);
double[] matrix1Column1 = { -1, 5, 6 };
double[] matrix1Column2 = { 2, -4, 7 };
double[] matrix1Column3 = { 3, 6, -8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
Matrix expectedResult = new Matrix(3,3);
double[] expectedResultColumn1 = { 1, 5, 6 };
double[] expectedResultColumn2 = { 2, 4, 7 };
double[] expectedResultColumn3 = { 3, 6, 8 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
expectedResult.SetColumn(2, expectedResultColumn3);
Matrix actualResult = matrix1.AbsoluteValue();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_ExtractUpperComplicatedTest()
{
Matrix matrixA = new Matrix(4, 4);
//Set up matrix A
double[] columnOneOfMatrixA = { 3, 1, 2, 5 };
double[] columnTwoOfMatrixA = { 7, 8, 1, 4 };
double[] columnThreeOfMatrixA = { 2, 4, 9, 7 };
double[] columnFourOfMatrixA = { 5, 2, 3, 1 };
matrixA.SetColumn(0, columnOneOfMatrixA);
matrixA.SetColumn(1, columnTwoOfMatrixA);
matrixA.SetColumn(2, columnThreeOfMatrixA);
matrixA.SetColumn(3, columnFourOfMatrixA);
//The LUP Decomposition
//Correct U Part
Matrix correctUPartOfLUPDecomposition = new Matrix(4, 4);
double[] columnOneOfUMatrix = { 3, 0, 0, 0 };
double[] columnTwoOfUMatrix = { 7, 8, 0, 0 };
double[] columnThreeOfUMatrix = { 2, 4, 9, 0 };
double[] columnFourOfUMatrix = { 5, 2, 3, 1 };
correctUPartOfLUPDecomposition.SetColumn(0, columnOneOfUMatrix);
correctUPartOfLUPDecomposition.SetColumn(1, columnTwoOfUMatrix);
correctUPartOfLUPDecomposition.SetColumn(2, columnThreeOfUMatrix);
correctUPartOfLUPDecomposition.SetColumn(3, columnFourOfUMatrix);
//Calculate U Part
Matrix calculatedUPartOfLUPDecomposition = matrixA.ExtractUpper();
(calculatedUPartOfLUPDecomposition == correctUPartOfLUPDecomposition).Should().BeTrue();
}
public void Matrix_CreateIdentityMatrixTest()
{
Matrix expectedResult = new Matrix(3,3);
double[] expectedResultColumn1 = { 1, 0, 0 };
double[] expectedResultColumn2 = { 0, 1, 0 };
double[] expectedResultColumn3 = { 0, 0, 1 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
expectedResult.SetColumn(2, expectedResultColumn3);
Matrix actualResult = Matrix.IdentityMatrix(3);
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_EqualsTest()
{
Matrix matrix1 = new Matrix(2, 2);
Matrix matrix2 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 3 };
double[] matrix1Column2 = { 4, 5 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
double[] matrix2Column1 = { 2, 3 };
double[] matrix2Column2 = { 4, 5 };
matrix2.SetColumn(0, matrix2Column1);
matrix2.SetColumn(1, matrix2Column2);
bool result = matrix1.Equals(matrix2);
result.Should().BeTrue();
}
public void Matrix_TransposeTest()
{
Matrix matrix1 = new Matrix(3,3);
double[] matrix1Column1 = { 1, 5, 6 };
double[] matrix1Column2 = { 2, 4, 7 };
double[] matrix1Column3 = { 3, 6, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
Matrix expectedResult = new Matrix(3,3);
double[] expectedResultColumn1 = { 1, 2, 3 };
double[] expectedResultColumn2 = { 5, 4, 6 };
double[] expectedResultColumn3 = { 6, 7, 8 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
expectedResult.SetColumn(2, expectedResultColumn3);
Matrix actualResult = matrix1.Transpose();
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_MultiplyOperatorTest()
{
Matrix matrix1 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 3 };
double[] matrix1Column2 = { 4, 5 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
Matrix matrix2 = new Matrix(2, 2);
double[] matrix2Column1 = { 1, 3 };
double[] matrix2Column2 = { 5, 7 };
matrix2.SetColumn(0, matrix2Column1);
matrix2.SetColumn(1, matrix2Column2);
Matrix expectedResult = new Matrix(2);
double[] expectedResultColumn1 = { 14, 18 };
double[] expectedResultColumn2 = { 38, 50 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
Matrix actualResult = matrix1 * matrix2;
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
public void Matrix_RotateAboutXTest()
{
Point pointToRotate = Point.MakePointWithInches(4, -2, 2);
Angle angleToRotate = new Angle(new Degree(), 199);
Matrix rotationMatrix = Matrix.RotationMatrixAboutX(angleToRotate);
Matrix actualResultMatrix = rotationMatrix * pointToRotate.ConvertToMatrixColumn();
double[] expectedResultColumn = { 4.0, 2.5421734601129469, -1.23990084228432 };
Matrix expectedResultMatrix = new Matrix(3, 1);
expectedResultMatrix.SetColumn(0, expectedResultColumn);
(actualResultMatrix == expectedResultMatrix).Should().BeTrue();
}
public void Matrix_IsSquareTrueTest()
{
Matrix matrix1 = new Matrix(2, 2);
double[] matrix1Column1 = { 2, 3 };
double[] matrix1Column2 = { 4, 5 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.IsSquare().Should().BeTrue();
}
public void Matrix_RotateAboutZTest()
{
Point pointToRotate = Point.MakePointWithInches(4, -2, 2);
Angle angleToRotate = new Angle(new Degree(), 199);
Matrix rotationMatrix = Matrix.RotationMatrixAboutZ(angleToRotate);
Matrix actualResultMatrix = rotationMatrix * pointToRotate.ConvertToMatrixColumn();
double[] expectedResultColumn = { -4.4332106113115808, 0.58876453337000645, 2.0 };
Matrix expectedResultMatrix = new Matrix(3, 1);
expectedResultMatrix.SetColumn(0, expectedResultColumn);
(actualResultMatrix == expectedResultMatrix).Should().BeTrue();
}
public void Matrix_GetSubMatrixStandardTest()
{
Matrix matrix1 = new Matrix(3,3);
double[] matrix1Column1 = { 1, 5, 6 };
double[] matrix1Column2 = { 2, 4, 7 };
double[] matrix1Column3 = { 3, 6, 8 };
matrix1.SetColumn(0, matrix1Column1);
matrix1.SetColumn(1, matrix1Column2);
matrix1.SetColumn(2, matrix1Column3);
Matrix expectedResult = new Matrix(2);
double[] expectedResultColumn1 = { 4, 7 };
double[] expectedResultColumn2 = { 6, 8 };
expectedResult.SetColumn(0, expectedResultColumn1);
expectedResult.SetColumn(1, expectedResultColumn2);
Matrix cofactor = new Matrix(2);
Matrix actualResult = matrix1.GetSubMatrix(0, 0);
bool equalityResult = (actualResult == expectedResult);
equalityResult.Should().BeTrue();
}
/// <summary>
/// Returns the rotation component of the shift object.
/// </summary>
public static Rotation RotationAboutOrigin(Shift shift)
{
var copy = new Matrix(shift.Matrix);
copy.SetColumn(3, new double[] { 0, 0, 0, 1 });
return new Rotation(copy);
}
