BEPUutilitiesTests.AffineTests.TestMultiplyCorrectness C# (CSharp) Method

        public static unsafe void TestMultiplyCorrectness()
        {
            const int iterationCount = 100000;
            Random random = new Random(5);
            for (int iterationIndex = 0; iterationIndex < iterationCount; ++iterationIndex)
            {
                AffineTransform simdA, simdB;
                bAffineTransform scalarA, scalarB;
                var simdPointerA = (float*)&simdA;
                var scalarPointerA = (float*)&scalarA;
                var simdPointerB = (float*)&simdB;
                var scalarPointerB = (float*)&scalarB;
                for (int i = 0; i < 12; ++i)
                {
                    scalarPointerA[i] = simdPointerA[i] = (float)(random.NextDouble() * 4 - 2);
                    scalarPointerB[i] = simdPointerB[i] = (float)(random.NextDouble() * 4 - 2);
                }

                AffineTransform simdResult;
                AffineTransform.Multiply(ref simdA, ref simdB, out simdResult);
                bAffineTransform scalarResult;
                bAffineTransform.Multiply(ref scalarA, ref scalarB, out scalarResult);
                var simdPointerResult = (float*)&simdResult;
                var scalarPointerResult = (float*)&scalarResult;

                for (int i = 0; i < 12; ++i)
                {
                    const float threshold = 1e-5f;
                    var simdScalarError = Math.Abs(simdPointerResult[i] - scalarPointerResult[i]);
                    if (simdScalarError > threshold)
                    {
                        Console.WriteLine($"Excess error for {i}");
                    }
                }
            }

            for (int iterationIndex = 0; iterationIndex < iterationCount; ++iterationIndex)
            {
                AffineTransform simdA, simdB;
                bAffineTransform scalarA, scalarB;
                var simdPointerA = (float*)&simdA;
                var scalarPointerA = (float*)&scalarA;
                var simdPointerB = (float*)&simdB;
                var scalarPointerB = (float*)&scalarB;
                for (int i = 0; i < 12; ++i)
                {
                    scalarPointerA[i] = simdPointerA[i] = (float)(random.NextDouble() * 4 - 2);
                    scalarPointerB[i] = simdPointerB[i] = (float)(random.NextDouble() * 4 - 2);
                }

                AffineTransform.Multiply(ref simdA, ref simdB, out simdA);
                bAffineTransform.Multiply(ref scalarA, ref scalarB, out scalarA);

                for (int i = 0; i < 12; ++i)
                {
                    const float threshold = 1e-5f;
                    var simdScalarError = Math.Abs(simdPointerA[i] - scalarPointerA[i]);
                    if (simdScalarError > threshold)
                    {
                        Console.WriteLine($"Excess error for {i}");
                    }
                }
            }

            for (int iterationIndex = 0; iterationIndex < iterationCount; ++iterationIndex)
            {
                AffineTransform simdA, simdB;
                bAffineTransform scalarA, scalarB;
                var simdPointerA = (float*)&simdA;
                var scalarPointerA = (float*)&scalarA;
                var simdPointerB = (float*)&simdB;
                var scalarPointerB = (float*)&scalarB;
                for (int i = 0; i < 12; ++i)
                {
                    scalarPointerA[i] = simdPointerA[i] = (float)(random.NextDouble() * 4 - 2);
                    scalarPointerB[i] = simdPointerB[i] = (float)(random.NextDouble() * 4 - 2);
                }

                AffineTransform.Multiply(ref simdA, ref simdB, out simdB);
                bAffineTransform.Multiply(ref scalarA, ref scalarB, out scalarB);

                for (int i = 0; i < 12; ++i)
                {
                    const float threshold = 1e-5f;
                    var simdScalarError = Math.Abs(simdPointerB[i] - scalarPointerB[i]);
                    if (simdScalarError > threshold)
                    {
                        Console.WriteLine($"Excess error for {i}");
                    }
                }
            }

            for (int iterationIndex = 0; iterationIndex < iterationCount; ++iterationIndex)
            {
                AffineTransform simd;
                bAffineTransform scalar;
                var simdPointer = (float*)&simd;
                var scalarPointer = (float*)&scalar;
                for (int i = 0; i < 12; ++i)
                {
                    scalarPointer[i] = simdPointer[i] = (float)(random.NextDouble() * 4 - 2);
                }

                AffineTransform.Multiply(ref simd, ref simd, out simd);
                bAffineTransform.Multiply(ref scalar, ref scalar, out scalar);

                for (int i = 0; i < 12; ++i)
                {
                    const float threshold = 1e-5f;
                    var simdScalarError = Math.Abs(simdPointer[i] - scalarPointer[i]);
                    if (simdScalarError > threshold)
                    {
                        Console.WriteLine($"Excess error for {i}");
                    }
                }
            }
        }