/// Tests that method
            /// <see cref="SingularValueDecomposition
            /// .GetSingularValues(ComplexMatrix)"/>,
            /// method has
            /// been properly implemented.
            public static void Succeed(
                TestableSingularValueDecomposition <TestableComplexMatrix, ComplexMatrix> testableSvd)
            {
                var testableMatrix = testableSvd.TestableMatrix;

                #region Writable

                // Dense
                {
                    var actualValues = SingularValueDecomposition.GetSingularValues(
                        testableMatrix.AsDense);

                    DoubleMatrixAssert.AreEqual(
                        expected: GetMainDiagonal(testableSvd.Values),
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                // Sparse
                {
                    var actualValues = SingularValueDecomposition.GetSingularValues(
                        testableMatrix.AsSparse);

                    DoubleMatrixAssert.AreEqual(
                        expected: GetMainDiagonal(testableSvd.Values),
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                #endregion

                #region ReadOnly

                // Dense
                {
                    var actualValues = SingularValueDecomposition.GetSingularValues(
                        testableMatrix.AsDense.AsReadOnly());

                    DoubleMatrixAssert.AreEqual(
                        expected: GetMainDiagonal(testableSvd.Values),
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                // Sparse
                {
                    var actualValues = SingularValueDecomposition.GetSingularValues(
                        testableMatrix.AsSparse.AsReadOnly());

                    DoubleMatrixAssert.AreEqual(
                        expected: GetMainDiagonal(testableSvd.Values),
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                #endregion
            }
            /// Tests that method
            /// <see cref="SingularValueDecomposition
            /// .Decompose(DoubleMatrix, out DoubleMatrix, out DoubleMatrix)"/>,
            /// has been properly implemented.
            public static void Succeed(
                TestableSingularValueDecomposition <TestableDoubleMatrix, DoubleMatrix> testableSvd)
            {
                var testableMatrix = testableSvd.TestableMatrix;

                #region Writable

                // Dense
                {
                    var actualValues = SingularValueDecomposition.Decompose(
                        testableMatrix.AsDense,
                        out DoubleMatrix actualLeftVectors,
                        out DoubleMatrix actualConjugateTransposedRightVectors);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .Values,
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .LeftVectors,
                        actual: actualLeftVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .ConjugateTransposedRightVectors,
                        actual: actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .TestableMatrix.AsDense,
                        actual: actualLeftVectors * actualValues
                        * actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                // Sparse
                {
                    var actualValues = SingularValueDecomposition.Decompose(
                        testableMatrix.AsSparse,
                        out DoubleMatrix actualLeftVectors,
                        out DoubleMatrix actualConjugateTransposedRightVectors);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .Values,
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .LeftVectors,
                        actual: actualLeftVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .ConjugateTransposedRightVectors,
                        actual: actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .TestableMatrix.AsDense,
                        actual: actualLeftVectors * actualValues
                        * actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                #endregion

                #region ReadOnly

                // Dense
                {
                    var actualValues = SingularValueDecomposition.Decompose(
                        testableMatrix.AsDense.AsReadOnly(),
                        out DoubleMatrix actualLeftVectors,
                        out DoubleMatrix actualConjugateTransposedRightVectors);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .Values,
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .LeftVectors,
                        actual: actualLeftVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .ConjugateTransposedRightVectors,
                        actual: actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .TestableMatrix.AsDense,
                        actual: actualLeftVectors * actualValues
                        * actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                // Sparse
                {
                    var actualValues = SingularValueDecomposition.Decompose(
                        testableMatrix.AsSparse.AsReadOnly(),
                        out DoubleMatrix actualLeftVectors,
                        out DoubleMatrix actualConjugateTransposedRightVectors);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .Values,
                        actual: actualValues,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .LeftVectors,
                        actual: actualLeftVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .ConjugateTransposedRightVectors,
                        actual: actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);

                    DoubleMatrixAssert.AreEqual(
                        expected: testableSvd
                        .TestableMatrix.AsDense,
                        actual: actualLeftVectors * actualValues
                        * actualConjugateTransposedRightVectors,
                        delta: SingularValueDecompositionTest.Accuracy);
                }

                #endregion
            }