public void MatrixNxNConstructor()
{
var matrix = new MatrixNxN <int>(10);
Assert.AreEqual(matrix.Rows, 10);
Assert.AreEqual(matrix.Columns, 10);
}
public void MatrixCramersRuleInvalidEquationResults()
{
var values = new int[, ]
{
{ 1, 2 },
{ 3, 4 }
};
var matrix = new MatrixNxN <int>(values).CramersRule(new List <int> {
1, 2, 3
});
}
public void MatrixDeterminant2x2()
{
var values = new int[, ]
{
{ 1, 2 },
{ 3, 4 }
};
var result = new MatrixNxN <int>(values).Determinant();
Assert.AreEqual(result, -2);
}
public void MatrixDeterminant3x3()
{
var values = new int[, ]
{
{ 1, 1, 2 },
{ 3, 5, 1 },
{ 2, 8, 6 }
};
var result = new MatrixNxN <int>(values).Determinant();
Assert.AreEqual(result, 34);
}
public void MatrixDeterminant4x4()
{
var values = new int[, ]
{
{ 1, 0, 1, 2 },
{ 3, 5, 7, 1 },
{ 2, 8, 4, 6 },
{ 1, -4, -3, 1 }
};
var result = new MatrixNxN <int>(values).Determinant();
Assert.AreEqual(result, 150);
}
public void MatrixNxNConstructorFromMatrix()
{
var values = new int[, ]
{
{ 1, 2 },
{ 3, 4 }
};
var matrix1 = new MatrixNxN <int>(values);
Assert.AreEqual(matrix1.Zip(Enumerable.Cast <int>(matrix1), (a, b) => a == b).Count(a => !a), 0);
var matrix2 = new MatrixNxN <int>(matrix1);
Assert.IsTrue(matrix2.Equals(matrix1));
}
public void MatrixCramersRuleValidResult()
{
var values = new double[, ]
{
{ 8, -1, -2 },
{ -1, 7, -1 },
{ -2, -1, 9 }
};
var result = new MatrixNxN <double>(values).CramersRule(new List <double> {
0, 10, 23
});
var expectedResult = new List <double> {
1, 2, 3
};
Assert.IsTrue(result.SequenceEqual(expectedResult, NumericUtilities.FloatNumberEqualityComparer <double>()));
}
public void MatrixInverse()
{
var values = new double[, ]
{
{ 1, 2 },
{ 3, 4 }
};
var expected = new double[, ]
{
{ -2, 1 },
{ 1.5, -0.5 }
};
var matrix = new MatrixNxN <double>(values).Inverse();
var expectedMatrix = new MatrixNxN <double>(expected);
Assert.IsTrue(matrix.Equals(expectedMatrix));
}
public void InitializeKernelMatrix(int size = -1)
{
kernel = new MatrixNxN((uint)3);
//for (uint y = 0; y < kernel.N; y++)
//{
// for (uint x = 0; x < kernel.N; x++)
// {
// kernel[x, y] = -1;
// }
//}
kernel[1, 0] = -1;
kernel[1, 2] = -1;
kernel[0, 1] = -1;
kernel[2, 1] = -1;
kernel[1, 1] = 5;
divisor = 1;
}
public MatrixNxN Inverse()
{
int n = Count1;
LudCmp Lud = new LudCmp(this);
MatrixNxN result = new MatrixNxN(n);
for (int j = 0; j < n; j++)
{
double[] vec = new double[n];
for (int i = 0; i < n; i++)
{
vec[i] = 0d;
}
vec[j] = 1d;
vec = Lud.LubKsb(vec);
for (int i = 0; i < n; i++)
{
result[i, j] = vec[i];
}
}
return(result);
}
public void MatrixDivision()
{
var values1 = new double[, ]
{
{ 1, 2, 3 },
{ 5, 6, 7 },
{ 0, 0, 0 }
};
var values2 = new double[, ]
{
{ -7, -9, 11 },
{ 10, -14, -5 },
{ 4, -10, 10 }
};
var expectedValues = new double[, ]
{
{ -281 / 963.0, -283 / 963.0, 913 / 1926.0 },
{ -989 / 963.0, -763 / 963.0, 2761 / 1926.0 },
{ 0, 0, 0 }
};
var result = new MatrixNxN <double>(values1) / new MatrixNxN <double>(values2);
Assert.IsTrue(result.SequenceEqual(Enumerable.Cast <double>(expectedValues), NumericUtilities.FloatNumberEqualityComparer <double>()));
}
public MatrixNxN MulMatrix(MatrixNxN Mat)
{
return(base.MulMatrix(Mat).ToMatrixNxN());
}
