public void solve_for_diagonal()
{
float[][] value = // not positive-definite
{
new float[] { 6, -1, 2, 6 },
new float[] { -1, 3, -3, -2 },
new float[] { 2, -3, 2, 0 },
new float[] { 6, -2, 0, 0 },
};
var chol = new JaggedCholeskyDecompositionF(value, robust: true);
float[][] L = chol.LeftTriangularFactor;
float[] B = new float[] { 1, 2, 3, 4 };
float[][] expected =
{
new float[] { 0.4f, 2.4f, 4.2f, -2 },
new float[] { 1.2f, 7.2f, 12.6f, -8 },
new float[] { 1.4f, 8.4f, 16.2f, -10 },
new float[] { -0.5f, -4.0f, -7.5f, 4 }
};
float[][] actual = chol.SolveForDiagonal(B);
Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-4f));
float[][] reverse = chol.Reverse();
Assert.IsTrue(Matrix.IsEqual(value, reverse, atol: 1e-3f));
}
public void CholeskyDecompositionConstructorTest4()
{
// Based on tests by Ken Johnson
float[][] value = // positive-definite
{
new float[] { 2f, 0f, 0f },
new float[] { -1f, 2f, 0f },
new float[] { 0f, -1f, 2f }
};
float[][] expected =
{
new float[] { 1.4142f, 0.0000f, 0.0000f },
new float[] { -0.7071f, 1.2247f, 0.0000f },
new float[] { 0.0000f, -0.8165f, 1.1547f }
};
var chol = new JaggedCholeskyDecompositionF(value, robust: false, valueType: MatrixType.LowerTriangular);
float[][] L = chol.LeftTriangularFactor;
Assert.IsTrue(Matrix.IsEqual(L, expected, 0.0001f));
Assert.AreEqual(4, chol.Determinant, 1e-6);
Assert.IsTrue(chol.IsPositiveDefinite);
var reverse = chol.Reverse();
Assert.IsTrue(Matrix.IsEqual(reverse, value.GetSymmetric(MatrixType.LowerTriangular), 1e-6f));
float[][] expected2 =
{
new float[] { 1.0f, 0.0f, 0.0f },
new float[] { -0.5f, 1.0f, 0.0f },
new float[] { 0.0f, -0.6666667f, 1.0f }
};
chol = new JaggedCholeskyDecompositionF(value, robust: true, valueType: MatrixType.LowerTriangular);
L = chol.LeftTriangularFactor;
Assert.IsTrue(Matrix.IsEqual(L, expected2, 0.0001f));
Assert.AreEqual(4, chol.Determinant, 1e-6);
Assert.IsTrue(chol.IsPositiveDefinite);
reverse = chol.Reverse();
Assert.IsTrue(Matrix.IsEqual(reverse, value.GetSymmetric(MatrixType.LowerTriangular), 1e-6f));
}
public void CholeskyDecompositionConstructorTest3()
{
float[][] value = // not positive-definite
{
new float[] { 6, -1, 2, 6 },
new float[] { -1, 3, -3, -2 },
new float[] { 2, -3, 2, 0 },
new float[] { 6, -2, 0, 0 },
};
float[][] expected =
{
new float[] { 1.0000f, 0f, 0f, 0f },
new float[] { -0.1667f, 1.0000f, 0f, 0f },
new float[] { 0.3333f, -0.9412f, 1.0000f, 0f },
new float[] { 1.0000f, -0.3529f, 2.5000f, 1.0000f },
};
float[][] diagonal =
{
new float[] { 6.0000f, 0f, 0f, 0f },
new float[] { 0f, 2.8333f, 0f, 0f },
new float[] { 0f, 0f, -1.1765f, 0f },
new float[] { 0f, 0f, 0f, 1.0000f },
};
var chol = new JaggedCholeskyDecompositionF(value, robust: true);
float[][] L = chol.LeftTriangularFactor;
float[][] D = chol.DiagonalMatrix;
Assert.IsTrue(Matrix.IsEqual(L, expected, 1e-3f));
Assert.IsTrue(Matrix.IsEqual(D, diagonal, 1e-3f));
// Decomposition Identity
Assert.IsTrue(Matrix.IsEqual(Matrix.Multiply(Matrix.Multiply(L, D), L.Transpose()), value, 1e-3f));
Assert.IsTrue(Matrix.IsEqual(chol.Reverse(), value, 1e-3f));
Assert.AreEqual(new JaggedLuDecompositionF(value).Determinant, chol.Determinant, 1e-4f);
Assert.IsFalse(chol.IsPositiveDefinite);
}
public void CholeskyDecompositionFConstructorTest2()
{
float[][] value = // positive-definite
{
new float[] { 2, -1, 0 },
new float[] { -1, 2, -1 },
new float[] { 0, -1, 2 }
};
float[][] expected =
{
new float[] { 1.0000f, 0.0000f, 0.0000f },
new float[] { -0.5000f, 1.0000f, 0.0000f },
new float[] { 0.0000f, -0.6667f, 1.0000f }
};
float[][] diagonal =
{
new float[] { 2.0000f, 0.0000f, 0.0000f },
new float[] { 0.0000f, 1.5000f, 0.0000f },
new float[] { 0.0000f, 0.0000f, 1.3333f },
};
var chol = new JaggedCholeskyDecompositionF(value, true);
float[][] L = chol.LeftTriangularFactor;
float[][] D = chol.DiagonalMatrix;
Assert.IsTrue(Matrix.IsEqual(L, expected, 0.001f));
Assert.IsTrue(Matrix.IsEqual(D, diagonal, 0.001f));
// Decomposition Identity
Assert.IsTrue(Matrix.IsEqual(Matrix.Multiply(Matrix.Multiply(L, D), L.Transpose()), value, 1e-3f));
Assert.IsTrue(Matrix.IsEqual(chol.Reverse(), value, 1e-3f));
Assert.AreEqual(new JaggedLuDecompositionF(value).Determinant, chol.Determinant, 1e-10);
Assert.IsTrue(chol.IsPositiveDefinite);
}
public void CholeskyDecompositionConstructorTest4()
{
// Based on tests by Ken Johnson
float[][] value = // positive-definite
{
new float[] { 2f, 0f, 0f },
new float[] { -1f, 2f, 0f },
new float[] { 0f, -1f, 2f }
};
float[][] expected =
{
new float[] { 1.4142f, 0.0000f, 0.0000f },
new float[] { -0.7071f, 1.2247f, 0.0000f },
new float[] { 0.0000f, -0.8165f, 1.1547f }
};
var chol = new JaggedCholeskyDecompositionF(value, robust: false, valueType: MatrixType.LowerTriangular);
float[][] L = chol.LeftTriangularFactor;
Assert.IsTrue(Matrix.IsEqual(L, expected, 0.0001f));
Assert.AreEqual(4, chol.Determinant, 1e-6);
Assert.IsTrue(chol.IsPositiveDefinite);
var reverse = chol.Reverse();
Assert.IsTrue(Matrix.IsEqual(reverse, value.GetSymmetric(MatrixType.LowerTriangular), 1e-6f));
float[][] expected2 =
{
new float[] { 1.0f, 0.0f, 0.0f },
new float[] { -0.5f, 1.0f, 0.0f },
new float[] { 0.0f, -0.6666667f, 1.0f }
};
chol = new JaggedCholeskyDecompositionF(value, robust: true, valueType: MatrixType.LowerTriangular);
L = chol.LeftTriangularFactor;
Assert.IsTrue(Matrix.IsEqual(L, expected2, 0.0001f));
Assert.AreEqual(4, chol.Determinant, 1e-6);
Assert.IsTrue(chol.IsPositiveDefinite);
reverse = chol.Reverse();
Assert.IsTrue(Matrix.IsEqual(reverse, value.GetSymmetric(MatrixType.LowerTriangular), 1e-6f));
}
public void CholeskyDecompositionConstructorTest3()
{
float[][] value = // not positive-definite
{
new float[] { 6, -1, 2, 6 },
new float[] { -1, 3, -3, -2 },
new float[] { 2, -3, 2, 0 },
new float[] { 6, -2, 0, 0 },
};
float[][] expected =
{
new float[] { 1.0000f, 0f, 0f, 0f },
new float[] { -0.1667f, 1.0000f, 0f, 0f },
new float[] { 0.3333f, -0.9412f, 1.0000f, 0f },
new float[] { 1.0000f, -0.3529f, 2.5000f, 1.0000f },
};
float[][] diagonal =
{
new float[] { 6.0000f, 0f, 0f, 0f },
new float[] { 0f, 2.8333f, 0f, 0f },
new float[] { 0f, 0f, -1.1765f, 0f },
new float[] { 0f, 0f, 0f, 1.0000f },
};
var chol = new JaggedCholeskyDecompositionF(value, robust: true);
float[][] L = chol.LeftTriangularFactor;
float[][] D = chol.DiagonalMatrix;
Assert.IsTrue(Matrix.IsEqual(L, expected, 1e-3f));
Assert.IsTrue(Matrix.IsEqual(D, diagonal, 1e-3f));
// Decomposition Identity
Assert.IsTrue(Matrix.IsEqual(Matrix.Multiply(Matrix.Multiply(L, D), L.Transpose()), value, 1e-3f));
Assert.IsTrue(Matrix.IsEqual(chol.Reverse(), value, 1e-3f));
Assert.AreEqual(new JaggedLuDecompositionF(value).Determinant, chol.Determinant, 1e-4f);
Assert.IsFalse(chol.IsPositiveDefinite);
}
public void CholeskyDecompositionFConstructorTest2()
{
float[][] value = // positive-definite
{
new float[] { 2, -1, 0 },
new float[] { -1, 2, -1 },
new float[] { 0, -1, 2 }
};
float[][] expected =
{
new float[] { 1.0000f, 0.0000f, 0.0000f },
new float[] { -0.5000f, 1.0000f, 0.0000f },
new float[] { 0.0000f, -0.6667f, 1.0000f }
};
float[][] diagonal =
{
new float[] { 2.0000f, 0.0000f, 0.0000f },
new float[] { 0.0000f, 1.5000f, 0.0000f },
new float[] { 0.0000f, 0.0000f, 1.3333f },
};
var chol = new JaggedCholeskyDecompositionF(value, true);
float[][] L = chol.LeftTriangularFactor;
float[][] D = chol.DiagonalMatrix;
Assert.IsTrue(Matrix.IsEqual(L, expected, 0.001f));
Assert.IsTrue(Matrix.IsEqual(D, diagonal, 0.001f));
// Decomposition Identity
Assert.IsTrue(Matrix.IsEqual(Matrix.Multiply(Matrix.Multiply(L, D), L.Transpose()), value, 1e-3f));
Assert.IsTrue(Matrix.IsEqual(chol.Reverse(), value, 1e-3f));
Assert.AreEqual(new JaggedLuDecompositionF(value).Determinant, chol.Determinant, 1e-10);
Assert.IsTrue(chol.IsPositiveDefinite);
}
