/// <summary>
        /// Asserts that the specified objects are equal.
        /// </summary>
        /// <param name="expected">The expected array.</param>
        /// <param name="actual">The actual array.</param>
        /// <param name="delta">The required accuracy.</param>
        /// <exception cref="AssertFailedException">
        /// One array is null, the other is not.</br>
        /// -or-</br>
        /// The arrays have not the same length.</br>
        /// -or-</br>
        /// A value is unexpected at a given position.
        /// </exception>
        public static void AreEqual(
            Complex[] expected, Complex[] actual, double delta)
        {
            if (null == expected && null == actual)
            {
                return;
            }

            if (((null == expected) && (null != actual)) || ((null != expected) && (null == actual)))
            {
                throw new AssertFailedException("One array is null, the other is not.");
            }

            int expectedLength = expected.Length;
            int actualLength   = actual.Length;

            if (expectedLength != actualLength)
            {
                throw new AssertFailedException("The arrays have not the same length.");
            }

            for (int l = 0; l < expectedLength; l++)
            {
                ComplexAssert.AreEqual(expected[l], actual[l], delta);
            }
        }
        /// <summary>
        /// Determines whether the specified matrix has the expected state.
        /// </summary>
        /// <param name="expectedState">The expected state.</param>
        /// <param name="actualMatrix">The actual matrix.</param>
        /// <param name="delta">The required precision.</param>
        public static void IsStateAsExpected(
            ComplexMatrixState expectedState,
            ComplexMatrix actualMatrix,
            double delta)
        {
            // Null reference ?

            Assert.IsNotNull(actualMatrix);

            // Matrix Fields

            object implementor = Reflector.GetField(
                actualMatrix,
                "implementor");

            Assert.IsNotNull(implementor);

            Complex[] actualColumnMajorOrderedEntries;

            actualColumnMajorOrderedEntries =
                (Complex[])Reflector.ExecuteMember(
                    implementor,
                    "AsColumnMajorDenseArray",
                    null);

            Assert.IsNotNull(actualColumnMajorOrderedEntries);

            var expectedColumnMajorOrderedEntries = expectedState.AsColumnMajorDenseArray;

            Assert.AreEqual(
                expectedColumnMajorOrderedEntries.Length,
                actualColumnMajorOrderedEntries.Length);

            for (int Id = 0; Id < actualColumnMajorOrderedEntries.Length; Id++)
            {
                ComplexAssert.AreEqual(
                    expectedColumnMajorOrderedEntries[Id],
                    actualColumnMajorOrderedEntries[Id],
                    delta);
            }

            int actualNumberOfRows = (int)Reflector.GetProperty(
                implementor,
                "NumberOfRows");

            int expectedNumberOfRows = expectedState.NumberOfRows;

            Assert.AreEqual(expectedNumberOfRows, actualNumberOfRows);

            int actualNumberOfColumns = (int)Reflector.GetProperty(
                implementor,
                "NumberOfColumns");

            int expectedNumberOfColumns = expectedState.NumberOfColumns;

            Assert.AreEqual(expectedNumberOfColumns, actualNumberOfColumns);

            // Matrix Names

            // Matrix name

            Assert.AreEqual(expectedState.Name, actualMatrix.Name);

            // Row names

            // Both have row names
            bool expectedHasRowNames = expectedState.RowNames is not null;

            Assert.AreEqual(expectedHasRowNames, actualMatrix.HasRowNames);

            if (expectedHasRowNames)
            {
                CompareDimensionNames("row", expectedState.RowNames, actualMatrix.RowNames);
            }

            // Column names

            // Both have column names
            bool expectedHasColumnNames = expectedState.ColumnNames is not null;

            Assert.AreEqual(expectedHasColumnNames, actualMatrix.HasColumnNames);

            if (expectedHasColumnNames)
            {
                CompareDimensionNames("column", expectedState.ColumnNames, actualMatrix.ColumnNames);
            }
        }
        /// <summary>
        /// Checks that the specified <see cref="ComplexMatrix"/>
        /// instances are equal.
        /// </summary>
        /// <param name="expected">The expected matrix.</param>
        /// <param name="actual">The actual matrix.</param>
        /// <param name="delta">The required accuracy.</param>
        public static void AreEqual(
            ComplexMatrix expected,
            ComplexMatrix actual,
            double delta)
        {
            // Null references ?

            Assert.IsNotNull(expected);
            Assert.IsNotNull(actual);

            // Matrix Fields

            object expectedImplementor = Reflector.GetField(
                expected,
                "implementor");

            Assert.IsNotNull(expectedImplementor);

            var expectedColumnMajorOrderedEntries =
                (Complex[])Reflector.ExecuteMember(
                    expectedImplementor,
                    "AsColumnMajorDenseArray",
                    null);

            Assert.IsNotNull(expectedColumnMajorOrderedEntries);

            object actualImplementor = Reflector.GetField(
                actual,
                "implementor");

            Assert.IsNotNull(actualImplementor);

            var actualColumnMajorOrderedEntries =
                (Complex[])Reflector.ExecuteMember(
                    actualImplementor,
                    "AsColumnMajorDenseArray",
                    null);

            Assert.IsNotNull(actualColumnMajorOrderedEntries);

            Assert.AreEqual(
                expectedColumnMajorOrderedEntries.Length,
                actualColumnMajorOrderedEntries.Length);

            for (int l = 0; l < actualColumnMajorOrderedEntries.Length; l++)
            {
                ComplexAssert.AreEqual(
                    expectedColumnMajorOrderedEntries[l],
                    actualColumnMajorOrderedEntries[l],
                    ComplexMatrixTest.Accuracy);
            }

            int expectedNumberOfRows = (int)Reflector.GetProperty(
                expectedImplementor,
                "NumberOfRows");

            int actualNumberOfRows = (int)Reflector.GetProperty(
                actualImplementor,
                "NumberOfRows");

            Assert.AreEqual(expectedNumberOfRows, actualNumberOfRows);

            int expectedNumberOfColumns = (int)Reflector.GetProperty(
                expectedImplementor,
                "NumberOfColumns");

            int actualNumberOfColumns = (int)Reflector.GetProperty(
                actualImplementor,
                "NumberOfColumns");

            Assert.AreEqual(expectedNumberOfColumns, actualNumberOfColumns);

            // Matrix Names

            MatrixNamesAreEqual(expected, actual);
        }