Added C# implementation of System.Math.ScaleB and System.MathF.ScaleB… (#42476)

* Added C# implementation of System.Math.ScaleB and System.MathF.ScaleB, removed old bindings, added test cases.

* Moved tests into System.Runtime.Extensions tests.

* Removed unmanaged scalbn and scalbnf from pal and mono

* Update src/libraries/System.Private.CoreLib/src/System/Math.cs

Co-authored-by: Adeel Mujahid <adeelbm@outlook.com>
* Styling changes.

* Conditionally include ScaleB for Mono.

* Update src/mono/mono/metadata/sysmath.c

Tabs, not spaces.

Co-authored-by: Adeel Mujahid <adeelbm@outlook.com>
* Removing more scalb from PAL

* Completely removed ScaleB from Mono

* Cleaning up more scalbn

* Added comments for ScaleB, updated licenses for musl and Sun

* Fixed whitespace.

* Removing old references, fixing double ScaleB definition that merge didn't resolve

Co-authored-by: Adeel Mujahid <adeelbm@outlook.com>

diff --git a/THIRD-PARTY-NOTICES.TXT b/THIRD-PARTY-NOTICES.TXT
index 88501d6..8dc999a 100644 (file)
--- a/THIRD-PARTY-NOTICES.TXT
+++ b/THIRD-PARTY-NOTICES.TXT
@@ -882,3 +882,69 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
+License notice for musl
+-----------------------
+
+musl as a whole is licensed under the following standard MIT license:
+
+Copyright © 2005-2020 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+License notice for Sun Microsystems
+-----------------------------------
+
+
+Copyright (c) 2002 Sun Microsystems, Inc. All  Rights Reserved.
+
+Redistribution  and use in  source  and binary  forms,  with or
+without modification, are permitted provided that the following
+conditions are met:
+
+ -Redistribution of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+ -Redistribution  in  binary  form  must  reproduce  the  above
+  copyright notice,  this list of conditions and  the following
+  disclaimer  in  the  documentation  and/or  other   materials
+  provided with the distribution.
+
+Neither  the  name  of  Sun Microsystems, Inc.  or the names of
+contributors may be used to endorse or promote products derived
+from this  software without  specific prior written permission.
+
+This  software  is provided  "AS IS," without a warranty of any
+kind.  ALL EXPRESS  OR IMPLIED  CONDITIONS, REPRESENTATIONS AND
+WARRANTIES,  INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
+FITNESS  FOR  A  PARTICULAR  PURPOSE  OR  NON-INFRINGEMENT, ARE
+HEREBY  EXCLUDED.    SUN MICROSYSTEMS, INC.  ("SUN")   AND  ITS
+LICENSORS  SHALL  NOT  BE  LIABLE  FOR  ANY DAMAGES SUFFERED BY
+LICENSEE  AS A  RESULT OF USING, MODIFYING OR DISTRIBUTING THIS
+SOFTWARE  OR  ITS  DERIVATIVES.   IN  NO  EVENT WILL SUN OR ITS
+LICENSORS BE LIABLE  FOR  ANY LOST REVENUE,  PROFIT OR DATA, OR
+FOR DIRECT,  INDIRECT,  SPECIAL,  CONSEQUENTIAL,  INCIDENTAL OR
+PUNITIVE DAMAGES,  HOWEVER CAUSED AND  REGARDLESS OF THE THEORY
+OF LIABILITY,  ARISING  OUT  OF  THE USE OF OR INABILITY TO USE
+THIS SOFTWARE,  EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGES.
+
+You acknowledge that this software is not designed, licensed or
+intended  for  use  in  the  design, construction, operation or
+maintenance of any nuclear facility.

diff --git a/src/coreclr/System.Private.CoreLib/src/System/Math.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Math.CoreCLR.cs
index 6ac864d..b607c95 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/Math.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/Math.CoreCLR.cs
@@ -97,9 +97,6 @@ namespace System
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern double Pow(double x, double y);
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern double ScaleB(double x, int n);
-
         [Intrinsic]
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern double Sin(double a);

diff --git a/src/coreclr/System.Private.CoreLib/src/System/MathF.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/MathF.CoreCLR.cs
index 8d60812..ae6e9cb 100644 (file)
--- a/src/coreclr/System.Private.CoreLib/src/System/MathF.CoreCLR.cs
+++ b/src/coreclr/System.Private.CoreLib/src/System/MathF.CoreCLR.cs
@@ -86,9 +86,6 @@ namespace System
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern float Pow(float x, float y);
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern float ScaleB(float x, int n);
-
         [Intrinsic]
         [MethodImpl(MethodImplOptions.InternalCall)]
         public static extern float Sin(float x);

diff --git a/src/coreclr/classlibnative/float/floatdouble.cpp b/src/coreclr/classlibnative/float/floatdouble.cpp
index 3419835..690b743 100644 (file)
--- a/src/coreclr/classlibnative/float/floatdouble.cpp
+++ b/src/coreclr/classlibnative/float/floatdouble.cpp
@@ -262,15 +262,6 @@ FCIMPL2_VV(double, COMDouble::Pow, double x, double y)
     return (double)pow(x, y);
 FCIMPLEND
 
-/*=====================================ScaleB===================================
-**
-==============================================================================*/
-FCIMPL2_VI(double, COMDouble::ScaleB, double x, int n)
-    FCALL_CONTRACT;
-
-    return (double)scalbn(x, n);
-FCIMPLEND
-
 /*=====================================Sin======================================
 **
 ==============================================================================*/

diff --git a/src/coreclr/classlibnative/float/floatsingle.cpp b/src/coreclr/classlibnative/float/floatsingle.cpp
index b7adb85..c535dbe 100644 (file)
--- a/src/coreclr/classlibnative/float/floatsingle.cpp
+++ b/src/coreclr/classlibnative/float/floatsingle.cpp
@@ -249,15 +249,6 @@ FCIMPL2_VV(float, COMSingle::Pow, float x, float y)
     return (float)powf(x, y);
 FCIMPLEND
 
-/*=====================================ScaleB===================================
-**
-==============================================================================*/
-FCIMPL2_VI(float, COMSingle::ScaleB, float x, int n)
-    FCALL_CONTRACT;
-
-    return (float)scalbnf(x, n);
-FCIMPLEND
-
 /*=====================================Sin======================================
 **
 ==============================================================================*/

diff --git a/src/coreclr/classlibnative/inc/floatdouble.h b/src/coreclr/classlibnative/inc/floatdouble.h
index 127ba17..80e49c0 100644 (file)
--- a/src/coreclr/classlibnative/inc/floatdouble.h
+++ b/src/coreclr/classlibnative/inc/floatdouble.h
@@ -31,7 +31,6 @@ public:
     FCDECL1_V(static double, Log10, double x);
     FCDECL2_VI(static double, ModF, double x, double* intptr);
     FCDECL2_VV(static double, Pow, double x, double y);
-    FCDECL2_VI(static double, ScaleB, double x, int n);
     FCDECL1_V(static double, Sin, double x);
     FCDECL3_VII(static void, SinCos, double x, double* sin, double* cos);
     FCDECL1_V(static double, Sinh, double x);

diff --git a/src/coreclr/classlibnative/inc/floatsingle.h b/src/coreclr/classlibnative/inc/floatsingle.h
index 786383e..e14bebb 100644 (file)
--- a/src/coreclr/classlibnative/inc/floatsingle.h
+++ b/src/coreclr/classlibnative/inc/floatsingle.h
@@ -31,7 +31,6 @@ public:
     FCDECL1_V(static float, Log10, float x);
     FCDECL2_VI(static float, ModF, float x, float* intptr);
     FCDECL2_VV(static float, Pow, float x, float y);
-    FCDECL2_VI(static float, ScaleB, float x, int n);
     FCDECL1_V(static float, Sin, float x);
     FCDECL3_VII(static void, SinCos, float x, float* sin, float* cos);
     FCDECL1_V(static float, Sinh, float x);

diff --git a/src/coreclr/pal/inc/pal.h b/src/coreclr/pal/inc/pal.h
index 5eb1544..95eeee7 100644 (file)
--- a/src/coreclr/pal/inc/pal.h
+++ b/src/coreclr/pal/inc/pal.h
@@ -3807,7 +3807,6 @@ PAL_GetCurrentThreadAffinitySet(SIZE_T size, UINT_PTR* data);
 #define log2          PAL_log2
 #define log10         PAL_log10
 #define pow           PAL_pow
-#define scalbn        PAL_scalbn
 #define sincos        PAL_sincos
 #define acosf         PAL_acosf
 #define acoshf        PAL_acoshf
@@ -3821,7 +3820,6 @@ PAL_GetCurrentThreadAffinitySet(SIZE_T size, UINT_PTR* data);
 #define log2f         PAL_log2f
 #define log10f        PAL_log10f
 #define powf          PAL_powf
-#define scalbnf       PAL_scalbnf
 #define sincosf       PAL_sincosf
 #define malloc        PAL_malloc
 #define free          PAL_free
@@ -4091,7 +4089,6 @@ PALIMPORT double __cdecl log2(double);
 PALIMPORT double __cdecl log10(double);
 PALIMPORT double __cdecl modf(double, double*);
 PALIMPORT double __cdecl pow(double, double);
-PALIMPORT double __cdecl scalbn(double, int);
 PALIMPORT double __cdecl sin(double);
 PALIMPORT void __cdecl sincos(double, double*, double*);
 PALIMPORT double __cdecl sinh(double);
@@ -4136,7 +4133,6 @@ PALIMPORT float __cdecl log2f(float);
 PALIMPORT float __cdecl log10f(float);
 PALIMPORT float __cdecl modff(float, float*);
 PALIMPORT float __cdecl powf(float, float);
-PALIMPORT float __cdecl scalbnf(float, int);
 PALIMPORT float __cdecl sinf(float);
 PALIMPORT void __cdecl sincosf(float, float*, float*);
 PALIMPORT float __cdecl sinhf(float);

diff --git a/src/coreclr/pal/src/cruntime/math.cpp b/src/coreclr/pal/src/cruntime/math.cpp
index 940f08a..33898bd 100644 (file)
--- a/src/coreclr/pal/src/cruntime/math.cpp
+++ b/src/coreclr/pal/src/cruntime/math.cpp
@@ -510,25 +510,6 @@ PALIMPORT double __cdecl PAL_pow(double x, double y)
 
 /*++
 Function:
-    scalbn
-
-See MSDN.
---*/
-PALIMPORT double __cdecl PAL_scalbn(double x, int n)
-{
-    double ret;
-    PERF_ENTRY(scalbn);
-    ENTRY("scalbn (x=%f, n=%d)\n", x, n);
-
-    ret = scalbn(x, n);
-
-    LOGEXIT("scalbn returns double %f\n", ret);
-    PERF_EXIT(scalbn);
-    return ret;
-}
-
-/*++
-Function:
     sincos
 
 See MSDN.
@@ -1011,25 +992,6 @@ PALIMPORT float __cdecl PAL_powf(float x, float y)
 
 /*++
 Function:
-    scalbnf
-
-See MSDN.
---*/
-PALIMPORT float __cdecl PAL_scalbnf(float x, int n)
-{
-    float ret;
-    PERF_ENTRY(scalbnf);
-    ENTRY("scalbnf (x=%f, n=%d)\n", x, n);
-
-    ret = scalbnf(x, n);
-
-    LOGEXIT("scalbnf returns float %f\n", ret);
-    PERF_EXIT(scalbnf);
-    return ret;
-}
-
-/*++
-Function:
     sincosf
 
 See MSDN.

diff --git a/src/coreclr/pal/src/include/pal/palinternal.h b/src/coreclr/pal/src/include/pal/palinternal.h
index bd35139..b0abe2a 100644 (file)
--- a/src/coreclr/pal/src/include/pal/palinternal.h
+++ b/src/coreclr/pal/src/include/pal/palinternal.h
@@ -458,7 +458,6 @@ function_name() to call the system's implementation
 #undef log10
 #undef modf
 #undef pow
-#undef scalbn
 #undef sin
 #undef sincos
 #undef sinh
@@ -487,7 +486,6 @@ function_name() to call the system's implementation
 #undef log10f
 #undef modff
 #undef powf
-#undef scalbnf
 #undef sinf
 #undef sincosf
 #undef sinhf

diff --git a/src/coreclr/pal/tests/palsuite/CMakeLists.txt b/src/coreclr/pal/tests/palsuite/CMakeLists.txt
index a62cd38..f59e6f4 100644 (file)
--- a/src/coreclr/pal/tests/palsuite/CMakeLists.txt
+++ b/src/coreclr/pal/tests/palsuite/CMakeLists.txt
@@ -224,8 +224,6 @@ _add_executable(paltests
   c_runtime/qsort/test2/test2.cpp
   c_runtime/rand_srand/test1/test1.cpp
   c_runtime/realloc/test1/test1.cpp
-  c_runtime/scalbn/test1/test1.cpp
-  c_runtime/scalbnf/test1/test1.cpp
   c_runtime/sin/test1/test1.cpp
   c_runtime/sincos/test1/test1.cpp
   c_runtime/sincosf/test1/test1.cpp

diff --git a/src/coreclr/pal/tests/palsuite/c_runtime/scalbn/test1/test1.cpp b/src/coreclr/pal/tests/palsuite/c_runtime/scalbn/test1/test1.cpp
deleted file mode 100644 (file)
index a36f2de..0000000
--- a/src/coreclr/pal/tests/palsuite/c_runtime/scalbn/test1/test1.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-/*=====================================================================
-**
-** Source:  test1.c
-**
-** Purpose: Tests that scalbn returns correct values.
-**
-**===================================================================*/
-
-#include <palsuite.h>
-
-// binary64 (double) has a machine epsilon of 2^-52 (approx. 2.22e-16). However, this 
-// is slightly too accurate when writing tests meant to run against libm implementations
-// for various platforms. 2^-50 (approx. 8.88e-16) seems to be as accurate as we can get.
-//
-// The tests themselves will take PAL_EPSILON and adjust it according to the expected result
-// so that the delta used for comparison will compare the most significant digits and ignore
-// any digits that are outside the double precision range (15-17 digits).
-
-// For example, a test with an expect result in the format of 0.xxxxxxxxxxxxxxxxx will use
-// PAL_EPSILON for the variance, while an expected result in the format of 0.0xxxxxxxxxxxxxxxxx
-// will use PAL_EPSILON / 10 and and expected result in the format of x.xxxxxxxxxxxxxxxx will
-// use PAL_EPSILON * 10.
-#define PAL_EPSILON 8.8817841970012523e-16
-
-#define PAL_NAN     sqrt(-1.0)
-#define PAL_POSINF -log(0.0)
-#define PAL_NEGINF  log(0.0)
-
-/**
- * Helper test structure
- */
-struct test
-{
-    double value;     /* value to test the function with */
-    int   exponent;  /* exponent to test the function with */
-    double expected;  /* expected result */
-    double variance;  /* maximum delta between the expected and actual result */
-};
-
-/**
- * scalbn_test1_validate
- *
- * test validation function
- */
-void __cdecl scalbn_test1_validate(double value, int exponent, double expected, double variance)
-{
-    double result = scalbn(value, exponent);
-
-    /*
-     * The test is valid when the difference between result
-     * and expected is less than or equal to variance
-     */
-    double delta = fabs(result - expected);
-
-    if (delta > variance)
-    {
-        Fail("scalbn(%g, %d) returned %20.17g when it should have returned %20.17g\n",
-             value, exponent, result, expected);
-    }
-}
-
-/**
- * scalbn_test1_validate
- *
- * test validation function for values returning NaN
- */
-void __cdecl scalbn_test1_validate_isnan(double value, int exponent)
-{
-    double result = scalbn(value, exponent);
-
-    if (!_isnan(result))
-    {
-        Fail("scalbn(%g, %d) returned %20.17g when it should have returned %20.17g\n",
-             value, exponent, result, PAL_NAN);
-    }
-}
-
-/**
- * main
- * 
- * executable entry point
- */
-PALTEST(c_runtime_scalbn_test1_paltest_scalbn_test1, "c_runtime/scalbn/test1/paltest_scalbn_test1")
-{
-    struct test tests[] = 
-    {
-        /* value                       exponent           expected               variance */
-        {  PAL_NEGINF,                 0x80000000,        PAL_NEGINF,            0 },
-        {  0,                          0x80000000,        0,                     0 },
-        {  0.11331473229676087,       -3,                 0.014164341537095108,  PAL_EPSILON / 10 },
-        {  0.15195522325791297,       -2,                 0.037988805814478242,  PAL_EPSILON / 10 },
-        {  0.20269956628651730,       -2,                 0.050674891571629327,  PAL_EPSILON / 10 },
-        {  0.33662253682241906,       -1,                 0.16831126841120952,   PAL_EPSILON },
-        {  0.36787944117144232,       -1,                 0.18393972058572117,   PAL_EPSILON },
-        {  0.37521422724648177,       -1,                 0.1876071136232409,    PAL_EPSILON },
-        {  0.45742934732229695,       -1,                 0.22871467366114848,   PAL_EPSILON },
-        {  0.5,                       -1,                 0.25,                  PAL_EPSILON },
-        {  0.58019181037172444,        0,                 0.5801918103717244,    PAL_EPSILON },
-        {  0.61254732653606592,        0,                 0.61254732653606592,   PAL_EPSILON },
-        {  0.61850313780157598,        0,                 0.61850313780157595,   PAL_EPSILON },
-        {  0.64321824193300488,        0,                 0.64321824193300492,   PAL_EPSILON },
-        {  0.74005557395545179,        0,                 0.74005557395545174,   PAL_EPSILON },
-        {  0.80200887896145195,        0,                 0.8020088789614519,    PAL_EPSILON },
-        {  1,                          0,                 1,                     PAL_EPSILON * 10 },
-        {  1.2468689889006383,         0,                 1.2468689889006384,    PAL_EPSILON * 10 },
-        {  1.3512498725672678,         0,                 1.3512498725672677,    PAL_EPSILON * 10 },
-        {  1.5546822754821001,         0,                 1.5546822754821001,    PAL_EPSILON * 10 },
-        {  1.6168066722416747,         0,                 1.6168066722416747,    PAL_EPSILON * 10 },
-        {  1.6325269194381528,         0,                 1.6325269194381529,    PAL_EPSILON * 10 },
-        {  1.7235679341273495,         0,                 1.7235679341273495,    PAL_EPSILON * 10 },
-        {  2,                          1,                 4,                     PAL_EPSILON * 10 },
-        {  2.1861299583286618,         1,                 4.3722599166573239,    PAL_EPSILON * 10 },
-        {  2.6651441426902252,         1,                 5.3302882853804503,    PAL_EPSILON * 10 },
-        {  2.7182818284590452,         1,                 5.4365636569180902,    PAL_EPSILON * 10 },
-        {  2.9706864235520193,         1,                 5.9413728471040388,    PAL_EPSILON * 10 },
-        {  4.9334096679145963,         2,                 19.733638671658387,    PAL_EPSILON * 100 },
-        {  6.5808859910179210,         2,                 26.323543964071686,    PAL_EPSILON * 100 },
-        {  8.8249778270762876,         3,                 70.599822616610297,    PAL_EPSILON * 100 },
-        {  PAL_POSINF,                 0x80000000,        PAL_POSINF,            0 },
-    };
-
-    if (PAL_Initialize(argc, argv) != 0)
-    {
-        return FAIL;
-    }
-
-    for (int i = 0; i < (sizeof(tests) / sizeof(struct test)); i++)
-    {
-        scalbn_test1_validate(tests[i].value, tests[i].exponent, tests[i].expected, tests[i].variance);
-    }
-
-    scalbn_test1_validate_isnan(PAL_NAN, 2147483647);
-
-    PAL_Terminate();
-    return PASS;
-}

diff --git a/src/coreclr/pal/tests/palsuite/c_runtime/scalbnf/test1/test1.cpp b/src/coreclr/pal/tests/palsuite/c_runtime/scalbnf/test1/test1.cpp
deleted file mode 100644 (file)
index 28ac640..0000000
--- a/src/coreclr/pal/tests/palsuite/c_runtime/scalbnf/test1/test1.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-/*=====================================================================
-**
-** Source:  test1.c
-**
-** Purpose: Tests that scalbnf returns correct values.
-**
-**===================================================================*/
-
-#include <palsuite.h>
-
-// binary32 (float) has a machine epsilon of 2^-23 (approx. 1.19e-07). However, this 
-// is slightly too accurate when writing tests meant to run against libm implementations
-// for various platforms. 2^-21 (approx. 4.76e-07) seems to be as accurate as we can get.
-//
-// The tests themselves will take PAL_EPSILON and adjust it according to the expected result
-// so that the delta used for comparison will compare the most significant digits and ignore
-// any digits that are outside the double precision range (6-9 digits).
-
-// For example, a test with an expect result in the format of 0.xxxxxxxxx will use PAL_EPSILON
-// for the variance, while an expected result in the format of 0.0xxxxxxxxx will use
-// PAL_EPSILON / 10 and and expected result in the format of x.xxxxxx will use PAL_EPSILON * 10.
-#define PAL_EPSILON 4.76837158e-07
-
-#define PAL_NAN     sqrtf(-1.0f)
-#define PAL_POSINF -logf(0.0f)
-#define PAL_NEGINF  logf(0.0f)
-
-/**
- * Helper test structure
- */
-struct test
-{
-    float value;     /* value to test the function with */
-    int   exponent;  /* exponent to test the function with */
-    float expected;  /* expected result */
-    float variance;  /* maximum delta between the expected and actual result */
-};
-
-/**
- * scalbnf_test1_validate
- *
- * test validation function
- */
-void __cdecl scalbnf_test1_validate(float value, int exponent, float expected, float variance)
-{
-    float result = scalbnf(value, exponent);
-
-    /*
-     * The test is valid when the difference between result
-     * and expected is less than or equal to variance
-     */
-    float delta = fabsf(result - expected);
-
-    if (delta > variance)
-    {
-        Fail("scalbnf(%g, %g) returned %10.9g when it should have returned %10.9g",
-             value, exponent, result, expected);
-    }
-}
-
-/**
- * scalbnf_test1_validate
- *
- * test validation function for values returning NaN
- */
-void __cdecl scalbnf_test1_validate_isnan(float value, int exponent)
-{
-    float result = scalbnf(value, exponent);
-
-    if (!_isnanf(result))
-    {
-        Fail("scalbnf(%g, %g) returned %10.9g when it should have returned %10.9g",
-             value, exponent, result, PAL_NAN);
-    }
-}
-
-/**
- * main
- * 
- * executable entry point
- */
-PALTEST(c_runtime_scalbnf_test1_paltest_scalbnf_test1, "c_runtime/scalbnf/test1/paltest_scalbnf_test1")
-{
-    struct test tests[] = 
-    {
-        /* value                exponent           expected        variance */
-        {  PAL_NEGINF,          0x80000000,        PAL_NEGINF,     0 },
-        {  0,                   0x80000000,        0,              0 },
-        {  0.113314732f,       -3,                 0.0141643415f,  PAL_EPSILON / 10 },
-        {  0.151955223f,       -2,                 0.0379888058f,  PAL_EPSILON / 10 },
-        {  0.202699566f,       -2,                 0.0506748916f,  PAL_EPSILON / 10 },
-        {  0.336622537f,       -1,                 0.168311268f,   PAL_EPSILON },
-        {  0.367879441f,       -1,                 0.183939721f,   PAL_EPSILON },
-        {  0.375214227f,       -1,                 0.187607114f,   PAL_EPSILON },
-        {  0.457429347f,       -1,                 0.228714674f,   PAL_EPSILON },
-        {  0.5f,               -1,                 0.25f,          PAL_EPSILON },
-        {  0.580191810f,        0,                 0.580191810f,   PAL_EPSILON },
-        {  0.612547327f,        0,                 0.612547327f,   PAL_EPSILON },
-        {  0.618503138f,        0,                 0.618503138f,   PAL_EPSILON },
-        {  0.643218242f,        0,                 0.643218242f,   PAL_EPSILON },
-        {  0.740055574f,        0,                 0.740055574f,   PAL_EPSILON },
-        {  0.802008879f,        0,                 0.802008879f,   PAL_EPSILON },
-        {  1,                   0,                 1,              PAL_EPSILON * 10 },
-        {  1.24686899f,         0,                 1.24686899f,    PAL_EPSILON * 10 },
-        {  1.35124987f,         0,                 1.35124987f,    PAL_EPSILON * 10 },
-        {  1.55468228f,         0,                 1.55468228f,    PAL_EPSILON * 10 },
-        {  1.61680667f,         0,                 1.61680667f,    PAL_EPSILON * 10 },
-        {  1.63252692f,         0,                 1.63252692f,    PAL_EPSILON * 10 },
-        {  1.72356793f,         0,                 1.72356793f,    PAL_EPSILON * 10 },
-        {  2,                   1,                 4,              PAL_EPSILON * 10 },
-        {  2.18612996f,         1,                 4.37225992f,    PAL_EPSILON * 10 },
-        {  2.66514414f,         1,                 5.33028829f,    PAL_EPSILON * 10 },
-        {  2.71828183f,         1,                 5.43656366f,    PAL_EPSILON * 10 },
-        {  2.97068642f,         1,                 5.94137285f,    PAL_EPSILON * 10 },
-        {  4.93340967f,         2,                 19.7336387f,    PAL_EPSILON * 100 },
-        {  6.58088599f,         2,                 26.3235440f,    PAL_EPSILON * 100 },
-        {  8.82497783f,         3,                 70.5998226f,    PAL_EPSILON * 100 },
-        {  PAL_POSINF,          0x80000000,        PAL_POSINF,     0 },
-    };
-
-    if (PAL_Initialize(argc, argv) != 0)
-    {
-        return FAIL;
-    }
-
-    for (int i = 0; i < (sizeof(tests) / sizeof(struct test)); i++)
-    {
-        scalbnf_test1_validate(tests[i].value, tests[i].exponent, tests[i].expected, tests[i].variance);
-    }
-
-    scalbnf_test1_validate_isnan(PAL_NAN, 2147483647);
-
-    PAL_Terminate();
-    return PASS;
-}

diff --git a/src/coreclr/pal/tests/palsuite/compilableTests.txt b/src/coreclr/pal/tests/palsuite/compilableTests.txt
index 8df6359..c674de2 100644 (file)
--- a/src/coreclr/pal/tests/palsuite/compilableTests.txt
+++ b/src/coreclr/pal/tests/palsuite/compilableTests.txt
@@ -159,8 +159,6 @@ c_runtime/qsort/test1/paltest_qsort_test1
 c_runtime/qsort/test2/paltest_qsort_test2
 c_runtime/rand_srand/test1/paltest_rand_srand_test1
 c_runtime/realloc/test1/paltest_realloc_test1
-c_runtime/scalbn/test1/paltest_scalbn_test1
-c_runtime/scalbnf/test1/paltest_scalbnf_test1
 c_runtime/sin/test1/paltest_sin_test1
 c_runtime/sincos/test1/paltest_sincos_test1
 c_runtime/sincosf/test1/paltest_sincosf_test1

diff --git a/src/coreclr/pal/tests/palsuite/paltestlist.txt b/src/coreclr/pal/tests/palsuite/paltestlist.txt
index 70f4b59..2b9ac7c 100644 (file)
--- a/src/coreclr/pal/tests/palsuite/paltestlist.txt
+++ b/src/coreclr/pal/tests/palsuite/paltestlist.txt
@@ -148,8 +148,6 @@ c_runtime/qsort/test1/paltest_qsort_test1
 c_runtime/qsort/test2/paltest_qsort_test2
 c_runtime/rand_srand/test1/paltest_rand_srand_test1
 c_runtime/realloc/test1/paltest_realloc_test1
-c_runtime/scalbn/test1/paltest_scalbn_test1
-c_runtime/scalbnf/test1/paltest_scalbnf_test1
 c_runtime/sin/test1/paltest_sin_test1
 c_runtime/sincos/test1/paltest_sincos_test1
 c_runtime/sincosf/test1/paltest_sincosf_test1

diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
index 378f05b..546fa2e 100644 (file)
--- a/src/coreclr/vm/ecalllist.h
+++ b/src/coreclr/vm/ecalllist.h
@@ -528,7 +528,6 @@ FCFuncStart(gMathFuncs)
     FCFuncElement("Log10", COMDouble::Log10)
     FCFuncElement("ModF", COMDouble::ModF)
     FCFuncElement("Pow", COMDouble::Pow)
-    FCFuncElement("ScaleB", COMDouble::ScaleB)
     FCFuncElement("Sin", COMDouble::Sin)
     FCFuncElement("SinCos", COMDouble::SinCos)
     FCFuncElement("Sinh", COMDouble::Sinh)
@@ -559,7 +558,6 @@ FCFuncStart(gMathFFuncs)
     FCFuncElement("Log10", COMSingle::Log10)
     FCFuncElement("ModF", COMSingle::ModF)
     FCFuncElement("Pow", COMSingle::Pow)
-    FCFuncElement("ScaleB", COMSingle::ScaleB)
     FCFuncElement("Sin", COMSingle::Sin)
     FCFuncElement("SinCos", COMSingle::SinCos)
     FCFuncElement("Sinh", COMSingle::Sinh)

diff --git a/src/libraries/System.Private.CoreLib/src/System/Math.cs b/src/libraries/System.Private.CoreLib/src/System/Math.cs
index 47ff242..95f84d5 100644 (file)
--- a/src/libraries/System.Private.CoreLib/src/System/Math.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Math.cs
@@ -43,6 +43,12 @@ namespace System
           1E9, 1E10, 1E11, 1E12, 1E13, 1E14, 1E15
         };
 
+        private const double SCALEB_C1 = 8.98846567431158E+307; // 0x1p1023
+
+        private const double SCALEB_C2 = 2.2250738585072014E-308; // 0x1p-1022
+
+        private const double SCALEB_C3 = 9007199254740992; // 0x1p53
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static short Abs(short value)
         {
@@ -1390,5 +1396,47 @@ namespace System
         {
             throw new ArgumentException(SR.Format(SR.Argument_MinMaxValue, min, max));
         }
+
+        public static double ScaleB(double x, int n)
+        {
+            // Implementation based on https://git.musl-libc.org/cgit/musl/tree/src/math/scalbln.c
+            //
+            // Performs the calculation x * 2^n efficiently. It constructs a double from 2^n by building
+            // the correct biased exponent. If n is greater than the maximum exponent (1023) or less than
+            // the minimum exponent (-1022), adjust x and n to compute correct result.
+
+            double y = x;
+            if (n > 1023)
+            {
+                y *= SCALEB_C1;
+                n -= 1023;
+                if (n > 1023)
+                {
+                    y *= SCALEB_C1;
+                    n -= 1023;
+                    if (n > 1023)
+                    {
+                        n = 1023;
+                    }
+                }
+            }
+            else if (n < -1022)
+            {
+                y *= SCALEB_C2 * SCALEB_C3;
+                n += 1022 - 53;
+                if (n < -1022)
+                {
+                    y *= SCALEB_C2 * SCALEB_C3;
+                    n += 1022 - 53;
+                    if (n < -1022)
+                    {
+                        n = -1022;
+                    }
+                }
+            }
+
+            double u = BitConverter.Int64BitsToDouble(((long)(0x3ff + n) << 52));
+            return y * u;
+        }
     }
 }

diff --git a/src/libraries/System.Private.CoreLib/src/System/MathF.cs b/src/libraries/System.Private.CoreLib/src/System/MathF.cs
index b18c6da..0050f5d 100644 (file)
--- a/src/libraries/System.Private.CoreLib/src/System/MathF.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/MathF.cs
@@ -37,6 +37,12 @@ namespace System
 
         private const float singleRoundLimit = 1e8f;
 
+        private const float SCALEB_C1 = 1.7014118E+38f; // 0x1p127f
+
+        private const float SCALEB_C2 = 1.1754944E-38f; // 0x1p-126f
+
+        private const float SCALEB_C3 = 16777216f; // 0x1p24f
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Abs(float x)
         {
@@ -471,5 +477,47 @@ namespace System
             ModF(x, &x);
             return x;
         }
+
+        public static float ScaleB(float x, int n)
+        {
+            // Implementation based on https://git.musl-libc.org/cgit/musl/tree/src/math/scalblnf.c
+            //
+            // Performs the calculation x * 2^n efficiently. It constructs a float from 2^n by building
+            // the correct biased exponent. If n is greater than the maximum exponent (127) or less than
+            // the minimum exponent (-126), adjust x and n to compute correct result.
+
+            float y = x;
+            if (n > 127)
+            {
+                y *= SCALEB_C1;
+                n -= 127;
+                if (n > 127)
+                {
+                    y *= SCALEB_C1;
+                    n -= 127;
+                    if (n > 127)
+                    {
+                        n = 127;
+                    }
+                }
+            }
+            else if (n < -126)
+            {
+                y *= SCALEB_C2 * SCALEB_C3;
+                n += 126 - 24;
+                if (n < -126)
+                {
+                    y *= SCALEB_C2 * SCALEB_C3;
+                    n += 126 - 24;
+                    if (n < -126)
+                    {
+                        n = -126;
+                    }
+                }
+            }
+
+            float u = BitConverter.Int32BitsToSingle(((int)(0x7f + n) << 23));
+            return y * u;
+        }
     }
 }

diff --git a/src/libraries/System.Runtime.Extensions/tests/System/Math.cs b/src/libraries/System.Runtime.Extensions/tests/System/Math.cs
index a899832..fbe9952 100644 (file)
--- a/src/libraries/System.Runtime.Extensions/tests/System/Math.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/Math.cs
@@ -2874,6 +2874,13 @@ namespace System.Tests
         [InlineData(-0.0,                      unchecked((int)(0x80000000)), -0.0,                      0)]
         [InlineData( double.NaN,               unchecked((int)(0x7FFFFFFF)),  double.NaN,               0)]
         [InlineData( 0.0,                      unchecked((int)(0x80000000)),  0,                        0)]
+        [InlineData( double.NaN,              0,                              double.NaN,               0)]
+        [InlineData( double.PositiveInfinity, 0,                              double.PositiveInfinity,  0)]
+        [InlineData( double.NegativeInfinity, 0,                              double.NegativeInfinity,  0)]
+        [InlineData( 1,                       2147483647,                     double.PositiveInfinity,  0)]
+        [InlineData( double.NaN,              1,                              double.NaN,               0)]
+        [InlineData( double.PositiveInfinity, -1,                             double.PositiveInfinity,  0)]
+        [InlineData( double.PositiveInfinity, unchecked((int)(0x7FFFFFFF)),   double.PositiveInfinity,  0)]
         [InlineData( 0.11331473229676087,     -4,                             0.0070821707685475542,    CrossPlatformMachineEpsilon / 100)]
         [InlineData( 0.15195522325791297,     -3,                             0.018994402907239121,     CrossPlatformMachineEpsilon / 10)]
         [InlineData( 0.20269956628651730,     -3,                             0.025337445785814663,     CrossPlatformMachineEpsilon / 10)]
@@ -2888,6 +2895,26 @@ namespace System.Tests
         [InlineData( 0.64321824193300488,     -1,                             0.32160912096650246,      CrossPlatformMachineEpsilon)]
         [InlineData( 0.74005557395545179,     -1,                             0.37002778697772587,      CrossPlatformMachineEpsilon)]
         [InlineData( 0.80200887896145195,     -1,                             0.40100443948072595,      CrossPlatformMachineEpsilon)]
+        [InlineData( 0,                       2147483647,                     0,                        CrossPlatformMachineEpsilon)]
+        [InlineData( 0,                       -2147483648,                    0,                        CrossPlatformMachineEpsilon)]
+        [InlineData( 1,                       -1,                             0.5,                      CrossPlatformMachineEpsilon)]
+        [InlineData( 8.98846567431158E+307,   -2097,                          5E-324,                   CrossPlatformMachineEpsilon)]
+        [InlineData( 5E-324,                  2097,                           8.98846567431158E+307,    CrossPlatformMachineEpsilon)]
+        [InlineData( 1.000244140625,          -1074,                          5E-324,                   CrossPlatformMachineEpsilon)]
+        [InlineData( 0.7499999999999999,      -1073,                          5E-324,                   CrossPlatformMachineEpsilon)]
+        [InlineData( 0.5000000000000012,      -1024,                          2.781342323134007E-309,   CrossPlatformMachineEpsilon)]
+        [InlineData( 0.6619858980995045,      3,                              5.295887184796036,        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( -8.06684839057968,       -2,                             -2.01671209764492,        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( -8.06684839057968,       -2,                             -2.01671209764492,        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( 4.345239849338305,       -1,                             2.1726199246691524,       CrossPlatformMachineEpsilon * 10)]
+        [InlineData( -8.38143342755525,       0,                              -8.38143342755525,        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( -0.4066039223853553,     4,                              -6.505662758165685,       CrossPlatformMachineEpsilon * 10)]
+        [InlineData( 4.345239849338305,       -1,                             2.1726199246691524,       CrossPlatformMachineEpsilon * 10)]
+        [InlineData( -8.38143342755525,       0,                              -8.38143342755525,        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( 0.6619858980995045,      3,                              5.295887184796036,        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( -0.4066039223853553,     4,                              -6.505662758165685,       CrossPlatformMachineEpsilon * 10)]
+        [InlineData( 1,                       0,                              1,                        CrossPlatformMachineEpsilon * 10)]
+        [InlineData( 1,                       1,                              2,                        CrossPlatformMachineEpsilon * 10)]
         [InlineData( 1,                        0,                             1,                        CrossPlatformMachineEpsilon * 10)]
         [InlineData( 1.2468689889006383,       0,                             1.2468689889006384,       CrossPlatformMachineEpsilon * 10)]
         [InlineData( 1.3512498725672678,       0,                             1.3512498725672677,       CrossPlatformMachineEpsilon * 10)]
@@ -2903,7 +2930,16 @@ namespace System.Tests
         [InlineData( 4.9334096679145963,       2,                             19.733638671658387,       CrossPlatformMachineEpsilon * 100)]
         [InlineData( 6.5808859910179210,       2,                             26.323543964071686,       CrossPlatformMachineEpsilon * 100)]
         [InlineData( 8.8249778270762876,       3,                             70.599822616610297,       CrossPlatformMachineEpsilon * 100)]
-        [InlineData( double.PositiveInfinity,  unchecked((int)(0x7FFFFFFF)),  double.PositiveInfinity,  0)]
+        [InlineData( -6.531673581913484,       1,                             -13.063347163826968,      CrossPlatformMachineEpsilon * 100)]
+        [InlineData( 9.267056966972586,        2,                             37.06822786789034,        CrossPlatformMachineEpsilon * 100)]
+        [InlineData( 0.5617597462207241,       5,                             17.97631187906317,        CrossPlatformMachineEpsilon * 100)]
+        [InlineData( 0.7741522965913037,       6,                             49.545746981843436,       CrossPlatformMachineEpsilon * 100)]
+        [InlineData( -0.6787637026394024,      7,                             -86.88175393784351,       CrossPlatformMachineEpsilon * 100)]        
+        [InlineData( -6.531673581913484,       1,                             -13.063347163826968,      CrossPlatformMachineEpsilon * 100)]
+        [InlineData( 9.267056966972586,        2,                             37.06822786789034,        CrossPlatformMachineEpsilon * 100)]
+        [InlineData( 0.5617597462207241,       5,                             17.97631187906317,        CrossPlatformMachineEpsilon * 100)]
+        [InlineData( 0.7741522965913037,       6,                             49.545746981843436,       CrossPlatformMachineEpsilon * 100)]
+        [InlineData( -0.6787637026394024,      7,                             -86.88175393784351,       CrossPlatformMachineEpsilon * 100)]
         public static void ScaleB(double x, int n, double expectedResult, double allowedVariance)
         {
             AssertEqual(expectedResult, Math.ScaleB(x, n), allowedVariance);

diff --git a/src/libraries/System.Runtime.Extensions/tests/System/MathF.cs b/src/libraries/System.Runtime.Extensions/tests/System/MathF.cs
index 71cc28c..562d101 100644 (file)
--- a/src/libraries/System.Runtime.Extensions/tests/System/MathF.cs
+++ b/src/libraries/System.Runtime.Extensions/tests/System/MathF.cs
@@ -202,812 +202,812 @@ namespace System.Tests
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, float.PositiveInfinity, 0.0f)]
-        [InlineData(-3.14159265f,            3.14159265f,            CrossPlatformMachineEpsilon * 10)]     // value: -(pi)             expected: (pi)
-        [InlineData(-2.71828183f,            2.71828183f,            CrossPlatformMachineEpsilon * 10)]     // value: -(e)              expected: (e)
-        [InlineData(-2.30258509f,            2.30258509f,            CrossPlatformMachineEpsilon * 10)]     // value: -(ln(10))         expected: (ln(10))
-        [InlineData(-1.57079633f,            1.57079633f,            CrossPlatformMachineEpsilon * 10)]     // value: -(pi / 2)         expected: (pi / 2)
-        [InlineData(-1.44269504f,            1.44269504f,            CrossPlatformMachineEpsilon * 10)]     // value: -(log2(e))        expected: (log2(e))
-        [InlineData(-1.41421356f,            1.41421356f,            CrossPlatformMachineEpsilon * 10)]     // value: -(sqrt(2))        expected: (sqrt(2))
-        [InlineData(-1.12837917f,            1.12837917f,            CrossPlatformMachineEpsilon * 10)]     // value: -(2 / sqrt(pi))   expected: (2 / sqrt(pi))
-        [InlineData(-1.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.785398163f,           0.785398163f,           CrossPlatformMachineEpsilon)]          // value: -(pi / 4)         expected: (pi / 4)
-        [InlineData(-0.707106781f,           0.707106781f,           CrossPlatformMachineEpsilon)]          // value: -(1 / sqrt(2))    expected: (1 / sqrt(2))
-        [InlineData(-0.693147181f,           0.693147181f,           CrossPlatformMachineEpsilon)]          // value: -(ln(2))          expected: (ln(2))
-        [InlineData(-0.636619772f,           0.636619772f,           CrossPlatformMachineEpsilon)]          // value: -(2 / pi)         expected: (2 / pi)
-        [InlineData(-0.434294482f,           0.434294482f,           CrossPlatformMachineEpsilon)]          // value: -(log10(e))       expected: (log10(e))
-        [InlineData(-0.318309886f,           0.318309886f,           CrossPlatformMachineEpsilon)]          // value: -(1 / pi)         expected: (1 / pi)
-        [InlineData(-0.0f,                   0.0f,                   0.0f)]
-        [InlineData( float.NaN,              float.NaN,              0.0f)]
-        [InlineData( 0.0f,                   0.0f,                   0.0f)]
-        [InlineData( 0.318309886f,           0.318309886f,           CrossPlatformMachineEpsilon)]          // value:  (1 / pi)         expected: (1 / pi)
-        [InlineData( 0.434294482f,           0.434294482f,           CrossPlatformMachineEpsilon)]          // value:  (log10(e))       expected: (log10(e))
-        [InlineData( 0.636619772f,           0.636619772f,           CrossPlatformMachineEpsilon)]          // value:  (2 / pi)         expected: (2 / pi)
-        [InlineData( 0.693147181f,           0.693147181f,           CrossPlatformMachineEpsilon)]          // value:  (ln(2))          expected: (ln(2))
-        [InlineData( 0.707106781f,           0.707106781f,           CrossPlatformMachineEpsilon)]          // value:  (1 / sqrt(2))    expected: (1 / sqrt(2))
-        [InlineData( 0.785398163f,           0.785398163f,           CrossPlatformMachineEpsilon)]          // value:  (pi / 4)         expected: (pi / 4)
-        [InlineData( 1.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.12837917f,            1.12837917f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))   expected: (2 / sqrt(pi))
-        [InlineData( 1.41421356f,            1.41421356f,            CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))        expected: (sqrt(2))
-        [InlineData( 1.44269504f,            1.44269504f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))        expected: (log2(e))
-        [InlineData( 1.57079633f,            1.57079633f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)         expected: (pi / 2)
-        [InlineData( 2.30258509f,            2.30258509f,            CrossPlatformMachineEpsilon * 10)]     // value:  (ln(10))         expected: (ln(10))
-        [InlineData( 2.71828183f,            2.71828183f,            CrossPlatformMachineEpsilon * 10)]     // value:  (e)              expected: (e)
-        [InlineData( 3.14159265f,            3.14159265f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi)             expected: (pi)
-        [InlineData( float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(-3.14159265f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]     // value: -(pi)             expected: (pi)
+        [InlineData(-2.71828183f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]     // value: -(e)              expected: (e)
+        [InlineData(-2.30258509f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]     // value: -(ln(10))         expected: (ln(10))
+        [InlineData(-1.57079633f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // value: -(pi / 2)         expected: (pi / 2)
+        [InlineData(-1.44269504f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]     // value: -(log2(e))        expected: (log2(e))
+        [InlineData(-1.41421356f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]     // value: -(sqrt(2))        expected: (sqrt(2))
+        [InlineData(-1.12837917f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]     // value: -(2 / sqrt(pi))   expected: (2 / sqrt(pi))
+        [InlineData(-1.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.785398163f, 0.785398163f, CrossPlatformMachineEpsilon)]          // value: -(pi / 4)         expected: (pi / 4)
+        [InlineData(-0.707106781f, 0.707106781f, CrossPlatformMachineEpsilon)]          // value: -(1 / sqrt(2))    expected: (1 / sqrt(2))
+        [InlineData(-0.693147181f, 0.693147181f, CrossPlatformMachineEpsilon)]          // value: -(ln(2))          expected: (ln(2))
+        [InlineData(-0.636619772f, 0.636619772f, CrossPlatformMachineEpsilon)]          // value: -(2 / pi)         expected: (2 / pi)
+        [InlineData(-0.434294482f, 0.434294482f, CrossPlatformMachineEpsilon)]          // value: -(log10(e))       expected: (log10(e))
+        [InlineData(-0.318309886f, 0.318309886f, CrossPlatformMachineEpsilon)]          // value: -(1 / pi)         expected: (1 / pi)
+        [InlineData(-0.0f, 0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.318309886f, CrossPlatformMachineEpsilon)]          // value:  (1 / pi)         expected: (1 / pi)
+        [InlineData(0.434294482f, 0.434294482f, CrossPlatformMachineEpsilon)]          // value:  (log10(e))       expected: (log10(e))
+        [InlineData(0.636619772f, 0.636619772f, CrossPlatformMachineEpsilon)]          // value:  (2 / pi)         expected: (2 / pi)
+        [InlineData(0.693147181f, 0.693147181f, CrossPlatformMachineEpsilon)]          // value:  (ln(2))          expected: (ln(2))
+        [InlineData(0.707106781f, 0.707106781f, CrossPlatformMachineEpsilon)]          // value:  (1 / sqrt(2))    expected: (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.785398163f, CrossPlatformMachineEpsilon)]          // value:  (pi / 4)         expected: (pi / 4)
+        [InlineData(1.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.12837917f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))   expected: (2 / sqrt(pi))
+        [InlineData(1.41421356f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))        expected: (sqrt(2))
+        [InlineData(1.44269504f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))        expected: (log2(e))
+        [InlineData(1.57079633f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)         expected: (pi / 2)
+        [InlineData(2.30258509f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]     // value:  (ln(10))         expected: (ln(10))
+        [InlineData(2.71828183f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]     // value:  (e)              expected: (e)
+        [InlineData(3.14159265f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi)             expected: (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Abs(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Abs(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, float.NaN,    0.0f)]
-        [InlineData(-3.14159265f,            float.NaN,    0.0f)]                               //                              value: -(pi)
-        [InlineData(-2.71828183f,            float.NaN,    0.0f)]                               //                              value: -(e)
-        [InlineData(-1.41421356f,            float.NaN,    0.0f)]                               //                              value: -(sqrt(2))
-        [InlineData(-1.0f,                   3.14159265f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (pi)
-        [InlineData(-0.911733915f,           2.71828183f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (e)
-        [InlineData(-0.668201510f,           2.30258509f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (ln(10))
-        [InlineData(-0.0f,                   1.57079633f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (pi / 2)
-        [InlineData( float.NaN,              float.NaN,    0.0f)]
-        [InlineData( 0.0f,                   1.57079633f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (pi / 2)
-        [InlineData( 0.127751218f,           1.44269504f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (log2(e))
-        [InlineData( 0.155943695f,           1.41421356f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (sqrt(2))
-        [InlineData( 0.428125148f,           1.12837917f,  CrossPlatformMachineEpsilon * 10)]   // expected:  (2 / sqrt(pi))
-        [InlineData( 0.540302306f,           1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.707106781f,           0.785398163f, CrossPlatformMachineEpsilon)]        // expected:  (pi / 4),         value:  (1 / sqrt(2))
-        [InlineData( 0.760244597f,           0.707106781f, CrossPlatformMachineEpsilon)]        // expected:  (1 / sqrt(2))
-        [InlineData( 0.769238901f,           0.693147181f, CrossPlatformMachineEpsilon)]        // expected:  (ln(2))
-        [InlineData( 0.804109828f,           0.636619772f, CrossPlatformMachineEpsilon)]        // expected:  (2 / pi)
-        [InlineData( 0.907167129f,           0.434294482f, CrossPlatformMachineEpsilon)]        // expected:  (log10(e))
-        [InlineData( 0.949765715f,           0.318309886f, CrossPlatformMachineEpsilon)]        // expected:  (1 / pi)
-        [InlineData( 1.0f,                   0.0f,         0.0f)]
-        [InlineData( 1.41421356f,            float.NaN,    0.0f)]                               //                              value:  (sqrt(2))
-        [InlineData( 2.71828183f,            float.NaN,    0.0f)]                               //                              value:  (e)
-        [InlineData( 3.14159265f,            float.NaN,    0.0f)]                               //                              value:  (pi)
-        [InlineData( float.PositiveInfinity, float.NaN,    0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                               //                              value: -(pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                               //                              value: -(e)
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                               //                              value: -(sqrt(2))
+        [InlineData(-1.0f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]   // expected:  (pi)
+        [InlineData(-0.911733915f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]   // expected:  (e)
+        [InlineData(-0.668201510f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]   // expected:  (ln(10))
+        [InlineData(-0.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]   // expected:  (pi / 2)
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]   // expected:  (pi / 2)
+        [InlineData(0.127751218f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]   // expected:  (log2(e))
+        [InlineData(0.155943695f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]   // expected:  (sqrt(2))
+        [InlineData(0.428125148f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]   // expected:  (2 / sqrt(pi))
+        [InlineData(0.540302306f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.707106781f, 0.785398163f, CrossPlatformMachineEpsilon)]        // expected:  (pi / 4),         value:  (1 / sqrt(2))
+        [InlineData(0.760244597f, 0.707106781f, CrossPlatformMachineEpsilon)]        // expected:  (1 / sqrt(2))
+        [InlineData(0.769238901f, 0.693147181f, CrossPlatformMachineEpsilon)]        // expected:  (ln(2))
+        [InlineData(0.804109828f, 0.636619772f, CrossPlatformMachineEpsilon)]        // expected:  (2 / pi)
+        [InlineData(0.907167129f, 0.434294482f, CrossPlatformMachineEpsilon)]        // expected:  (log10(e))
+        [InlineData(0.949765715f, 0.318309886f, CrossPlatformMachineEpsilon)]        // expected:  (1 / pi)
+        [InlineData(1.0f, 0.0f, 0.0f)]
+        [InlineData(1.41421356f, float.NaN, 0.0f)]                               //                              value:  (sqrt(2))
+        [InlineData(2.71828183f, float.NaN, 0.0f)]                               //                              value:  (e)
+        [InlineData(3.14159265f, float.NaN, 0.0f)]                               //                              value:  (pi)
+        [InlineData(float.PositiveInfinity, float.NaN, 0.0f)]
         public static void Acos(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Acos(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-3.14159265f,             float.NaN,              0.0f)]                              //                                value: -(pi)
-        [InlineData(-2.71828183f,             float.NaN,              0.0f)]                              //                                value: -(e)
-        [InlineData(-1.41421356f,             float.NaN,              0.0f)]                              //                                value: -(sqrt(2))
-        [InlineData(-1.0f,                    float.NaN,              0.0f)]
-        [InlineData(-0.693147181f,            float.NaN,              0.0f)]                              //                                value: -(ln(2))
-        [InlineData(-0.434294482f,            float.NaN,              0.0f)]                              //                                value: -(log10(e))
-        [InlineData(-0.0f,                    float.NaN,              0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    float.NaN,              0.0f)]
-        [InlineData( 1.0f,                    0.0f,                   CrossPlatformMachineEpsilon)]
-        [InlineData( 1.05108979f,             0.318309886f,           CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
-        [InlineData( 1.09579746f,             0.434294482f,           CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
-        [InlineData( 1.20957949f,             0.636619772f,           CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
-        [InlineData( 1.25f,                   0.693147181f,           CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
-        [InlineData( 1.26059184f,             0.707106781f,           CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
-        [InlineData( 1.32460909f,             0.785398163f,           CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
-        [InlineData( 1.54308063f,             1.0,                    CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.70710014f,             1.12837917f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
-        [InlineData( 2.17818356f,             1.41421356f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
-        [InlineData( 2.23418810f,             1.44269504f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
-        [InlineData( 2.50917848f,             1.57079633f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
-        [InlineData( 5.05f,                   2.30258509f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (ln(10))
-        [InlineData( 7.61012514f,             2.71828183f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (e)
-        [InlineData( 11.5919533f,             3.14159265f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                              //                                value: -(pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                              //                                value: -(e)
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                              //                                value: -(sqrt(2))
+        [InlineData(-1.0f, float.NaN, 0.0f)]
+        [InlineData(-0.693147181f, float.NaN, 0.0f)]                              //                                value: -(ln(2))
+        [InlineData(-0.434294482f, float.NaN, 0.0f)]                              //                                value: -(log10(e))
+        [InlineData(-0.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, float.NaN, 0.0f)]
+        [InlineData(1.0f, 0.0f, CrossPlatformMachineEpsilon)]
+        [InlineData(1.05108979f, 0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
+        [InlineData(1.09579746f, 0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
+        [InlineData(1.20957949f, 0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
+        [InlineData(1.25f, 0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
+        [InlineData(1.26059184f, 0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
+        [InlineData(1.32460909f, 0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
+        [InlineData(1.54308063f, 1.0, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.70710014f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
+        [InlineData(2.17818356f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
+        [InlineData(2.23418810f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
+        [InlineData(2.50917848f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
+        [InlineData(5.05f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]  // expected:  (ln(10))
+        [InlineData(7.61012514f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]  // expected:  (e)
+        [InlineData(11.5919533f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Acosh(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Acosh(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,    0.0f)]
-        [InlineData(-3.14159265f,             float.NaN,    0.0f)]                              //                              value: -(pi)
-        [InlineData(-2.71828183f,             float.NaN,    0.0f)]                              //                              value: -(e)
-        [InlineData(-1.41421356f,             float.NaN,    0.0f)]                              //                              value: -(sqrt(2))
-        [InlineData(-1.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
-        [InlineData(-0.991806244f,           -1.44269504f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
-        [InlineData(-0.987765946f,           -1.41421356f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
-        [InlineData(-0.903719457f,           -1.12837917f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
-        [InlineData(-0.841470985f,           -1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.743980337f,           -0.839007561f, CrossPlatformMachineEpsilon)]       // expected: -(pi - ln(10))
-        [InlineData(-0.707106781f,           -0.785398163f, CrossPlatformMachineEpsilon)]       // expected: -(pi / 4),         value: (1 / sqrt(2))
-        [InlineData(-0.649636939f,           -0.707106781f, CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
-        [InlineData(-0.638961276f,           -0.693147181f, CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
-        [InlineData(-0.594480769f,           -0.636619772f, CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
-        [InlineData(-0.420770483f,           -0.434294482f, CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
-        [InlineData(-0.410781291f,           -0.423310825f, CrossPlatformMachineEpsilon)]       // expected: -(pi - e)
-        [InlineData(-0.312961796f,           -0.318309886f, CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,         0.0f)]
-        [InlineData( float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    0.0f,         0.0f)]
-        [InlineData( 0.312961796f,            0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
-        [InlineData( 0.410781291f,            0.423310825f, CrossPlatformMachineEpsilon)]       // expected:  (pi - e)
-        [InlineData( 0.420770483f,            0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
-        [InlineData( 0.594480769f,            0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
-        [InlineData( 0.638961276f,            0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
-        [InlineData( 0.649636939f,            0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
-        [InlineData( 0.707106781f,            0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4),         value: (1 / sqrt(2))
-        [InlineData( 0.743980337f,            0.839007561f, CrossPlatformMachineEpsilon)]       // expected:  (pi - ln(10))
-        [InlineData( 0.841470985f,            1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.903719457f,            1.12837917f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
-        [InlineData( 0.987765946f,            1.41421356f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
-        [InlineData( 0.991806244f,            1.44269504f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
-        [InlineData( 1.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
-        [InlineData( 1.41421356f,             float.NaN,    0.0f)]                              //                              value:  (sqrt(2))
-        [InlineData( 2.71828183f,             float.NaN,    0.0f)]                              //                              value:  (e)
-        [InlineData( 3.14159265f,             float.NaN,    0.0f)]                              //                              value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.NaN,    0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                              //                              value: -(pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                              //                              value: -(e)
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                              //                              value: -(sqrt(2))
+        [InlineData(-1.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
+        [InlineData(-0.991806244f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
+        [InlineData(-0.987765946f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
+        [InlineData(-0.903719457f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
+        [InlineData(-0.841470985f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.743980337f, -0.839007561f, CrossPlatformMachineEpsilon)]       // expected: -(pi - ln(10))
+        [InlineData(-0.707106781f, -0.785398163f, CrossPlatformMachineEpsilon)]       // expected: -(pi / 4),         value: (1 / sqrt(2))
+        [InlineData(-0.649636939f, -0.707106781f, CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
+        [InlineData(-0.638961276f, -0.693147181f, CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
+        [InlineData(-0.594480769f, -0.636619772f, CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
+        [InlineData(-0.420770483f, -0.434294482f, CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
+        [InlineData(-0.410781291f, -0.423310825f, CrossPlatformMachineEpsilon)]       // expected: -(pi - e)
+        [InlineData(-0.312961796f, -0.318309886f, CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.312961796f, 0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
+        [InlineData(0.410781291f, 0.423310825f, CrossPlatformMachineEpsilon)]       // expected:  (pi - e)
+        [InlineData(0.420770483f, 0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
+        [InlineData(0.594480769f, 0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
+        [InlineData(0.638961276f, 0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
+        [InlineData(0.649636939f, 0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
+        [InlineData(0.707106781f, 0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4),         value: (1 / sqrt(2))
+        [InlineData(0.743980337f, 0.839007561f, CrossPlatformMachineEpsilon)]       // expected:  (pi - ln(10))
+        [InlineData(0.841470985f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.903719457f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
+        [InlineData(0.987765946f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
+        [InlineData(0.991806244f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
+        [InlineData(1.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
+        [InlineData(1.41421356f, float.NaN, 0.0f)]                              //                              value:  (sqrt(2))
+        [InlineData(2.71828183f, float.NaN, 0.0f)]                              //                              value:  (e)
+        [InlineData(3.14159265f, float.NaN, 0.0f)]                              //                              value:  (pi)
+        [InlineData(float.PositiveInfinity, float.NaN, 0.0f)]
         public static void Asin(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Asin(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NegativeInfinity, 0.0f)]
-        [InlineData(-11.5487394f,            -3.14159265f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(pi)
-        [InlineData(-7.54413710f,            -2.71828183f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(e)
-        [InlineData(-4.95f,                  -2.30258509f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(ln(10))
-        [InlineData(-2.30129890f,            -1.57079633f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
-        [InlineData(-1.99789801f,            -1.44269504f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
-        [InlineData(-1.93506682f,            -1.41421356f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
-        [InlineData(-1.38354288f,            -1.12837917f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
-        [InlineData(-1.17520119f,            -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.868670961f,           -0.785398163f,           CrossPlatformMachineEpsilon)]       // expected: -(pi / 4)
-        [InlineData(-0.767523145f,           -0.707106781f,           CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
-        [InlineData(-0.75f,                  -0.693147181f,           CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
-        [InlineData(-0.680501678f,           -0.636619772f,           CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
-        [InlineData(-0.448075979f,           -0.434294482f,           CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
-        [InlineData(-0.323712439f,           -0.318309886f,           CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0,                    0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    0.0,                    0.0f)]
-        [InlineData( 0.323712439f,            0.318309886f,           CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
-        [InlineData( 0.448075979f,            0.434294482f,           CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
-        [InlineData( 0.680501678f,            0.636619772f,           CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
-        [InlineData( 0.75f,                   0.693147181f,           CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
-        [InlineData( 0.767523145f,            0.707106781f,           CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
-        [InlineData( 0.868670961f,            0.785398163f,           CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
-        [InlineData( 1.17520119f,             1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.38354288f,             1.12837917f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
-        [InlineData( 1.93506682f,             1.41421356f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
-        [InlineData( 1.99789801f,             1.44269504f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
-        [InlineData( 2.30129890f,             1.57079633f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
-        [InlineData( 4.95f,                   2.30258509f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (ln(10))
-        [InlineData( 7.54413710f,             2.71828183f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (e)
-        [InlineData( 11.5487394f,             3.14159265f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, 0.0f)]
+        [InlineData(-11.5487394f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]  // expected: -(pi)
+        [InlineData(-7.54413710f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]  // expected: -(e)
+        [InlineData(-4.95f, -2.30258509f, CrossPlatformMachineEpsilon * 10)]  // expected: -(ln(10))
+        [InlineData(-2.30129890f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
+        [InlineData(-1.99789801f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
+        [InlineData(-1.93506682f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
+        [InlineData(-1.38354288f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
+        [InlineData(-1.17520119f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.868670961f, -0.785398163f, CrossPlatformMachineEpsilon)]       // expected: -(pi / 4)
+        [InlineData(-0.767523145f, -0.707106781f, CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
+        [InlineData(-0.75f, -0.693147181f, CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
+        [InlineData(-0.680501678f, -0.636619772f, CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
+        [InlineData(-0.448075979f, -0.434294482f, CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
+        [InlineData(-0.323712439f, -0.318309886f, CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
+        [InlineData(-0.0f, -0.0, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0, 0.0f)]
+        [InlineData(0.323712439f, 0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
+        [InlineData(0.448075979f, 0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
+        [InlineData(0.680501678f, 0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
+        [InlineData(0.75f, 0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
+        [InlineData(0.767523145f, 0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
+        [InlineData(0.868670961f, 0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
+        [InlineData(1.17520119f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.38354288f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
+        [InlineData(1.93506682f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
+        [InlineData(1.99789801f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
+        [InlineData(2.30129890f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
+        [InlineData(4.95f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]  // expected:  (ln(10))
+        [InlineData(7.54413710f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]  // expected:  (e)
+        [InlineData(11.5487394f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Asinh(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Asinh(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, -1.57079633f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
-        [InlineData(-7.76357567f,            -1.44269504f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
-        [InlineData(-6.33411917f,            -1.41421356f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
-        [InlineData(-2.11087684f,            -1.12837917f,  CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
-        [InlineData(-1.55740772f,            -1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-1.11340715f,            -0.839007561f, CrossPlatformMachineEpsilon)]       // expected: -(pi - ln(10))
-        [InlineData(-1.0f,                   -0.785398163f, CrossPlatformMachineEpsilon)]       // expected: -(pi / 4)
-        [InlineData(-0.854510432f,           -0.707106781f, CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
-        [InlineData(-0.830640878f,           -0.693147181f, CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
-        [InlineData(-0.739302950f,           -0.636619772f, CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
-        [InlineData(-0.463829067f,           -0.434294482f, CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
-        [InlineData(-0.450549534f,           -0.423310825f, CrossPlatformMachineEpsilon)]       // expected: -(pi - e)
-        [InlineData(-0.329514733f,           -0.318309886f, CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,         0.0f)]
-        [InlineData( float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    0.0f,         0.0f)]
-        [InlineData( 0.329514733f,            0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
-        [InlineData( 0.450549534f,            0.423310825f, CrossPlatformMachineEpsilon)]       // expected:  (pi - e)
-        [InlineData( 0.463829067f,            0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
-        [InlineData( 0.739302950f,            0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
-        [InlineData( 0.830640878f,            0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
-        [InlineData( 0.854510432f,            0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
-        [InlineData( 1.0f,                    0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
-        [InlineData( 1.11340715f,             0.839007561f, CrossPlatformMachineEpsilon)]       // expected:  (pi - ln(10))
-        [InlineData( 1.55740772f,             1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2.11087684f,             1.12837917f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
-        [InlineData( 6.33411917f,             1.41421356f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
-        [InlineData( 7.76357567f,             1.44269504f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
-        [InlineData( float.PositiveInfinity,  1.57079633f,  CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
+        [InlineData(float.NegativeInfinity, -1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
+        [InlineData(-7.76357567f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
+        [InlineData(-6.33411917f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
+        [InlineData(-2.11087684f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
+        [InlineData(-1.55740772f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-1.11340715f, -0.839007561f, CrossPlatformMachineEpsilon)]       // expected: -(pi - ln(10))
+        [InlineData(-1.0f, -0.785398163f, CrossPlatformMachineEpsilon)]       // expected: -(pi / 4)
+        [InlineData(-0.854510432f, -0.707106781f, CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
+        [InlineData(-0.830640878f, -0.693147181f, CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
+        [InlineData(-0.739302950f, -0.636619772f, CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
+        [InlineData(-0.463829067f, -0.434294482f, CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
+        [InlineData(-0.450549534f, -0.423310825f, CrossPlatformMachineEpsilon)]       // expected: -(pi - e)
+        [InlineData(-0.329514733f, -0.318309886f, CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.329514733f, 0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
+        [InlineData(0.450549534f, 0.423310825f, CrossPlatformMachineEpsilon)]       // expected:  (pi - e)
+        [InlineData(0.463829067f, 0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
+        [InlineData(0.739302950f, 0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
+        [InlineData(0.830640878f, 0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
+        [InlineData(0.854510432f, 0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
+        [InlineData(1.0f, 0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
+        [InlineData(1.11340715f, 0.839007561f, CrossPlatformMachineEpsilon)]       // expected:  (pi - ln(10))
+        [InlineData(1.55740772f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2.11087684f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
+        [InlineData(6.33411917f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
+        [InlineData(7.76357567f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
+        [InlineData(float.PositiveInfinity, 1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
         public static void Atan(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Atan(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, -1.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
-        [InlineData( float.NegativeInfinity, -0.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
-        [InlineData( float.NegativeInfinity,  float.NaN,               float.NaN,    0.0f)]
-        [InlineData( float.NegativeInfinity,  0.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
-        [InlineData( float.NegativeInfinity,  1.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
-        [InlineData(-1.0f,                   -1.0f,                   -2.35619449f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(3 * pi / 4)
-        [InlineData(-1.0f,                   -0.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
-        [InlineData(-1.0f,                    float.NaN,               float.NaN,    0.0f)]
-        [InlineData(-1.0f,                    0.0f,                   -1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
-        [InlineData(-1.0f,                    1.0f,                   -0.785398163f, CrossPlatformMachineEpsilon)]          // expected: -(pi / 4)
-        [InlineData(-1.0f,                    float.PositiveInfinity, -0.0f,         0.0f)]
-        [InlineData(-0.991806244f,           -0.127751218f,           -1.69889761f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - log2(e))
-        [InlineData(-0.991806244f,            0.127751218f,           -1.44269504f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(log2(e))
-        [InlineData(-0.987765946f,           -0.155943695f,           -1.72737909f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - sqrt(2))
-        [InlineData(-0.987765946f,            0.155943695f,           -1.41421356f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(sqrt(2))
-        [InlineData(-0.903719457f,           -0.428125148f,           -2.01321349f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (2 / sqrt(pi))
-        [InlineData(-0.903719457f,            0.428125148f,           -1.12837917f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(2 / sqrt(pi)
-        [InlineData(-0.841470985f,           -0.540302306f,           -2.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - 1)
-        [InlineData(-0.841470985f,            0.540302306f,           -1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.743980337f,           -0.668201510f,           -2.30258509f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(ln(10))
-        [InlineData(-0.743980337f,            0.668201510f,           -0.839007561f, CrossPlatformMachineEpsilon)]          // expected: -(pi - ln(10))
-        [InlineData(-0.707106781f,           -0.707106781f,           -2.35619449f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(3 * pi / 4),         y: -(1 / sqrt(2))   x: -(1 / sqrt(2))
-        [InlineData(-0.707106781f,            0.707106781f,           -0.785398163f, CrossPlatformMachineEpsilon)]          // expected: -(pi / 4),             y: -(1 / sqrt(2))   x:  (1 / sqrt(2))
-        [InlineData(-0.649636939f,           -0.760244597f,           -2.43448587f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (1 / sqrt(2))
-        [InlineData(-0.649636939f,            0.760244597f,           -0.707106781f, CrossPlatformMachineEpsilon)]          // expected: -(1 / sqrt(2))
-        [InlineData(-0.638961276f,           -0.769238901f,           -2.44844547f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - ln(2))
-        [InlineData(-0.638961276f,            0.769238901f,           -0.693147181f, CrossPlatformMachineEpsilon)]          // expected: -(ln(2))
-        [InlineData(-0.594480769f,           -0.804109828f,           -2.50497288f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (2 / pi))
-        [InlineData(-0.594480769f,            0.804109828f,           -0.636619772f, CrossPlatformMachineEpsilon)]          // expected: -(2 / pi)
-        [InlineData(-0.420770483f,           -0.907167129f,           -2.70729817f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - log10(e))
-        [InlineData(-0.420770483f,            0.907167129f,           -0.434294482f, CrossPlatformMachineEpsilon)]          // expected: -(log10(e))
-        [InlineData(-0.410781291f,           -0.911733915f,           -2.71828183f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(e)
-        [InlineData(-0.410781291f,            0.911733915f,           -0.423310825f, CrossPlatformMachineEpsilon)]          // expected: -(pi - e)
-        [InlineData(-0.312961796f,           -0.949765715f,           -2.82328277f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (1 / pi))
-        [InlineData(-0.312961796f,            0.949765715f,           -0.318309886f, CrossPlatformMachineEpsilon)]          // expected: -(1 / pi)
-        [InlineData(-0.0f,                    float.NegativeInfinity, -3.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi)
-        [InlineData(-0.0f,                   -1.0f,                   -3.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi)
-        [InlineData(-0.0f,                   -0.0f,                   -3.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(pi)
-        [InlineData(-0.0f,                    float.NaN,               float.NaN,    0.0f)]
-        [InlineData(-0.0f,                    0.0f,                   -0.0f,         0.0f)]
-        [InlineData(-0.0f,                    1.0f,                   -0.0f,         0.0f)]
-        [InlineData(-0.0f,                    float.PositiveInfinity, -0.0f,         0.0f)]
-        [InlineData( float.NaN,               float.NegativeInfinity,  float.NaN,    0.0f)]
-        [InlineData( float.NaN,              -1.0f,                    float.NaN,    0.0f)]
-        [InlineData( float.NaN,              -0.0f,                    float.NaN,    0.0f)]
-        [InlineData( float.NaN,               float.NaN,               float.NaN,    0.0f)]
-        [InlineData( float.NaN,               0.0f,                    float.NaN,    0.0f)]
-        [InlineData( float.NaN,               1.0f,                    float.NaN,    0.0f)]
-        [InlineData( float.NaN,               float.PositiveInfinity,  float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  3.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi)
-        [InlineData( 0.0f,                   -1.0f,                    3.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi)
-        [InlineData( 0.0f,                   -0.0f,                    3.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi)
-        [InlineData( 0.0f,                    float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    0.0f,                    0.0f,         0.0f)]
-        [InlineData( 0.0f,                    1.0f,                    0.0f,         0.0f)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  0.0f,         0.0f)]
-        [InlineData( 0.312961796f,           -0.949765715f,            2.82328277f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (1 / pi))
-        [InlineData( 0.312961796f,            0.949765715f,            0.318309886f, CrossPlatformMachineEpsilon)]          // expected:  (1 / pi)
-        [InlineData( 0.410781291f,           -0.911733915f,            2.71828183f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (e)
-        [InlineData( 0.410781291f,            0.911733915f,            0.423310825f, CrossPlatformMachineEpsilon)]          // expected:  (pi - e)
-        [InlineData( 0.420770483f,           -0.907167129f,            2.70729817f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - log10(e))
-        [InlineData( 0.420770483f,            0.907167129f,            0.434294482f, CrossPlatformMachineEpsilon)]          // expected:  (log10(e))
-        [InlineData( 0.594480769f,           -0.804109828f,            2.50497288f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (2 / pi))
-        [InlineData( 0.594480769f,            0.804109828f,            0.636619772f, CrossPlatformMachineEpsilon)]          // expected:  (2 / pi)
-        [InlineData( 0.638961276f,           -0.769238901f,            2.44844547f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - ln(2))
-        [InlineData( 0.638961276f,            0.769238901f,            0.693147181f, CrossPlatformMachineEpsilon)]          // expected:  (ln(2))
-        [InlineData( 0.649636939f,           -0.760244597f,            2.43448587f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (1 / sqrt(2))
-        [InlineData( 0.649636939f,            0.760244597f,            0.707106781f, CrossPlatformMachineEpsilon)]          // expected:  (1 / sqrt(2))
-        [InlineData( 0.707106781f,           -0.707106781f,            2.35619449f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (3 * pi / 4),         y:  (1 / sqrt(2))   x: -(1 / sqrt(2))
-        [InlineData( 0.707106781f,            0.707106781f,            0.785398163f, CrossPlatformMachineEpsilon)]          // expected:  (pi / 4),             y:  (1 / sqrt(2))   x:  (1 / sqrt(2))
-        [InlineData( 0.743980337f,           -0.668201510f,            2.30258509f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (ln(10))
-        [InlineData( 0.743980337f,            0.668201510f,            0.839007561f, CrossPlatformMachineEpsilon)]          // expected:  (pi - ln(10))
-        [InlineData( 0.841470985f,           -0.540302306f,            2.14159265f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - 1)
-        [InlineData( 0.841470985f,            0.540302306f,            1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.903719457f,           -0.428125148f,            2.01321349f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (2 / sqrt(pi))
-        [InlineData( 0.903719457f,            0.428125148f,            1.12837917f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (2 / sqrt(pi))
-        [InlineData( 0.987765946f,           -0.155943695f,            1.72737909f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - sqrt(2))
-        [InlineData( 0.987765946f,            0.155943695f,            1.41421356f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (sqrt(2))
-        [InlineData( 0.991806244f,           -0.127751218f,            1.69889761f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - log2(e))
-        [InlineData( 0.991806244f,            0.127751218f,            1.44269504f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (log2(e))
-        [InlineData( 1.0f,                   -1.0f,                    2.35619449f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (3 * pi / 4)
-        [InlineData( 1.0f,                   -0.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
-        [InlineData( 1.0f,                    float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 1.0f,                    0.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
-        [InlineData( 1.0f,                    1.0f,                    0.785398163f, CrossPlatformMachineEpsilon)]          // expected:  (pi / 4)
-        [InlineData( 1.0f,                    float.PositiveInfinity,  0.0f,         0.0f)]
-        [InlineData( float.PositiveInfinity, -1.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
-        [InlineData( float.PositiveInfinity, -0.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
-        [InlineData( float.PositiveInfinity,  float.NaN,               float.NaN,    0.0f)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
-        [InlineData( float.PositiveInfinity,  1.0f,                    1.57079633f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
+        [InlineData(float.NegativeInfinity, -1.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
+        [InlineData(float.NegativeInfinity, -0.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
+        [InlineData(float.NegativeInfinity, float.NaN, float.NaN, 0.0f)]
+        [InlineData(float.NegativeInfinity, 0.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
+        [InlineData(float.NegativeInfinity, 1.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
+        [InlineData(-1.0f, -1.0f, -2.35619449f, CrossPlatformMachineEpsilon * 10)]     // expected: -(3 * pi / 4)
+        [InlineData(-1.0f, -0.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
+        [InlineData(-1.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(-1.0f, 0.0f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi / 2)
+        [InlineData(-1.0f, 1.0f, -0.785398163f, CrossPlatformMachineEpsilon)]          // expected: -(pi / 4)
+        [InlineData(-1.0f, float.PositiveInfinity, -0.0f, 0.0f)]
+        [InlineData(-0.991806244f, -0.127751218f, -1.69889761f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - log2(e))
+        [InlineData(-0.991806244f, 0.127751218f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]     // expected: -(log2(e))
+        [InlineData(-0.987765946f, -0.155943695f, -1.72737909f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - sqrt(2))
+        [InlineData(-0.987765946f, 0.155943695f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]     // expected: -(sqrt(2))
+        [InlineData(-0.903719457f, -0.428125148f, -2.01321349f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (2 / sqrt(pi))
+        [InlineData(-0.903719457f, 0.428125148f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]     // expected: -(2 / sqrt(pi)
+        [InlineData(-0.841470985f, -0.540302306f, -2.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - 1)
+        [InlineData(-0.841470985f, 0.540302306f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.743980337f, -0.668201510f, -2.30258509f, CrossPlatformMachineEpsilon * 10)]     // expected: -(ln(10))
+        [InlineData(-0.743980337f, 0.668201510f, -0.839007561f, CrossPlatformMachineEpsilon)]          // expected: -(pi - ln(10))
+        [InlineData(-0.707106781f, -0.707106781f, -2.35619449f, CrossPlatformMachineEpsilon * 10)]     // expected: -(3 * pi / 4),         y: -(1 / sqrt(2))   x: -(1 / sqrt(2))
+        [InlineData(-0.707106781f, 0.707106781f, -0.785398163f, CrossPlatformMachineEpsilon)]          // expected: -(pi / 4),             y: -(1 / sqrt(2))   x:  (1 / sqrt(2))
+        [InlineData(-0.649636939f, -0.760244597f, -2.43448587f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (1 / sqrt(2))
+        [InlineData(-0.649636939f, 0.760244597f, -0.707106781f, CrossPlatformMachineEpsilon)]          // expected: -(1 / sqrt(2))
+        [InlineData(-0.638961276f, -0.769238901f, -2.44844547f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - ln(2))
+        [InlineData(-0.638961276f, 0.769238901f, -0.693147181f, CrossPlatformMachineEpsilon)]          // expected: -(ln(2))
+        [InlineData(-0.594480769f, -0.804109828f, -2.50497288f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (2 / pi))
+        [InlineData(-0.594480769f, 0.804109828f, -0.636619772f, CrossPlatformMachineEpsilon)]          // expected: -(2 / pi)
+        [InlineData(-0.420770483f, -0.907167129f, -2.70729817f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - log10(e))
+        [InlineData(-0.420770483f, 0.907167129f, -0.434294482f, CrossPlatformMachineEpsilon)]          // expected: -(log10(e))
+        [InlineData(-0.410781291f, -0.911733915f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]     // expected: -(e)
+        [InlineData(-0.410781291f, 0.911733915f, -0.423310825f, CrossPlatformMachineEpsilon)]          // expected: -(pi - e)
+        [InlineData(-0.312961796f, -0.949765715f, -2.82328277f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi - (1 / pi))
+        [InlineData(-0.312961796f, 0.949765715f, -0.318309886f, CrossPlatformMachineEpsilon)]          // expected: -(1 / pi)
+        [InlineData(-0.0f, float.NegativeInfinity, -3.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi)
+        [InlineData(-0.0f, -1.0f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi)
+        [InlineData(-0.0f, -0.0f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected: -(pi)
+        [InlineData(-0.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(-0.0f, 0.0f, -0.0f, 0.0f)]
+        [InlineData(-0.0f, 1.0f, -0.0f, 0.0f)]
+        [InlineData(-0.0f, float.PositiveInfinity, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(float.NaN, -1.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, -0.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, float.NaN, float.NaN, 0.0f)]
+        [InlineData(float.NaN, 0.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, 1.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, float.PositiveInfinity, float.NaN, 0.0f)]
+        [InlineData(0.0f, float.NegativeInfinity, 3.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi)
+        [InlineData(0.0f, -1.0f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi)
+        [InlineData(0.0f, -0.0f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi)
+        [InlineData(0.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f, 0.0f)]
+        [InlineData(0.0f, 1.0f, 0.0f, 0.0f)]
+        [InlineData(0.0f, float.PositiveInfinity, 0.0f, 0.0f)]
+        [InlineData(0.312961796f, -0.949765715f, 2.82328277f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (1 / pi))
+        [InlineData(0.312961796f, 0.949765715f, 0.318309886f, CrossPlatformMachineEpsilon)]          // expected:  (1 / pi)
+        [InlineData(0.410781291f, -0.911733915f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]     // expected:  (e)
+        [InlineData(0.410781291f, 0.911733915f, 0.423310825f, CrossPlatformMachineEpsilon)]          // expected:  (pi - e)
+        [InlineData(0.420770483f, -0.907167129f, 2.70729817f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - log10(e))
+        [InlineData(0.420770483f, 0.907167129f, 0.434294482f, CrossPlatformMachineEpsilon)]          // expected:  (log10(e))
+        [InlineData(0.594480769f, -0.804109828f, 2.50497288f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (2 / pi))
+        [InlineData(0.594480769f, 0.804109828f, 0.636619772f, CrossPlatformMachineEpsilon)]          // expected:  (2 / pi)
+        [InlineData(0.638961276f, -0.769238901f, 2.44844547f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - ln(2))
+        [InlineData(0.638961276f, 0.769238901f, 0.693147181f, CrossPlatformMachineEpsilon)]          // expected:  (ln(2))
+        [InlineData(0.649636939f, -0.760244597f, 2.43448587f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (1 / sqrt(2))
+        [InlineData(0.649636939f, 0.760244597f, 0.707106781f, CrossPlatformMachineEpsilon)]          // expected:  (1 / sqrt(2))
+        [InlineData(0.707106781f, -0.707106781f, 2.35619449f, CrossPlatformMachineEpsilon * 10)]     // expected:  (3 * pi / 4),         y:  (1 / sqrt(2))   x: -(1 / sqrt(2))
+        [InlineData(0.707106781f, 0.707106781f, 0.785398163f, CrossPlatformMachineEpsilon)]          // expected:  (pi / 4),             y:  (1 / sqrt(2))   x:  (1 / sqrt(2))
+        [InlineData(0.743980337f, -0.668201510f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]     // expected:  (ln(10))
+        [InlineData(0.743980337f, 0.668201510f, 0.839007561f, CrossPlatformMachineEpsilon)]          // expected:  (pi - ln(10))
+        [InlineData(0.841470985f, -0.540302306f, 2.14159265f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - 1)
+        [InlineData(0.841470985f, 0.540302306f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.903719457f, -0.428125148f, 2.01321349f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - (2 / sqrt(pi))
+        [InlineData(0.903719457f, 0.428125148f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]     // expected:  (2 / sqrt(pi))
+        [InlineData(0.987765946f, -0.155943695f, 1.72737909f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - sqrt(2))
+        [InlineData(0.987765946f, 0.155943695f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]     // expected:  (sqrt(2))
+        [InlineData(0.991806244f, -0.127751218f, 1.69889761f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi - log2(e))
+        [InlineData(0.991806244f, 0.127751218f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]     // expected:  (log2(e))
+        [InlineData(1.0f, -1.0f, 2.35619449f, CrossPlatformMachineEpsilon * 10)]     // expected:  (3 * pi / 4)
+        [InlineData(1.0f, -0.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
+        [InlineData(1.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(1.0f, 0.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
+        [InlineData(1.0f, 1.0f, 0.785398163f, CrossPlatformMachineEpsilon)]          // expected:  (pi / 4)
+        [InlineData(1.0f, float.PositiveInfinity, 0.0f, 0.0f)]
+        [InlineData(float.PositiveInfinity, -1.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
+        [InlineData(float.PositiveInfinity, -0.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
+        [InlineData(float.PositiveInfinity, float.NaN, float.NaN, 0.0f)]
+        [InlineData(float.PositiveInfinity, 0.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
+        [InlineData(float.PositiveInfinity, 1.0f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]     // expected:  (pi / 2)
         public static void Atan2(float y, float x, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Atan2(y, x), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, float.NegativeInfinity, -2.35619449f,  CrossPlatformMachineEpsilon * 10)]     // expected: -(3 * pi / 4)
-        [InlineData( float.NegativeInfinity, float.PositiveInfinity, -0.785398163f, CrossPlatformMachineEpsilon)]          // expected: -(pi / 4)
-        [InlineData( float.PositiveInfinity, float.NegativeInfinity,  2.35619449f,  CrossPlatformMachineEpsilon * 10)]     // expected:  (3 * pi / 4
-        [InlineData( float.PositiveInfinity, float.PositiveInfinity,  0.785398163f, CrossPlatformMachineEpsilon)]          // expected:  (pi / 4)
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, -2.35619449f, CrossPlatformMachineEpsilon * 10)]     // expected: -(3 * pi / 4)
+        [InlineData(float.NegativeInfinity, float.PositiveInfinity, -0.785398163f, CrossPlatformMachineEpsilon)]          // expected: -(pi / 4)
+        [InlineData(float.PositiveInfinity, float.NegativeInfinity, 2.35619449f, CrossPlatformMachineEpsilon * 10)]     // expected:  (3 * pi / 4
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.785398163f, CrossPlatformMachineEpsilon)]          // expected:  (pi / 4)
         public static void Atan2_IEEE(float y, float x, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Atan2(y, x), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-3.14159265f,             float.NaN,              0.0f)]                              //                                value: -(pi)
-        [InlineData(-2.71828183f,             float.NaN,              0.0f)]                              //                                value: -(e)
-        [InlineData(-1.41421356f,             float.NaN,              0.0f)]                              //                                value: -(sqrt(2))
-        [InlineData(-1.0f,                    float.NegativeInfinity, CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.996272076f,           -3.14159265f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(pi)
-        [InlineData(-0.991328916f,           -2.71828183f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(e)
-        [InlineData(-0.980198020f,           -2.30258509f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(ln(10))
-        [InlineData(-0.917152336f,           -1.57079633f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
-        [InlineData(-0.894238946f,           -1.44269504f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
-        [InlineData(-0.888385562f,           -1.41421356f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
-        [InlineData(-0.810463806f,           -1.12837917f,            CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
-        [InlineData(-0.761594156f,           -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.655794203f,           -0.785398163f,           CrossPlatformMachineEpsilon)]       // expected: -(pi / 4)
-        [InlineData(-0.608859365f,           -0.707106781f,           CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
-        [InlineData(-0.6f,                   -0.693147181f,           CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
-        [InlineData(-0.562593600f,           -0.636619772f,           CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
-        [InlineData(-0.408904012f,           -0.434294482f,           CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
-        [InlineData(-0.307977913f,           -0.318309886f,           CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,                   0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0,                     0.0f,                   0.0f)]
-        [InlineData( 0.307977913f,            0.318309886f,           CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
-        [InlineData( 0.408904012f,            0.434294482f,           CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
-        [InlineData( 0.562593600f,            0.636619772f,           CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
-        [InlineData( 0.6f,                    0.693147181f,           CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
-        [InlineData( 0.608859365f,            0.707106781f,           CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
-        [InlineData( 0.655794203f,            0.785398163f,           CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
-        [InlineData( 0.761594156f,            1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.810463806f,            1.12837917f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
-        [InlineData( 0.888385562f,            1.41421356f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
-        [InlineData( 0.894238946f,            1.44269504f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
-        [InlineData( 0.917152336f,            1.57079633f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
-        [InlineData( 0.980198020f,            2.30258509f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (ln(10))
-        [InlineData( 0.991328916f,            2.71828183f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (e)
-        [InlineData( 0.996272076f,            3.14159265f,            CrossPlatformMachineEpsilon * 10)]  // expected:  (pi)
-        [InlineData( 1.0f,                    float.PositiveInfinity, 0.0f)]
-        [InlineData( 3.14159265f,             float.NaN,              0.0f)]                              //                                value:  (pi)
-        [InlineData( 2.71828183f,             float.NaN,              0.0f)]                              //                                value:  (e)
-        [InlineData( 1.41421356f,             float.NaN,              0.0f)]                              //                                value:  (sqrt(2))
-        [InlineData( float.PositiveInfinity,  float.NaN,              0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                              //                                value: -(pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                              //                                value: -(e)
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                              //                                value: -(sqrt(2))
+        [InlineData(-1.0f, float.NegativeInfinity, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.996272076f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]  // expected: -(pi)
+        [InlineData(-0.991328916f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]  // expected: -(e)
+        [InlineData(-0.980198020f, -2.30258509f, CrossPlatformMachineEpsilon * 10)]  // expected: -(ln(10))
+        [InlineData(-0.917152336f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected: -(pi / 2)
+        [InlineData(-0.894238946f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected: -(log2(e))
+        [InlineData(-0.888385562f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected: -(sqrt(2))
+        [InlineData(-0.810463806f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected: -(2 / sqrt(pi))
+        [InlineData(-0.761594156f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.655794203f, -0.785398163f, CrossPlatformMachineEpsilon)]       // expected: -(pi / 4)
+        [InlineData(-0.608859365f, -0.707106781f, CrossPlatformMachineEpsilon)]       // expected: -(1 / sqrt(2))
+        [InlineData(-0.6f, -0.693147181f, CrossPlatformMachineEpsilon)]       // expected: -(ln(2))
+        [InlineData(-0.562593600f, -0.636619772f, CrossPlatformMachineEpsilon)]       // expected: -(2 / pi)
+        [InlineData(-0.408904012f, -0.434294482f, CrossPlatformMachineEpsilon)]       // expected: -(log10(e))
+        [InlineData(-0.307977913f, -0.318309886f, CrossPlatformMachineEpsilon)]       // expected: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0, 0.0f, 0.0f)]
+        [InlineData(0.307977913f, 0.318309886f, CrossPlatformMachineEpsilon)]       // expected:  (1 / pi)
+        [InlineData(0.408904012f, 0.434294482f, CrossPlatformMachineEpsilon)]       // expected:  (log10(e))
+        [InlineData(0.562593600f, 0.636619772f, CrossPlatformMachineEpsilon)]       // expected:  (2 / pi)
+        [InlineData(0.6f, 0.693147181f, CrossPlatformMachineEpsilon)]       // expected:  (ln(2))
+        [InlineData(0.608859365f, 0.707106781f, CrossPlatformMachineEpsilon)]       // expected:  (1 / sqrt(2))
+        [InlineData(0.655794203f, 0.785398163f, CrossPlatformMachineEpsilon)]       // expected:  (pi / 4)
+        [InlineData(0.761594156f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.810463806f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]  // expected:  (2 / sqrt(pi))
+        [InlineData(0.888385562f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]  // expected:  (sqrt(2))
+        [InlineData(0.894238946f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]  // expected:  (log2(e))
+        [InlineData(0.917152336f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi / 2)
+        [InlineData(0.980198020f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]  // expected:  (ln(10))
+        [InlineData(0.991328916f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]  // expected:  (e)
+        [InlineData(0.996272076f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]  // expected:  (pi)
+        [InlineData(1.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(3.14159265f, float.NaN, 0.0f)]                              //                                value:  (pi)
+        [InlineData(2.71828183f, float.NaN, 0.0f)]                              //                                value:  (e)
+        [InlineData(1.41421356f, float.NaN, 0.0f)]                              //                                value:  (sqrt(2))
+        [InlineData(float.PositiveInfinity, float.NaN, 0.0f)]
         public static void Atanh(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Atanh(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NegativeInfinity)]
-        [InlineData(-3.14159265f,            -3.14159298f)]     // value: -(pi)
-        [InlineData(-2.71828183f,            -2.71828198f)]     // value: -(e)
-        [InlineData(-2.30258509f,            -2.30258536f)]     // value: -(ln(10))
-        [InlineData(-1.57079633f,            -1.57079649f)]     // value: -(pi / 2)
-        [InlineData(-1.44269504f,            -1.44269514f)]     // value: -(log2(e))
-        [InlineData(-1.41421356f,            -1.41421366f)]     // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            -1.12837934f)]     // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   -1.00000012f)]
-        [InlineData(-0.785398163f,           -0.785398245f)]    // value: -(pi / 4)
-        [InlineData(-0.707106781f,           -0.707106829f)]    // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           -0.693147242f)]    // value: -(ln(2))
-        [InlineData(-0.636619772f,           -0.636619806f)]    // value: -(2 / pi)
-        [InlineData(-0.434294482f,           -0.434294522f)]    // value: -(log10(e))
-        [InlineData(-0.318309886f,           -0.318309903f)]    // value: -(1 / pi)
-        [InlineData(-0.0f,                   -float.Epsilon)]
-        [InlineData( float.NaN,               float.NaN)]
-        [InlineData( 0.0f,                   -float.Epsilon)]
-        [InlineData( 0.318309886f,            0.318309844f)]    // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.434294462f)]    // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.636619687f)]    // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.693147123f)]    // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.707106709f)]    // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.785398126f)]    // value:  (pi / 4)
-        [InlineData( 1.0f,                    0.999999940f)]
-        [InlineData( 1.12837917f,             1.12837911f)]     // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             1.41421342f)]     // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             1.44269490f)]     // value:  (log2(e))
-        [InlineData( 1.57079633f,             1.57079625f)]     // value:  (pi / 2)
-        [InlineData( 2.30258509f,             2.30258489f)]     // value:  (ln(10))
-        [InlineData( 2.71828183f,             2.71828151f)]     // value:  (e)
-        [InlineData( 3.14159265f,             3.14159250f)]     // value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.MaxValue)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity)]
+        [InlineData(-3.14159265f, -3.14159298f)]     // value: -(pi)
+        [InlineData(-2.71828183f, -2.71828198f)]     // value: -(e)
+        [InlineData(-2.30258509f, -2.30258536f)]     // value: -(ln(10))
+        [InlineData(-1.57079633f, -1.57079649f)]     // value: -(pi / 2)
+        [InlineData(-1.44269504f, -1.44269514f)]     // value: -(log2(e))
+        [InlineData(-1.41421356f, -1.41421366f)]     // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -1.12837934f)]     // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -1.00000012f)]
+        [InlineData(-0.785398163f, -0.785398245f)]    // value: -(pi / 4)
+        [InlineData(-0.707106781f, -0.707106829f)]    // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.693147242f)]    // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.636619806f)]    // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.434294522f)]    // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.318309903f)]    // value: -(1 / pi)
+        [InlineData(-0.0f, -float.Epsilon)]
+        [InlineData(float.NaN, float.NaN)]
+        [InlineData(0.0f, -float.Epsilon)]
+        [InlineData(0.318309886f, 0.318309844f)]    // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.434294462f)]    // value:  (log10(e))
+        [InlineData(0.636619772f, 0.636619687f)]    // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.693147123f)]    // value:  (ln(2))
+        [InlineData(0.707106781f, 0.707106709f)]    // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.785398126f)]    // value:  (pi / 4)
+        [InlineData(1.0f, 0.999999940f)]
+        [InlineData(1.12837917f, 1.12837911f)]     // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 1.41421342f)]     // value:  (sqrt(2))
+        [InlineData(1.44269504f, 1.44269490f)]     // value:  (log2(e))
+        [InlineData(1.57079633f, 1.57079625f)]     // value:  (pi / 2)
+        [InlineData(2.30258509f, 2.30258489f)]     // value:  (ln(10))
+        [InlineData(2.71828183f, 2.71828151f)]     // value:  (e)
+        [InlineData(3.14159265f, 3.14159250f)]     // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.MaxValue)]
         public static void BitDecrement(float value, float expectedResult)
         {
             AssertEqual(expectedResult, MathF.BitDecrement(value), 0.0f);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.MinValue)]
-        [InlineData(-3.14159265f,            -3.14159250f)]     // value: -(pi)
-        [InlineData(-2.71828183f,            -2.71828151f)]     // value: -(e)
-        [InlineData(-2.30258509f,            -2.30258489f)]     // value: -(ln(10))
-        [InlineData(-1.57079633f,            -1.57079625f)]     // value: -(pi / 2)
-        [InlineData(-1.44269504f,            -1.44269490f)]     // value: -(log2(e))
-        [InlineData(-1.41421356f,            -1.41421342f)]     // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            -1.12837911f)]     // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   -0.999999940f)]
-        [InlineData(-0.785398163f,           -0.785398126f)]    // value: -(pi / 4)
-        [InlineData(-0.707106781f,           -0.707106709f)]    // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           -0.693147123f)]    // value: -(ln(2))
-        [InlineData(-0.636619772f,           -0.636619687f)]    // value: -(2 / pi)
-        [InlineData(-0.434294482f,           -0.434294462f)]    // value: -(log10(e))
-        [InlineData(-0.318309886f,           -0.318309844f)]    // value: -(1 / pi)
-        [InlineData(-0.0f,                    float.Epsilon)]
-        [InlineData( float.NaN,               float.NaN)]
-        [InlineData( 0.0f,                    float.Epsilon)]
-        [InlineData( 0.318309886f,            0.318309903f)]    // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.434294522f)]    // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.636619806f)]    // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.693147242f)]    // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.707106829f)]    // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.785398245f)]    // value:  (pi / 4)
-        [InlineData( 1.0f,                    1.00000012f)]
-        [InlineData( 1.12837917f,             1.12837934f)]     // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             1.41421366f)]     // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             1.44269514f)]     // value:  (log2(e))
-        [InlineData( 1.57079633f,             1.57079649f)]     // value:  (pi / 2)
-        [InlineData( 2.30258509f,             2.30258536f)]     // value:  (ln(10))
-        [InlineData( 2.71828183f,             2.71828198f)]     // value:  (e)
-        [InlineData( 3.14159265f,             3.14159298f)]     // value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity)]
+        [InlineData(float.NegativeInfinity, float.MinValue)]
+        [InlineData(-3.14159265f, -3.14159250f)]     // value: -(pi)
+        [InlineData(-2.71828183f, -2.71828151f)]     // value: -(e)
+        [InlineData(-2.30258509f, -2.30258489f)]     // value: -(ln(10))
+        [InlineData(-1.57079633f, -1.57079625f)]     // value: -(pi / 2)
+        [InlineData(-1.44269504f, -1.44269490f)]     // value: -(log2(e))
+        [InlineData(-1.41421356f, -1.41421342f)]     // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -1.12837911f)]     // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -0.999999940f)]
+        [InlineData(-0.785398163f, -0.785398126f)]    // value: -(pi / 4)
+        [InlineData(-0.707106781f, -0.707106709f)]    // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.693147123f)]    // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.636619687f)]    // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.434294462f)]    // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.318309844f)]    // value: -(1 / pi)
+        [InlineData(-0.0f, float.Epsilon)]
+        [InlineData(float.NaN, float.NaN)]
+        [InlineData(0.0f, float.Epsilon)]
+        [InlineData(0.318309886f, 0.318309903f)]    // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.434294522f)]    // value:  (log10(e))
+        [InlineData(0.636619772f, 0.636619806f)]    // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.693147242f)]    // value:  (ln(2))
+        [InlineData(0.707106781f, 0.707106829f)]    // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.785398245f)]    // value:  (pi / 4)
+        [InlineData(1.0f, 1.00000012f)]
+        [InlineData(1.12837917f, 1.12837934f)]     // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 1.41421366f)]     // value:  (sqrt(2))
+        [InlineData(1.44269504f, 1.44269514f)]     // value:  (log2(e))
+        [InlineData(1.57079633f, 1.57079649f)]     // value:  (pi / 2)
+        [InlineData(2.30258509f, 2.30258536f)]     // value:  (ln(10))
+        [InlineData(2.71828183f, 2.71828198f)]     // value:  (e)
+        [InlineData(3.14159265f, 3.14159298f)]     // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity)]
         public static void BitIncrement(float value, float expectedResult)
         {
             AssertEqual(expectedResult, MathF.BitIncrement(value), 0.0f);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NegativeInfinity, 0.0f)]
-        [InlineData(-3.14159265f,            -1.46459189f,            CrossPlatformMachineEpsilon * 10)]   // value: -(pi)
-        [InlineData(-2.71828183f,            -1.39561243f,            CrossPlatformMachineEpsilon * 10)]   // value: -(e)
-        [InlineData(-2.30258509f,            -1.32050048f,            CrossPlatformMachineEpsilon * 10)]   // value: -(ln(10))
-        [InlineData(-1.57079633f,            -1.16244735f,            CrossPlatformMachineEpsilon * 10)]   // value: -(pi / 2)
-        [InlineData(-1.44269504f,            -1.12994728f,            CrossPlatformMachineEpsilon * 10)]   // value: -(log2(e))
-        [InlineData(-1.41421356f,            -1.12246205f,            CrossPlatformMachineEpsilon * 10)]   // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            -1.04108220f,            CrossPlatformMachineEpsilon * 10)]   // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.785398163f,           -0.922635074f,           CrossPlatformMachineEpsilon)]        // value: -(pi / 4)
-        [InlineData(-0.707106781f,           -0.890898718f,           CrossPlatformMachineEpsilon)]        // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           -0.884997045f,           CrossPlatformMachineEpsilon)]        // value: -(ln(2))
-        [InlineData(-0.636619772f,           -0.860254014f,           CrossPlatformMachineEpsilon)]        // value: -(2 / pi)
-        [InlineData(-0.434294482f,           -0.757288631f,           CrossPlatformMachineEpsilon)]        // value: -(log10(e))
-        [InlineData(-0.318309886f,           -0.682784063f,           CrossPlatformMachineEpsilon)]        // value: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,                   0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    0.0f,                   0.0f)]
-        [InlineData( 0.318309886f,            0.682784063f,           CrossPlatformMachineEpsilon)]        // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.757288631f,           CrossPlatformMachineEpsilon)]        // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.860254014f,           CrossPlatformMachineEpsilon)]        // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.884997045f,           CrossPlatformMachineEpsilon)]        // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.890898718f,           CrossPlatformMachineEpsilon)]        // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.922635074f,           CrossPlatformMachineEpsilon)]        // value:  (pi / 4)
-        [InlineData( 1.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.12837917f,             1.04108220f,            CrossPlatformMachineEpsilon * 10)]   // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             1.12246205f,            CrossPlatformMachineEpsilon * 10)]   // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             1.12994728f,            CrossPlatformMachineEpsilon * 10)]   // value:  (log2(e))
-        [InlineData( 1.57079633f,             1.16244735f,            CrossPlatformMachineEpsilon * 10)]   // value:  (pi / 2)
-        [InlineData( 2.30258509f,             1.32050048f,            CrossPlatformMachineEpsilon * 10)]   // value:  (ln(10))
-        [InlineData( 2.71828183f,             1.39561243f,            CrossPlatformMachineEpsilon * 10)]   // value:  (e)
-        [InlineData( 3.14159265f,             1.46459189f,            CrossPlatformMachineEpsilon * 10)]   // value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, 0.0f)]
+        [InlineData(-3.14159265f, -1.46459189f, CrossPlatformMachineEpsilon * 10)]   // value: -(pi)
+        [InlineData(-2.71828183f, -1.39561243f, CrossPlatformMachineEpsilon * 10)]   // value: -(e)
+        [InlineData(-2.30258509f, -1.32050048f, CrossPlatformMachineEpsilon * 10)]   // value: -(ln(10))
+        [InlineData(-1.57079633f, -1.16244735f, CrossPlatformMachineEpsilon * 10)]   // value: -(pi / 2)
+        [InlineData(-1.44269504f, -1.12994728f, CrossPlatformMachineEpsilon * 10)]   // value: -(log2(e))
+        [InlineData(-1.41421356f, -1.12246205f, CrossPlatformMachineEpsilon * 10)]   // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -1.04108220f, CrossPlatformMachineEpsilon * 10)]   // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.785398163f, -0.922635074f, CrossPlatformMachineEpsilon)]        // value: -(pi / 4)
+        [InlineData(-0.707106781f, -0.890898718f, CrossPlatformMachineEpsilon)]        // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.884997045f, CrossPlatformMachineEpsilon)]        // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.860254014f, CrossPlatformMachineEpsilon)]        // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.757288631f, CrossPlatformMachineEpsilon)]        // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.682784063f, CrossPlatformMachineEpsilon)]        // value: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.682784063f, CrossPlatformMachineEpsilon)]        // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.757288631f, CrossPlatformMachineEpsilon)]        // value:  (log10(e))
+        [InlineData(0.636619772f, 0.860254014f, CrossPlatformMachineEpsilon)]        // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.884997045f, CrossPlatformMachineEpsilon)]        // value:  (ln(2))
+        [InlineData(0.707106781f, 0.890898718f, CrossPlatformMachineEpsilon)]        // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.922635074f, CrossPlatformMachineEpsilon)]        // value:  (pi / 4)
+        [InlineData(1.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.12837917f, 1.04108220f, CrossPlatformMachineEpsilon * 10)]   // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 1.12246205f, CrossPlatformMachineEpsilon * 10)]   // value:  (sqrt(2))
+        [InlineData(1.44269504f, 1.12994728f, CrossPlatformMachineEpsilon * 10)]   // value:  (log2(e))
+        [InlineData(1.57079633f, 1.16244735f, CrossPlatformMachineEpsilon * 10)]   // value:  (pi / 2)
+        [InlineData(2.30258509f, 1.32050048f, CrossPlatformMachineEpsilon * 10)]   // value:  (ln(10))
+        [InlineData(2.71828183f, 1.39561243f, CrossPlatformMachineEpsilon * 10)]   // value:  (e)
+        [InlineData(3.14159265f, 1.46459189f, CrossPlatformMachineEpsilon * 10)]   // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Cbrt(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Cbrt(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData(float.NegativeInfinity,  float.NegativeInfinity, 0.0f)]
-        [InlineData(-3.14159265f,           -3.0f,                   0.0f)]     // value: -(pi)
-        [InlineData(-2.71828183f,           -2.0f,                   0.0f)]     // value: -(e)
-        [InlineData(-2.30258509f,           -2.0f,                   0.0f)]     // value: -(ln(10))
-        [InlineData(-1.57079633f,           -1.0f,                   0.0f)]     // value: -(pi / 2)
-        [InlineData(-1.44269504f,           -1.0f,                   0.0f)]     // value: -(log2(e))
-        [InlineData(-1.41421356f,           -1.0f,                   0.0f)]     // value: -(sqrt(2))
-        [InlineData(-1.12837917f,           -1.0f,                   0.0f)]     // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                  -1.0f,                   0.0f)]
-        [InlineData(-0.785398163f,          -0.0f,                   0.0f)]  // value: -(pi / 4)
-        [InlineData(-0.707106781f,          -0.0f,                   0.0f)]  // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,          -0.0f,                   0.0f)]  // value: -(ln(2))
-        [InlineData(-0.636619772f,          -0.0f,                   0.0f)]  // value: -(2 / pi)
-        [InlineData(-0.434294482f,          -0.0f,                   0.0f)]  // value: -(log10(e))
-        [InlineData(-0.318309886f,          -0.0f,                   0.0f)]  // value: -(1 / pi)
-        [InlineData(-0.0f,                  -0.0f,                   0.0f)]
-        [InlineData( float.NaN,              float.NaN,              0.0f)]
-        [InlineData( 0.0f,                   0.0f,                   0.0f)]
-        [InlineData( 0.318309886f,           1.0f,                   0.0f)]     // value:  (1 / pi)
-        [InlineData( 0.434294482f,           1.0f,                   0.0f)]     // value:  (log10(e))
-        [InlineData( 0.636619772f,           1.0f,                   0.0f)]     // value:  (2 / pi)
-        [InlineData( 0.693147181f,           1.0f,                   0.0f)]     // value:  (ln(2))
-        [InlineData( 0.707106781f,           1.0f,                   0.0f)]     // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,           1.0f,                   0.0f)]     // value:  (pi / 4)
-        [InlineData( 1.0f,                   1.0f,                   0.0f)]
-        [InlineData( 1.12837917f,            2.0f,                   0.0f)]     // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,            2.0f,                   0.0f)]     // value:  (sqrt(2))
-        [InlineData( 1.44269504f,            2.0f,                   0.0f)]     // value:  (log2(e))
-        [InlineData( 1.57079633f,            2.0f,                   0.0f)]     // value:  (pi / 2)
-        [InlineData( 2.30258509f,            3.0f,                   0.0f)]     // value:  (ln(10))
-        [InlineData( 2.71828183f,            3.0f,                   0.0f)]     // value:  (e)
-        [InlineData( 3.14159265f,            4.0f,                   0.0f)]     // value:  (pi)
-        [InlineData(float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, 0.0f)]
+        [InlineData(-3.14159265f, -3.0f, 0.0f)]     // value: -(pi)
+        [InlineData(-2.71828183f, -2.0f, 0.0f)]     // value: -(e)
+        [InlineData(-2.30258509f, -2.0f, 0.0f)]     // value: -(ln(10))
+        [InlineData(-1.57079633f, -1.0f, 0.0f)]     // value: -(pi / 2)
+        [InlineData(-1.44269504f, -1.0f, 0.0f)]     // value: -(log2(e))
+        [InlineData(-1.41421356f, -1.0f, 0.0f)]     // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -1.0f, 0.0f)]     // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -1.0f, 0.0f)]
+        [InlineData(-0.785398163f, -0.0f, 0.0f)]  // value: -(pi / 4)
+        [InlineData(-0.707106781f, -0.0f, 0.0f)]  // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.0f, 0.0f)]  // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.0f, 0.0f)]  // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.0f, 0.0f)]  // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.0f, 0.0f)]  // value: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 1.0f, 0.0f)]     // value:  (1 / pi)
+        [InlineData(0.434294482f, 1.0f, 0.0f)]     // value:  (log10(e))
+        [InlineData(0.636619772f, 1.0f, 0.0f)]     // value:  (2 / pi)
+        [InlineData(0.693147181f, 1.0f, 0.0f)]     // value:  (ln(2))
+        [InlineData(0.707106781f, 1.0f, 0.0f)]     // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 1.0f, 0.0f)]     // value:  (pi / 4)
+        [InlineData(1.0f, 1.0f, 0.0f)]
+        [InlineData(1.12837917f, 2.0f, 0.0f)]     // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 2.0f, 0.0f)]     // value:  (sqrt(2))
+        [InlineData(1.44269504f, 2.0f, 0.0f)]     // value:  (log2(e))
+        [InlineData(1.57079633f, 2.0f, 0.0f)]     // value:  (pi / 2)
+        [InlineData(2.30258509f, 3.0f, 0.0f)]     // value:  (ln(10))
+        [InlineData(2.71828183f, 3.0f, 0.0f)]     // value:  (e)
+        [InlineData(3.14159265f, 4.0f, 0.0f)]     // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Ceiling(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Ceiling(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NegativeInfinity,  float.NegativeInfinity)]
-        [InlineData( float.NegativeInfinity, -3.14159265f,             float.NegativeInfinity)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    float.NegativeInfinity)]
-        [InlineData( float.NegativeInfinity,  float.NaN,               float.NegativeInfinity)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    float.PositiveInfinity)]
-        [InlineData( float.NegativeInfinity,  3.14159265f,             float.PositiveInfinity)]
-        [InlineData( float.NegativeInfinity,  float.PositiveInfinity,  float.PositiveInfinity)]
-        [InlineData(-3.14159265f,             float.NegativeInfinity, -3.14159265f)]
-        [InlineData(-3.14159265f,            -3.14159265f,            -3.14159265f)]
-        [InlineData(-3.14159265f,            -0.0f,                   -3.14159265f)]
-        [InlineData(-3.14159265f,             float.NaN,              -3.14159265f)]
-        [InlineData(-3.14159265f,             0.0f,                    3.14159265f)]
-        [InlineData(-3.14159265f,             3.14159265f,             3.14159265f)]
-        [InlineData(-3.14159265f,             float.PositiveInfinity,  3.14159265f)]
-        [InlineData(-0.0f,                    float.NegativeInfinity, -0.0f)]
-        [InlineData(-0.0f,                   -3.14159265f,            -0.0f)]
-        [InlineData(-0.0f,                   -0.0f,                   -0.0f)]
-        [InlineData(-0.0f,                    float.NaN,              -0.0f)]
-        [InlineData(-0.0f,                    0.0f,                    0.0f)]
-        [InlineData(-0.0f,                    3.14159265f,             0.0f)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  0.0f)]
-        [InlineData( float.NaN,               float.NegativeInfinity,  float.NaN)]
-        [InlineData( float.NaN,              -3.14159265f,             float.NaN)]
-        [InlineData( float.NaN,              -0.0f,                    float.NaN)]
-        [InlineData( float.NaN,               float.NaN,               float.NaN)]
-        [InlineData( float.NaN,               0.0f,                    float.NaN)]
-        [InlineData( float.NaN,               3.14159265f,             float.NaN)]
-        [InlineData( float.NaN,               float.PositiveInfinity,  float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity, -0.0f)]
-        [InlineData( 0.0f,                   -3.14159265f,            -0.0f)]
-        [InlineData( 0.0f,                   -0.0f,                   -0.0f)]
-        [InlineData( 0.0f,                    float.NaN,              -0.0f)]
-        [InlineData( 0.0f,                    0.0f,                    0.0f)]
-        [InlineData( 0.0f,                    3.14159265f,             0.0f)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  0.0f)]
-        [InlineData( 3.14159265f,             float.NegativeInfinity, -3.14159265f)]
-        [InlineData( 3.14159265f,            -3.14159265f,            -3.14159265f)]
-        [InlineData( 3.14159265f,            -0.0f,                   -3.14159265f)]
-        [InlineData( 3.14159265f,             float.NaN,              -3.14159265f)]
-        [InlineData( 3.14159265f,             0.0f,                    3.14159265f)]
-        [InlineData( 3.14159265f,             3.14159265f,             3.14159265f)]
-        [InlineData( 3.14159265f,             float.PositiveInfinity,  3.14159265f)]
-        [InlineData( float.PositiveInfinity,  float.NegativeInfinity,  float.NegativeInfinity)]
-        [InlineData( float.PositiveInfinity, -3.14159265f,             float.NegativeInfinity)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    float.NegativeInfinity)]
-        [InlineData( float.PositiveInfinity,  float.NaN,               float.NegativeInfinity)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    float.PositiveInfinity)]
-        [InlineData( float.PositiveInfinity,  3.14159265f,             float.PositiveInfinity)]
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity,  float.PositiveInfinity)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)]
+        [InlineData(float.NegativeInfinity, -3.14159265f, float.NegativeInfinity)]
+        [InlineData(float.NegativeInfinity, -0.0f, float.NegativeInfinity)]
+        [InlineData(float.NegativeInfinity, float.NaN, float.NegativeInfinity)]
+        [InlineData(float.NegativeInfinity, 0.0f, float.PositiveInfinity)]
+        [InlineData(float.NegativeInfinity, 3.14159265f, float.PositiveInfinity)]
+        [InlineData(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity)]
+        [InlineData(-3.14159265f, float.NegativeInfinity, -3.14159265f)]
+        [InlineData(-3.14159265f, -3.14159265f, -3.14159265f)]
+        [InlineData(-3.14159265f, -0.0f, -3.14159265f)]
+        [InlineData(-3.14159265f, float.NaN, -3.14159265f)]
+        [InlineData(-3.14159265f, 0.0f, 3.14159265f)]
+        [InlineData(-3.14159265f, 3.14159265f, 3.14159265f)]
+        [InlineData(-3.14159265f, float.PositiveInfinity, 3.14159265f)]
+        [InlineData(-0.0f, float.NegativeInfinity, -0.0f)]
+        [InlineData(-0.0f, -3.14159265f, -0.0f)]
+        [InlineData(-0.0f, -0.0f, -0.0f)]
+        [InlineData(-0.0f, float.NaN, -0.0f)]
+        [InlineData(-0.0f, 0.0f, 0.0f)]
+        [InlineData(-0.0f, 3.14159265f, 0.0f)]
+        [InlineData(-0.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NaN, float.NegativeInfinity, float.NaN)]
+        [InlineData(float.NaN, -3.14159265f, float.NaN)]
+        [InlineData(float.NaN, -0.0f, float.NaN)]
+        [InlineData(float.NaN, float.NaN, float.NaN)]
+        [InlineData(float.NaN, 0.0f, float.NaN)]
+        [InlineData(float.NaN, 3.14159265f, float.NaN)]
+        [InlineData(float.NaN, float.PositiveInfinity, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, -0.0f)]
+        [InlineData(0.0f, -3.14159265f, -0.0f)]
+        [InlineData(0.0f, -0.0f, -0.0f)]
+        [InlineData(0.0f, float.NaN, -0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.0f, 3.14159265f, 0.0f)]
+        [InlineData(0.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(3.14159265f, float.NegativeInfinity, -3.14159265f)]
+        [InlineData(3.14159265f, -3.14159265f, -3.14159265f)]
+        [InlineData(3.14159265f, -0.0f, -3.14159265f)]
+        [InlineData(3.14159265f, float.NaN, -3.14159265f)]
+        [InlineData(3.14159265f, 0.0f, 3.14159265f)]
+        [InlineData(3.14159265f, 3.14159265f, 3.14159265f)]
+        [InlineData(3.14159265f, float.PositiveInfinity, 3.14159265f)]
+        [InlineData(float.PositiveInfinity, float.NegativeInfinity, float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity, -3.14159265f, float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity, -0.0f, float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity, float.NaN, float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity, 0.0f, float.PositiveInfinity)]
+        [InlineData(float.PositiveInfinity, 3.14159265f, float.PositiveInfinity)]
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)]
         public static void CopySign(float x, float y, float expectedResult)
         {
             AssertEqual(expectedResult, MathF.CopySign(x, y), 0.0f);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,    0.0f)]
-        [InlineData(-3.14159265f,            -1.0f,         CrossPlatformMachineEpsilon * 10)]  // value: -(pi)
-        [InlineData(-2.71828183f,            -0.911733918f, CrossPlatformMachineEpsilon)]       // value: -(e)
-        [InlineData(-2.30258509f,            -0.668201510f, CrossPlatformMachineEpsilon)]       // value: -(ln(10))
-        [InlineData(-1.57079633f,             0.0f,         CrossPlatformMachineEpsilon)]       // value: -(pi / 2)
-        [InlineData(-1.44269504f,             0.127751218f, CrossPlatformMachineEpsilon)]       // value: -(log2(e))
-        [InlineData(-1.41421356f,             0.155943695f, CrossPlatformMachineEpsilon)]       // value: -(sqrt(2))
-        [InlineData(-1.12837917f,             0.428125148f, CrossPlatformMachineEpsilon)]       // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                    0.540302306f, CrossPlatformMachineEpsilon)]
-        [InlineData(-0.785398163f,            0.707106781f, CrossPlatformMachineEpsilon)]       // value: -(pi / 4),        expected:  (1 / sqrt(2))
-        [InlineData(-0.707106781f,            0.760244597f, CrossPlatformMachineEpsilon)]       // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,            0.769238901f, CrossPlatformMachineEpsilon)]       // value: -(ln(2))
-        [InlineData(-0.636619772f,            0.804109828f, CrossPlatformMachineEpsilon)]       // value: -(2 / pi)
-        [InlineData(-0.434294482f,            0.907167129f, CrossPlatformMachineEpsilon)]       // value: -(log10(e))
-        [InlineData(-0.318309886f,            0.949765715f, CrossPlatformMachineEpsilon)]       // value: -(1 / pi)
-        [InlineData(-0.0f,                    1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.318309886f,            0.949765715f, CrossPlatformMachineEpsilon)]       // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.907167129f, CrossPlatformMachineEpsilon)]       // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.804109828f, CrossPlatformMachineEpsilon)]       // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.769238901f, CrossPlatformMachineEpsilon)]       // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.760244597f, CrossPlatformMachineEpsilon)]       // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.707106781f, CrossPlatformMachineEpsilon)]       // value:  (pi / 4),        expected:  (1 / sqrt(2))
-        [InlineData( 1.0f,                    0.540302306f, CrossPlatformMachineEpsilon)]
-        [InlineData( 1.12837917f,             0.428125148f, CrossPlatformMachineEpsilon)]       // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             0.155943695f, CrossPlatformMachineEpsilon)]       // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             0.127751218f, CrossPlatformMachineEpsilon)]       // value:  (log2(e))
-        [InlineData( 1.57079633f,             0.0f,         CrossPlatformMachineEpsilon)]       // value:  (pi / 2)
-        [InlineData( 2.30258509f,            -0.668201510f, CrossPlatformMachineEpsilon)]       // value:  (ln(10))
-        [InlineData( 2.71828183f,            -0.911733918f, CrossPlatformMachineEpsilon)]       // value:  (e)
-        [InlineData( 3.14159265f,            -1.0f,         CrossPlatformMachineEpsilon * 10)]  // value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.NaN,    0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, -1.0f, CrossPlatformMachineEpsilon * 10)]  // value: -(pi)
+        [InlineData(-2.71828183f, -0.911733918f, CrossPlatformMachineEpsilon)]       // value: -(e)
+        [InlineData(-2.30258509f, -0.668201510f, CrossPlatformMachineEpsilon)]       // value: -(ln(10))
+        [InlineData(-1.57079633f, 0.0f, CrossPlatformMachineEpsilon)]       // value: -(pi / 2)
+        [InlineData(-1.44269504f, 0.127751218f, CrossPlatformMachineEpsilon)]       // value: -(log2(e))
+        [InlineData(-1.41421356f, 0.155943695f, CrossPlatformMachineEpsilon)]       // value: -(sqrt(2))
+        [InlineData(-1.12837917f, 0.428125148f, CrossPlatformMachineEpsilon)]       // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, 0.540302306f, CrossPlatformMachineEpsilon)]
+        [InlineData(-0.785398163f, 0.707106781f, CrossPlatformMachineEpsilon)]       // value: -(pi / 4),        expected:  (1 / sqrt(2))
+        [InlineData(-0.707106781f, 0.760244597f, CrossPlatformMachineEpsilon)]       // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, 0.769238901f, CrossPlatformMachineEpsilon)]       // value: -(ln(2))
+        [InlineData(-0.636619772f, 0.804109828f, CrossPlatformMachineEpsilon)]       // value: -(2 / pi)
+        [InlineData(-0.434294482f, 0.907167129f, CrossPlatformMachineEpsilon)]       // value: -(log10(e))
+        [InlineData(-0.318309886f, 0.949765715f, CrossPlatformMachineEpsilon)]       // value: -(1 / pi)
+        [InlineData(-0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.318309886f, 0.949765715f, CrossPlatformMachineEpsilon)]       // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.907167129f, CrossPlatformMachineEpsilon)]       // value:  (log10(e))
+        [InlineData(0.636619772f, 0.804109828f, CrossPlatformMachineEpsilon)]       // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.769238901f, CrossPlatformMachineEpsilon)]       // value:  (ln(2))
+        [InlineData(0.707106781f, 0.760244597f, CrossPlatformMachineEpsilon)]       // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.707106781f, CrossPlatformMachineEpsilon)]       // value:  (pi / 4),        expected:  (1 / sqrt(2))
+        [InlineData(1.0f, 0.540302306f, CrossPlatformMachineEpsilon)]
+        [InlineData(1.12837917f, 0.428125148f, CrossPlatformMachineEpsilon)]       // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 0.155943695f, CrossPlatformMachineEpsilon)]       // value:  (sqrt(2))
+        [InlineData(1.44269504f, 0.127751218f, CrossPlatformMachineEpsilon)]       // value:  (log2(e))
+        [InlineData(1.57079633f, 0.0f, CrossPlatformMachineEpsilon)]       // value:  (pi / 2)
+        [InlineData(2.30258509f, -0.668201510f, CrossPlatformMachineEpsilon)]       // value:  (ln(10))
+        [InlineData(2.71828183f, -0.911733918f, CrossPlatformMachineEpsilon)]       // value:  (e)
+        [InlineData(3.14159265f, -1.0f, CrossPlatformMachineEpsilon * 10)]  // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.NaN, 0.0f)]
         public static void Cos(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Cos(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, float.PositiveInfinity, 0.0f)]
-        [InlineData(-3.14159265f,            11.5919533f,            CrossPlatformMachineEpsilon * 100)]    // value:  (pi)
-        [InlineData(-2.71828183f,            7.61012514f,            CrossPlatformMachineEpsilon * 10)]     // value:  (e)
-        [InlineData(-2.30258509f,            5.05f,                  CrossPlatformMachineEpsilon * 10)]     // value:  (ln(10))
-        [InlineData(-1.57079633f,            2.50917848f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)
-        [InlineData(-1.44269504f,            2.23418810f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))
-        [InlineData(-1.41421356f,            2.17818356f,            CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))
-        [InlineData(-1.12837917f,            1.70710014f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))
-        [InlineData(-1.0f,                   1.54308063f,            CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.785398163f,           1.32460909f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 4)
-        [InlineData(-0.707106781f,           1.26059184f,            CrossPlatformMachineEpsilon * 10)]     // value:  (1 / sqrt(2))
-        [InlineData(-0.693147181f,           1.25f,                  CrossPlatformMachineEpsilon * 10)]     // value:  (ln(2))
-        [InlineData(-0.636619772f,           1.20957949f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / pi)
-        [InlineData(-0.434294482f,           1.09579746f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log10(e))
-        [InlineData(-0.318309886f,           1.05108979f,            CrossPlatformMachineEpsilon * 10)]     // value:  (1 / pi)
-        [InlineData(-0.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NaN,              float.NaN,              0.0f)]
-        [InlineData( 0.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.318309886f,           1.05108979f,            CrossPlatformMachineEpsilon * 10)]     // value:  (1 / pi)
-        [InlineData( 0.434294482f,           1.09579746f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log10(e))
-        [InlineData( 0.636619772f,           1.20957949f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / pi)
-        [InlineData( 0.693147181f,           1.25f,                  CrossPlatformMachineEpsilon * 10)]     // value:  (ln(2))
-        [InlineData( 0.707106781f,           1.26059184f,            CrossPlatformMachineEpsilon * 10)]     // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,           1.32460909f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 4)
-        [InlineData( 1.0f,                   1.54308063f,            CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.12837917f,            1.70710014f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,            2.17818356f,            CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))
-        [InlineData( 1.44269504f,            2.23418810f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))
-        [InlineData( 1.57079633f,            2.50917848f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)
-        [InlineData( 2.30258509f,            5.05f,                  CrossPlatformMachineEpsilon * 10)]     // value:  (ln(10))
-        [InlineData( 2.71828183f,            7.61012514f,            CrossPlatformMachineEpsilon * 10)]     // value:  (e)
-        [InlineData( 3.14159265f,            11.5919533f,            CrossPlatformMachineEpsilon * 100)]    // value:  (pi)
-        [InlineData( float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(-3.14159265f, 11.5919533f, CrossPlatformMachineEpsilon * 100)]    // value:  (pi)
+        [InlineData(-2.71828183f, 7.61012514f, CrossPlatformMachineEpsilon * 10)]     // value:  (e)
+        [InlineData(-2.30258509f, 5.05f, CrossPlatformMachineEpsilon * 10)]     // value:  (ln(10))
+        [InlineData(-1.57079633f, 2.50917848f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)
+        [InlineData(-1.44269504f, 2.23418810f, CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))
+        [InlineData(-1.41421356f, 2.17818356f, CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))
+        [InlineData(-1.12837917f, 1.70710014f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))
+        [InlineData(-1.0f, 1.54308063f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.785398163f, 1.32460909f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 4)
+        [InlineData(-0.707106781f, 1.26059184f, CrossPlatformMachineEpsilon * 10)]     // value:  (1 / sqrt(2))
+        [InlineData(-0.693147181f, 1.25f, CrossPlatformMachineEpsilon * 10)]     // value:  (ln(2))
+        [InlineData(-0.636619772f, 1.20957949f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / pi)
+        [InlineData(-0.434294482f, 1.09579746f, CrossPlatformMachineEpsilon * 10)]     // value:  (log10(e))
+        [InlineData(-0.318309886f, 1.05108979f, CrossPlatformMachineEpsilon * 10)]     // value:  (1 / pi)
+        [InlineData(-0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.318309886f, 1.05108979f, CrossPlatformMachineEpsilon * 10)]     // value:  (1 / pi)
+        [InlineData(0.434294482f, 1.09579746f, CrossPlatformMachineEpsilon * 10)]     // value:  (log10(e))
+        [InlineData(0.636619772f, 1.20957949f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / pi)
+        [InlineData(0.693147181f, 1.25f, CrossPlatformMachineEpsilon * 10)]     // value:  (ln(2))
+        [InlineData(0.707106781f, 1.26059184f, CrossPlatformMachineEpsilon * 10)]     // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 1.32460909f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 4)
+        [InlineData(1.0f, 1.54308063f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.12837917f, 1.70710014f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 2.17818356f, CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))
+        [InlineData(1.44269504f, 2.23418810f, CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))
+        [InlineData(1.57079633f, 2.50917848f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)
+        [InlineData(2.30258509f, 5.05f, CrossPlatformMachineEpsilon * 10)]     // value:  (ln(10))
+        [InlineData(2.71828183f, 7.61012514f, CrossPlatformMachineEpsilon * 10)]     // value:  (e)
+        [InlineData(3.14159265f, 11.5919533f, CrossPlatformMachineEpsilon * 100)]    // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Cosh(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Cosh(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, 0.0f,                   CrossPlatformMachineEpsilon)]
-        [InlineData(-3.14159265f,            0.0432139183f,          CrossPlatformMachineEpsilon / 10)]     // value: -(pi)
-        [InlineData(-2.71828183f,            0.0659880358f,          CrossPlatformMachineEpsilon / 10)]     // value: -(e)
-        [InlineData(-2.30258509f,            0.1f,                   CrossPlatformMachineEpsilon)]          // value: -(ln(10))
-        [InlineData(-1.57079633f,            0.207879576f,           CrossPlatformMachineEpsilon)]          // value: -(pi / 2)
-        [InlineData(-1.44269504f,            0.236290088f,           CrossPlatformMachineEpsilon)]          // value: -(log2(e))
-        [InlineData(-1.41421356f,            0.243116734f,           CrossPlatformMachineEpsilon)]          // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            0.323557264f,           CrossPlatformMachineEpsilon)]          // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   0.367879441f,           CrossPlatformMachineEpsilon)]
-        [InlineData(-0.785398163f,           0.455938128f,           CrossPlatformMachineEpsilon)]          // value: -(pi / 4)
-        [InlineData(-0.707106781f,           0.493068691f,           CrossPlatformMachineEpsilon)]          // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           0.5f,                   CrossPlatformMachineEpsilon)]          // value: -(ln(2))
-        [InlineData(-0.636619772f,           0.529077808f,           CrossPlatformMachineEpsilon)]          // value: -(2 / pi)
-        [InlineData(-0.434294482f,           0.647721485f,           CrossPlatformMachineEpsilon)]          // value: -(log10(e))
-        [InlineData(-0.318309886f,           0.727377349f,           CrossPlatformMachineEpsilon)]          // value: -(1 / pi)
-        [InlineData(-0.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NaN,              float.NaN,              0.0f)]
-        [InlineData( 0.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.318309886f,           1.37480223f,            CrossPlatformMachineEpsilon * 10)]     // value:  (1 / pi)
-        [InlineData( 0.434294482f,           1.54387344f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log10(e))
-        [InlineData( 0.636619772f,           1.89008116f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / pi)
-        [InlineData( 0.693147181f,           2.0f,                   CrossPlatformMachineEpsilon * 10)]     // value:  (ln(2))
-        [InlineData( 0.707106781f,           2.02811498f,            CrossPlatformMachineEpsilon * 10)]     // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,           2.19328005f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 4)
-        [InlineData( 1.0f,                   2.71828183f,            CrossPlatformMachineEpsilon * 10)]     //                          expected: (e)
-        [InlineData( 1.12837917f,            3.09064302f,            CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,            4.11325038f,            CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))
-        [InlineData( 1.44269504f,            4.23208611f,            CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))
-        [InlineData( 1.57079633f,            4.81047738f,            CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)
-        [InlineData( 2.30258509f,            10.0f,                  CrossPlatformMachineEpsilon * 100)]    // value:  (ln(10))
-        [InlineData( 2.71828183f,            15.1542622f,            CrossPlatformMachineEpsilon * 100)]    // value:  (e)
-        [InlineData( 3.14159265f,            23.1406926f,            CrossPlatformMachineEpsilon * 100)]    // value:  (pi)
-        [InlineData( float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, 0.0f, CrossPlatformMachineEpsilon)]
+        [InlineData(-3.14159265f, 0.0432139183f, CrossPlatformMachineEpsilon / 10)]     // value: -(pi)
+        [InlineData(-2.71828183f, 0.0659880358f, CrossPlatformMachineEpsilon / 10)]     // value: -(e)
+        [InlineData(-2.30258509f, 0.1f, CrossPlatformMachineEpsilon)]          // value: -(ln(10))
+        [InlineData(-1.57079633f, 0.207879576f, CrossPlatformMachineEpsilon)]          // value: -(pi / 2)
+        [InlineData(-1.44269504f, 0.236290088f, CrossPlatformMachineEpsilon)]          // value: -(log2(e))
+        [InlineData(-1.41421356f, 0.243116734f, CrossPlatformMachineEpsilon)]          // value: -(sqrt(2))
+        [InlineData(-1.12837917f, 0.323557264f, CrossPlatformMachineEpsilon)]          // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, 0.367879441f, CrossPlatformMachineEpsilon)]
+        [InlineData(-0.785398163f, 0.455938128f, CrossPlatformMachineEpsilon)]          // value: -(pi / 4)
+        [InlineData(-0.707106781f, 0.493068691f, CrossPlatformMachineEpsilon)]          // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, 0.5f, CrossPlatformMachineEpsilon)]          // value: -(ln(2))
+        [InlineData(-0.636619772f, 0.529077808f, CrossPlatformMachineEpsilon)]          // value: -(2 / pi)
+        [InlineData(-0.434294482f, 0.647721485f, CrossPlatformMachineEpsilon)]          // value: -(log10(e))
+        [InlineData(-0.318309886f, 0.727377349f, CrossPlatformMachineEpsilon)]          // value: -(1 / pi)
+        [InlineData(-0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.318309886f, 1.37480223f, CrossPlatformMachineEpsilon * 10)]     // value:  (1 / pi)
+        [InlineData(0.434294482f, 1.54387344f, CrossPlatformMachineEpsilon * 10)]     // value:  (log10(e))
+        [InlineData(0.636619772f, 1.89008116f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / pi)
+        [InlineData(0.693147181f, 2.0f, CrossPlatformMachineEpsilon * 10)]     // value:  (ln(2))
+        [InlineData(0.707106781f, 2.02811498f, CrossPlatformMachineEpsilon * 10)]     // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 2.19328005f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 4)
+        [InlineData(1.0f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]     //                          expected: (e)
+        [InlineData(1.12837917f, 3.09064302f, CrossPlatformMachineEpsilon * 10)]     // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 4.11325038f, CrossPlatformMachineEpsilon * 10)]     // value:  (sqrt(2))
+        [InlineData(1.44269504f, 4.23208611f, CrossPlatformMachineEpsilon * 10)]     // value:  (log2(e))
+        [InlineData(1.57079633f, 4.81047738f, CrossPlatformMachineEpsilon * 10)]     // value:  (pi / 2)
+        [InlineData(2.30258509f, 10.0f, CrossPlatformMachineEpsilon * 100)]    // value:  (ln(10))
+        [InlineData(2.71828183f, 15.1542622f, CrossPlatformMachineEpsilon * 100)]    // value:  (e)
+        [InlineData(3.14159265f, 23.1406926f, CrossPlatformMachineEpsilon * 100)]    // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Exp(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Exp(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData(float.NegativeInfinity,  float.NegativeInfinity, 0.0f)]
-        [InlineData(-3.14159265f,           -4.0f,                   0.0f)]  // value: -(pi)
-        [InlineData(-2.71828183f,           -3.0f,                   0.0f)]  // value: -(e)
-        [InlineData(-2.30258509f,           -3.0f,                   0.0f)]  // value: -(ln(10))
-        [InlineData(-1.57079633f,           -2.0f,                   0.0f)]  // value: -(pi / 2)
-        [InlineData(-1.44269504f,           -2.0f,                   0.0f)]  // value: -(log2(e))
-        [InlineData(-1.41421356f,           -2.0f,                   0.0f)]  // value: -(sqrt(2))
-        [InlineData(-1.12837917f,           -2.0f,                   0.0f)]  // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                  -1.0f,                   0.0f)]
-        [InlineData(-0.785398163f,          -1.0f,                   0.0f)]  // value: -(pi / 4)
-        [InlineData(-0.707106781f,          -1.0f,                   0.0f)]  // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,          -1.0f,                   0.0f)]  // value: -(ln(2))
-        [InlineData(-0.636619772f,          -1.0f,                   0.0f)]  // value: -(2 / pi)
-        [InlineData(-0.434294482f,          -1.0f,                   0.0f)]  // value: -(log10(e))
-        [InlineData(-0.318309886f,          -1.0f,                   0.0f)]  // value: -(1 / pi)
-        [InlineData(-0.0f,                  -0.0f,                   0.0f)]
-        [InlineData( float.NaN,              float.NaN,              0.0f)]
-        [InlineData( 0.0f,                   0.0f,                   0.0f)]
-        [InlineData( 0.318309886f,           0.0f,                   0.0f)]  // value:  (1 / pi)
-        [InlineData( 0.434294482f,           0.0f,                   0.0f)]  // value:  (log10(e))
-        [InlineData( 0.636619772f,           0.0f,                   0.0f)]  // value:  (2 / pi)
-        [InlineData( 0.693147181f,           0.0f,                   0.0f)]  // value:  (ln(2))
-        [InlineData( 0.707106781f,           0.0f,                   0.0f)]  // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,           0.0f,                   0.0f)]  // value:  (pi / 4)
-        [InlineData( 1.0f,                   1.0f,                   0.0f)]
-        [InlineData( 1.12837917f,            1.0f,                   0.0f)]  // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,            1.0f,                   0.0f)]  // value:  (sqrt(2))
-        [InlineData( 1.44269504f,            1.0f,                   0.0f)]  // value:  (log2(e))
-        [InlineData( 1.57079633f,            1.0f,                   0.0f)]  // value:  (pi / 2)
-        [InlineData( 2.30258509f,            2.0f,                   0.0f)]  // value:  (ln(10))
-        [InlineData( 2.71828183f,            2.0f,                   0.0f)]  // value:  (e)
-        [InlineData( 3.14159265f,            3.0f,                   0.0f)]  // value:  (pi)
-        [InlineData(float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, 0.0f)]
+        [InlineData(-3.14159265f, -4.0f, 0.0f)]  // value: -(pi)
+        [InlineData(-2.71828183f, -3.0f, 0.0f)]  // value: -(e)
+        [InlineData(-2.30258509f, -3.0f, 0.0f)]  // value: -(ln(10))
+        [InlineData(-1.57079633f, -2.0f, 0.0f)]  // value: -(pi / 2)
+        [InlineData(-1.44269504f, -2.0f, 0.0f)]  // value: -(log2(e))
+        [InlineData(-1.41421356f, -2.0f, 0.0f)]  // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -2.0f, 0.0f)]  // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -1.0f, 0.0f)]
+        [InlineData(-0.785398163f, -1.0f, 0.0f)]  // value: -(pi / 4)
+        [InlineData(-0.707106781f, -1.0f, 0.0f)]  // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -1.0f, 0.0f)]  // value: -(ln(2))
+        [InlineData(-0.636619772f, -1.0f, 0.0f)]  // value: -(2 / pi)
+        [InlineData(-0.434294482f, -1.0f, 0.0f)]  // value: -(log10(e))
+        [InlineData(-0.318309886f, -1.0f, 0.0f)]  // value: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.0f, 0.0f)]  // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.0f, 0.0f)]  // value:  (log10(e))
+        [InlineData(0.636619772f, 0.0f, 0.0f)]  // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.0f, 0.0f)]  // value:  (ln(2))
+        [InlineData(0.707106781f, 0.0f, 0.0f)]  // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.0f, 0.0f)]  // value:  (pi / 4)
+        [InlineData(1.0f, 1.0f, 0.0f)]
+        [InlineData(1.12837917f, 1.0f, 0.0f)]  // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 1.0f, 0.0f)]  // value:  (sqrt(2))
+        [InlineData(1.44269504f, 1.0f, 0.0f)]  // value:  (log2(e))
+        [InlineData(1.57079633f, 1.0f, 0.0f)]  // value:  (pi / 2)
+        [InlineData(2.30258509f, 2.0f, 0.0f)]  // value:  (ln(10))
+        [InlineData(2.71828183f, 2.0f, 0.0f)]  // value:  (e)
+        [InlineData(3.14159265f, 3.0f, 0.0f)]  // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Floor(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Floor(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NegativeInfinity,  float.NegativeInfinity,  float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    float.NegativeInfinity,  float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                   -3.14159265f,             float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                   -0.0f,                    float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    float.NaN,               float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    0.0f,                    float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    3.14159265f,             float.NaN)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    float.PositiveInfinity,  float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    float.NegativeInfinity,  float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                   -3.14159265f,             float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                   -0.0f,                    float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    float.NaN,               float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    0.0f,                    float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    3.14159265f,             float.NaN)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    float.PositiveInfinity,  float.NaN)]
-        [InlineData( float.NegativeInfinity,  float.PositiveInfinity,  float.PositiveInfinity,  float.NaN)]
-        [InlineData(-1e38f,                   2.0f,                    1e38f,                  -1e38f)]
-        [InlineData(-1e38f,                   2.0f,                    float.PositiveInfinity,  float.PositiveInfinity)]
-        [InlineData(-5,                       4,                      -3,                      -23)]
-        [InlineData(-0.0f,                    float.NegativeInfinity,  float.NegativeInfinity,  float.NaN)]
-        [InlineData(-0.0f,                    float.NegativeInfinity, -3.14159265f,             float.NaN)]
-        [InlineData(-0.0f,                    float.NegativeInfinity, -0.0f,                    float.NaN)]
-        [InlineData(-0.0f,                    float.NegativeInfinity,  float.NaN,               float.NaN)]
-        [InlineData(-0.0f,                    float.NegativeInfinity,  0.0f,                    float.NaN)]
-        [InlineData(-0.0f,                    float.NegativeInfinity,  3.14159265f,             float.NaN)]
-        [InlineData(-0.0f,                    float.NegativeInfinity,  float.PositiveInfinity,  float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  float.NegativeInfinity,  float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity, -3.14159265f,             float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity, -0.0f,                    float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  float.NaN,               float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  0.0f,                    float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  3.14159265f,             float.NaN)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  float.PositiveInfinity,  float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  float.NegativeInfinity,  float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity, -3.14159265f,             float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity, -0.0f,                    float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  float.NaN,               float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  0.0f,                    float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  3.14159265f,             float.NaN)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  float.PositiveInfinity,  float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  float.NegativeInfinity,  float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity, -3.14159265f,             float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity, -0.0f,                    float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  float.NaN,               float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  0.0f,                    float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  3.14159265f,             float.NaN)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  float.PositiveInfinity,  float.NaN)]
-        [InlineData( 5,                       4,                       3,                       23)]
-        [InlineData( 1e38f,                   2.0f,                   -1e38f,                   1e38f)]
-        [InlineData( 1e38f,                   2.0f,                    float.NegativeInfinity,  float.NegativeInfinity)]
-        [InlineData( float.PositiveInfinity,  float.NegativeInfinity,  float.PositiveInfinity,  float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    float.NegativeInfinity,  float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                   -3.14159265f,             float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                   -0.0f,                    float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    float.NaN,               float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    0.0f,                    float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    3.14159265f,             float.NaN)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    float.PositiveInfinity,  float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    float.NegativeInfinity,  float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                   -3.14159265f,             float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                   -0.0f,                    float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    float.NaN,               float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    0.0f,                    float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    3.14159265f,             float.NaN)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    float.PositiveInfinity,  float.NaN)]
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity,  float.NegativeInfinity,  float.NaN)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, float.NegativeInfinity, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, -3.14159265f, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, -0.0f, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, float.NaN, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, 0.0f, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, 3.14159265f, float.NaN)]
+        [InlineData(float.NegativeInfinity, -0.0f, float.PositiveInfinity, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, float.NegativeInfinity, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, -3.14159265f, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, -0.0f, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, float.NaN, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, 0.0f, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, 3.14159265f, float.NaN)]
+        [InlineData(float.NegativeInfinity, 0.0f, float.PositiveInfinity, float.NaN)]
+        [InlineData(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity, float.NaN)]
+        [InlineData(-1e38f, 2.0f, 1e38f, -1e38f)]
+        [InlineData(-1e38f, 2.0f, float.PositiveInfinity, float.PositiveInfinity)]
+        [InlineData(-5, 4, -3, -23)]
+        [InlineData(-0.0f, float.NegativeInfinity, float.NegativeInfinity, float.NaN)]
+        [InlineData(-0.0f, float.NegativeInfinity, -3.14159265f, float.NaN)]
+        [InlineData(-0.0f, float.NegativeInfinity, -0.0f, float.NaN)]
+        [InlineData(-0.0f, float.NegativeInfinity, float.NaN, float.NaN)]
+        [InlineData(-0.0f, float.NegativeInfinity, 0.0f, float.NaN)]
+        [InlineData(-0.0f, float.NegativeInfinity, 3.14159265f, float.NaN)]
+        [InlineData(-0.0f, float.NegativeInfinity, float.PositiveInfinity, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, float.NegativeInfinity, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, -3.14159265f, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, -0.0f, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, float.NaN, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, 0.0f, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, 3.14159265f, float.NaN)]
+        [InlineData(-0.0f, float.PositiveInfinity, float.PositiveInfinity, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, float.NegativeInfinity, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, -3.14159265f, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, -0.0f, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, float.NaN, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, 0.0f, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, 3.14159265f, float.NaN)]
+        [InlineData(0.0f, float.NegativeInfinity, float.PositiveInfinity, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, float.NegativeInfinity, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, -3.14159265f, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, -0.0f, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, float.NaN, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, 0.0f, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, 3.14159265f, float.NaN)]
+        [InlineData(0.0f, float.PositiveInfinity, float.PositiveInfinity, float.NaN)]
+        [InlineData(5, 4, 3, 23)]
+        [InlineData(1e38f, 2.0f, -1e38f, 1e38f)]
+        [InlineData(1e38f, 2.0f, float.NegativeInfinity, float.NegativeInfinity)]
+        [InlineData(float.PositiveInfinity, float.NegativeInfinity, float.PositiveInfinity, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, float.NegativeInfinity, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, -3.14159265f, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, -0.0f, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, float.NaN, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, 0.0f, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, 3.14159265f, float.NaN)]
+        [InlineData(float.PositiveInfinity, -0.0f, float.PositiveInfinity, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, float.NegativeInfinity, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, -3.14159265f, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, -0.0f, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, float.NaN, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, 0.0f, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, 3.14159265f, float.NaN)]
+        [InlineData(float.PositiveInfinity, 0.0f, float.PositiveInfinity, float.NaN)]
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, float.NegativeInfinity, float.NaN)]
         public static void FusedMultiplyAdd(float x, float y, float z, float expectedResult)
         {
             AssertEqual(expectedResult, MathF.FusedMultiplyAdd(x, y, z), 0.0f);
@@ -1029,86 +1029,86 @@ namespace System.Tests
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  unchecked((int)(0x7FFFFFFF)))]
-        [InlineData(-0.0f,                    unchecked((int)(0x80000000)))]
-        [InlineData( float.NaN,               unchecked((int)(0x7FFFFFFF)))]
-        [InlineData( 0.0f,                    unchecked((int)(0x80000000)))]
-        [InlineData( 0.113314732f,           -4)]
-        [InlineData( 0.151955223f,           -3)]
-        [InlineData( 0.202699566f,           -3)]
-        [InlineData( 0.336622537f,           -2)]
-        [InlineData( 0.367879441f,           -2)]
-        [InlineData( 0.375214227f,           -2)]
-        [InlineData( 0.457429347f,           -2)]
-        [InlineData( 0.5f,                   -1)]
-        [InlineData( 0.580191810f,           -1)]
-        [InlineData( 0.612547327f,           -1)]
-        [InlineData( 0.618503138f,           -1)]
-        [InlineData( 0.643218242f,           -1)]
-        [InlineData( 0.740055574f,           -1)]
-        [InlineData( 0.802008879f,           -1)]
-        [InlineData( 1.0f,                    0)]
-        [InlineData( 1.24686899f,             0)]
-        [InlineData( 1.35124987f,             0)]
-        [InlineData( 1.55468228f,             0)]
-        [InlineData( 1.61680667f,             0)]
-        [InlineData( 1.63252692f,             0)]
-        [InlineData( 1.72356793f,             0)]
-        [InlineData( 2.0f,                    1)]
-        [InlineData( 2.18612996f,             1)]
-        [InlineData( 2.66514414f,             1)]
-        [InlineData( 2.71828183f,             1)]
-        [InlineData( 2.97068642f,             1)]
-        [InlineData( 4.93340967f,             2)]
-        [InlineData( 6.58088599f,             2)]
-        [InlineData( 8.82497783f,             3)]
-        [InlineData( float.PositiveInfinity,  unchecked((int)(0x7FFFFFFF)))]
+        [InlineData(float.NegativeInfinity, unchecked((int)(0x7FFFFFFF)))]
+        [InlineData(-0.0f, unchecked((int)(0x80000000)))]
+        [InlineData(float.NaN, unchecked((int)(0x7FFFFFFF)))]
+        [InlineData(0.0f, unchecked((int)(0x80000000)))]
+        [InlineData(0.113314732f, -4)]
+        [InlineData(0.151955223f, -3)]
+        [InlineData(0.202699566f, -3)]
+        [InlineData(0.336622537f, -2)]
+        [InlineData(0.367879441f, -2)]
+        [InlineData(0.375214227f, -2)]
+        [InlineData(0.457429347f, -2)]
+        [InlineData(0.5f, -1)]
+        [InlineData(0.580191810f, -1)]
+        [InlineData(0.612547327f, -1)]
+        [InlineData(0.618503138f, -1)]
+        [InlineData(0.643218242f, -1)]
+        [InlineData(0.740055574f, -1)]
+        [InlineData(0.802008879f, -1)]
+        [InlineData(1.0f, 0)]
+        [InlineData(1.24686899f, 0)]
+        [InlineData(1.35124987f, 0)]
+        [InlineData(1.55468228f, 0)]
+        [InlineData(1.61680667f, 0)]
+        [InlineData(1.63252692f, 0)]
+        [InlineData(1.72356793f, 0)]
+        [InlineData(2.0f, 1)]
+        [InlineData(2.18612996f, 1)]
+        [InlineData(2.66514414f, 1)]
+        [InlineData(2.71828183f, 1)]
+        [InlineData(2.97068642f, 1)]
+        [InlineData(4.93340967f, 2)]
+        [InlineData(6.58088599f, 2)]
+        [InlineData(8.82497783f, 3)]
+        [InlineData(float.PositiveInfinity, unchecked((int)(0x7FFFFFFF)))]
         public static void ILogB(float value, int expectedResult)
         {
             Assert.Equal(expectedResult, MathF.ILogB(value));
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-3.14159265f,             float.NaN,              0.0f)]                               //                               value: -(pi)
-        [InlineData(-2.71828183f,             float.NaN,              0.0f)]                               //                               value: -(e)
-        [InlineData(-1.41421356f,             float.NaN,              0.0f)]                               //                               value: -(sqrt(2))
-        [InlineData(-1.0f,                    float.NaN,              0.0f)]
-        [InlineData(-0.693147181f,            float.NaN,              0.0f)]                               //                               value: -(ln(2))
-        [InlineData(-0.434294482f,            float.NaN,              0.0f)]                               //                               value: -(log10(e))
-        [InlineData(-0.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( 0.0432139183f,          -3.14159265f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(pi)
-        [InlineData( 0.0659880358f,          -2.71828183f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(e)
-        [InlineData( 0.1f,                   -2.30258509f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(ln(10))
-        [InlineData( 0.207879576f,           -1.57079633f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(pi / 2)
-        [InlineData( 0.236290088f,           -1.44269504f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(log2(e))
-        [InlineData( 0.243116734f,           -1.41421356f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(sqrt(2))
-        [InlineData( 0.323557264f,           -1.12837917f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(2 / sqrt(pi))
-        [InlineData( 0.367879441f,           -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.455938128f,           -0.785398163f,           CrossPlatformMachineEpsilon)]         // expected: -(pi / 4)
-        [InlineData( 0.493068691f,           -0.707106781f,           CrossPlatformMachineEpsilon)]         // expected: -(1 / sqrt(2))
-        [InlineData( 0.5f,                   -0.693147181f,           CrossPlatformMachineEpsilon)]         // expected: -(ln(2))
-        [InlineData( 0.529077808f,           -0.636619772f,           CrossPlatformMachineEpsilon)]         // expected: -(2 / pi)
-        [InlineData( 0.647721485f,           -0.434294482f,           CrossPlatformMachineEpsilon)]         // expected: -(log10(e))
-        [InlineData( 0.727377349f,           -0.318309886f,           CrossPlatformMachineEpsilon)]         // expected: -(1 / pi)
-        [InlineData( 1.0f,                    0.0f,                   0.0f)]
-        [InlineData( 1.37480223f,             0.318309886f,           CrossPlatformMachineEpsilon)]         // expected:  (1 / pi)
-        [InlineData( 1.54387344f,             0.434294482f,           CrossPlatformMachineEpsilon)]         // expected:  (log10(e))
-        [InlineData( 1.89008116f,             0.636619772f,           CrossPlatformMachineEpsilon)]         // expected:  (2 / pi)
-        [InlineData( 2.0f,                    0.693147181f,           CrossPlatformMachineEpsilon)]         // expected:  (ln(2))
-        [InlineData( 2.02811498f,             0.707106781f,           CrossPlatformMachineEpsilon)]         // expected:  (1 / sqrt(2))
-        [InlineData( 2.19328005f,             0.785398163f,           CrossPlatformMachineEpsilon)]         // expected:  (pi / 4)
-        [InlineData( 2.71828183f,             1.0f,                   CrossPlatformMachineEpsilon * 10)]    //                              value: (e)
-        [InlineData( 3.09064302f,             1.12837917f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (2 / sqrt(pi))
-        [InlineData( 4.11325038f,             1.41421356f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (sqrt(2))
-        [InlineData( 4.23208611f,             1.44269504f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (log2(e))
-        [InlineData( 4.81047738f,             1.57079633f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (pi / 2)
-        [InlineData( 10.0f,                   2.30258509f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (ln(10))
-        [InlineData( 15.1542622f,             2.71828183f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (e)
-        [InlineData( 23.1406926f,             3.14159265f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                               //                               value: -(pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                               //                               value: -(e)
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                               //                               value: -(sqrt(2))
+        [InlineData(-1.0f, float.NaN, 0.0f)]
+        [InlineData(-0.693147181f, float.NaN, 0.0f)]                               //                               value: -(ln(2))
+        [InlineData(-0.434294482f, float.NaN, 0.0f)]                               //                               value: -(log10(e))
+        [InlineData(-0.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(0.0432139183f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]    // expected: -(pi)
+        [InlineData(0.0659880358f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]    // expected: -(e)
+        [InlineData(0.1f, -2.30258509f, CrossPlatformMachineEpsilon * 10)]    // expected: -(ln(10))
+        [InlineData(0.207879576f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]    // expected: -(pi / 2)
+        [InlineData(0.236290088f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]    // expected: -(log2(e))
+        [InlineData(0.243116734f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]    // expected: -(sqrt(2))
+        [InlineData(0.323557264f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]    // expected: -(2 / sqrt(pi))
+        [InlineData(0.367879441f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.455938128f, -0.785398163f, CrossPlatformMachineEpsilon)]         // expected: -(pi / 4)
+        [InlineData(0.493068691f, -0.707106781f, CrossPlatformMachineEpsilon)]         // expected: -(1 / sqrt(2))
+        [InlineData(0.5f, -0.693147181f, CrossPlatformMachineEpsilon)]         // expected: -(ln(2))
+        [InlineData(0.529077808f, -0.636619772f, CrossPlatformMachineEpsilon)]         // expected: -(2 / pi)
+        [InlineData(0.647721485f, -0.434294482f, CrossPlatformMachineEpsilon)]         // expected: -(log10(e))
+        [InlineData(0.727377349f, -0.318309886f, CrossPlatformMachineEpsilon)]         // expected: -(1 / pi)
+        [InlineData(1.0f, 0.0f, 0.0f)]
+        [InlineData(1.37480223f, 0.318309886f, CrossPlatformMachineEpsilon)]         // expected:  (1 / pi)
+        [InlineData(1.54387344f, 0.434294482f, CrossPlatformMachineEpsilon)]         // expected:  (log10(e))
+        [InlineData(1.89008116f, 0.636619772f, CrossPlatformMachineEpsilon)]         // expected:  (2 / pi)
+        [InlineData(2.0f, 0.693147181f, CrossPlatformMachineEpsilon)]         // expected:  (ln(2))
+        [InlineData(2.02811498f, 0.707106781f, CrossPlatformMachineEpsilon)]         // expected:  (1 / sqrt(2))
+        [InlineData(2.19328005f, 0.785398163f, CrossPlatformMachineEpsilon)]         // expected:  (pi / 4)
+        [InlineData(2.71828183f, 1.0f, CrossPlatformMachineEpsilon * 10)]    //                              value: (e)
+        [InlineData(3.09064302f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]    // expected:  (2 / sqrt(pi))
+        [InlineData(4.11325038f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]    // expected:  (sqrt(2))
+        [InlineData(4.23208611f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]    // expected:  (log2(e))
+        [InlineData(4.81047738f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]    // expected:  (pi / 2)
+        [InlineData(10.0f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]    // expected:  (ln(10))
+        [InlineData(15.1542622f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]    // expected:  (e)
+        [InlineData(23.1406926f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]    // expected:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Log(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Log(value), allowedVariance);
@@ -1127,87 +1127,87 @@ namespace System.Tests
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-0.113314732f,            float.NaN,              0.0f)]
-        [InlineData(-0.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( 0.113314732f,           -3.14159265f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(pi)
-        [InlineData( 0.151955223f,           -2.71828183f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(e)
-        [InlineData( 0.202699566f,           -2.30258509f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(ln(10))
-        [InlineData( 0.336622537f,           -1.57079633f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(pi / 2)
-        [InlineData( 0.367879441f,           -1.44269504f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(log2(e))
-        [InlineData( 0.375214227f,           -1.41421356f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(sqrt(2))
-        [InlineData( 0.457429347f,           -1.12837917f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(2 / sqrt(pi))
-        [InlineData( 0.5f,                   -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.580191810f,           -0.785398163f,           CrossPlatformMachineEpsilon)]         // expected: -(pi / 4)
-        [InlineData( 0.612547327f,           -0.707106781f,           CrossPlatformMachineEpsilon)]         // expected: -(1 / sqrt(2))
-        [InlineData( 0.618503138f,           -0.693147181f,           CrossPlatformMachineEpsilon)]         // expected: -(ln(2))
-        [InlineData( 0.643218242f,           -0.636619772f,           CrossPlatformMachineEpsilon)]         // expected: -(2 / pi)
-        [InlineData( 0.740055574f,           -0.434294482f,           CrossPlatformMachineEpsilon)]         // expected: -(log10(e))
-        [InlineData( 0.802008879f,           -0.318309886f,           CrossPlatformMachineEpsilon)]         // expected: -(1 / pi)
-        [InlineData( 1,                       0.0f,                   0.0f)]
-        [InlineData( 1.24686899f,             0.318309886f,           CrossPlatformMachineEpsilon)]         // expected:  (1 / pi)
-        [InlineData( 1.35124987f,             0.434294482f,           CrossPlatformMachineEpsilon)]         // expected:  (log10(e))
-        [InlineData( 1.55468228f,             0.636619772f,           CrossPlatformMachineEpsilon)]         // expected:  (2 / pi)
-        [InlineData( 1.61680667f,             0.693147181f,           CrossPlatformMachineEpsilon)]         // expected:  (ln(2))
-        [InlineData( 1.63252692f,             0.707106781f,           CrossPlatformMachineEpsilon)]         // expected:  (1 / sqrt(2))
-        [InlineData( 1.72356793f,             0.785398163f,           CrossPlatformMachineEpsilon)]         // expected:  (pi / 4)
-        [InlineData( 2,                       1.0f,                   CrossPlatformMachineEpsilon * 10)]    //                              value: (e)
-        [InlineData( 2.18612996f,             1.12837917f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (2 / sqrt(pi))
-        [InlineData( 2.66514414f,             1.41421356f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (sqrt(2))
-        [InlineData( 2.71828183f,             1.44269504f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (log2(e))
-        [InlineData( 2.97068642f,             1.57079633f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (pi / 2)
-        [InlineData( 4.93340967f,             2.30258509f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (ln(10))
-        [InlineData( 6.58088599f,             2.71828183f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (e)
-        [InlineData( 8.82497783f,             3.14159265f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-0.113314732f, float.NaN, 0.0f)]
+        [InlineData(-0.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(0.113314732f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]    // expected: -(pi)
+        [InlineData(0.151955223f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]    // expected: -(e)
+        [InlineData(0.202699566f, -2.30258509f, CrossPlatformMachineEpsilon * 10)]    // expected: -(ln(10))
+        [InlineData(0.336622537f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]    // expected: -(pi / 2)
+        [InlineData(0.367879441f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]    // expected: -(log2(e))
+        [InlineData(0.375214227f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]    // expected: -(sqrt(2))
+        [InlineData(0.457429347f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]    // expected: -(2 / sqrt(pi))
+        [InlineData(0.5f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.580191810f, -0.785398163f, CrossPlatformMachineEpsilon)]         // expected: -(pi / 4)
+        [InlineData(0.612547327f, -0.707106781f, CrossPlatformMachineEpsilon)]         // expected: -(1 / sqrt(2))
+        [InlineData(0.618503138f, -0.693147181f, CrossPlatformMachineEpsilon)]         // expected: -(ln(2))
+        [InlineData(0.643218242f, -0.636619772f, CrossPlatformMachineEpsilon)]         // expected: -(2 / pi)
+        [InlineData(0.740055574f, -0.434294482f, CrossPlatformMachineEpsilon)]         // expected: -(log10(e))
+        [InlineData(0.802008879f, -0.318309886f, CrossPlatformMachineEpsilon)]         // expected: -(1 / pi)
+        [InlineData(1, 0.0f, 0.0f)]
+        [InlineData(1.24686899f, 0.318309886f, CrossPlatformMachineEpsilon)]         // expected:  (1 / pi)
+        [InlineData(1.35124987f, 0.434294482f, CrossPlatformMachineEpsilon)]         // expected:  (log10(e))
+        [InlineData(1.55468228f, 0.636619772f, CrossPlatformMachineEpsilon)]         // expected:  (2 / pi)
+        [InlineData(1.61680667f, 0.693147181f, CrossPlatformMachineEpsilon)]         // expected:  (ln(2))
+        [InlineData(1.63252692f, 0.707106781f, CrossPlatformMachineEpsilon)]         // expected:  (1 / sqrt(2))
+        [InlineData(1.72356793f, 0.785398163f, CrossPlatformMachineEpsilon)]         // expected:  (pi / 4)
+        [InlineData(2, 1.0f, CrossPlatformMachineEpsilon * 10)]    //                              value: (e)
+        [InlineData(2.18612996f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]    // expected:  (2 / sqrt(pi))
+        [InlineData(2.66514414f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]    // expected:  (sqrt(2))
+        [InlineData(2.71828183f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]    // expected:  (log2(e))
+        [InlineData(2.97068642f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]    // expected:  (pi / 2)
+        [InlineData(4.93340967f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]    // expected:  (ln(10))
+        [InlineData(6.58088599f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]    // expected:  (e)
+        [InlineData(8.82497783f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]    // expected:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Log2(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Log2(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-3.14159265f,             float.NaN,              0.0f)]                                //                              value: -(pi)
-        [InlineData(-2.71828183f,             float.NaN,              0.0f)]                                //                              value: -(e)
-        [InlineData(-1.41421356f,             float.NaN,              0.0f)]                                //                              value: -(sqrt(2))
-        [InlineData(-1.0f,                    float.NaN,              0.0f)]
-        [InlineData(-0.693147181f,            float.NaN,              0.0f)]                                //                              value: -(ln(2))
-        [InlineData(-0.434294482f,            float.NaN,              0.0f)]                                //                              value: -(log10(e))
-        [InlineData(-0.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( 0.000721784159f,        -3.14159265f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(pi)
-        [InlineData( 0.00191301410f,         -2.71828183f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(e)
-        [InlineData( 0.00498212830f,         -2.30258509f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(ln(10))
-        [InlineData( 0.0268660410f,          -1.57079633f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(pi / 2)
-        [InlineData( 0.0360831928f,          -1.44269504f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(log2(e))
-        [InlineData( 0.0385288847f,          -1.41421356f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(sqrt(2))
-        [InlineData( 0.0744082059f,          -1.12837917f,            CrossPlatformMachineEpsilon * 10)]    // expected: -(2 / sqrt(pi))
-        [InlineData( 0.1f,                   -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.163908636f,           -0.785398163f,           CrossPlatformMachineEpsilon)]         // expected: -(pi / 4)
-        [InlineData( 0.196287760f,           -0.707106781f,           CrossPlatformMachineEpsilon)]         // expected: -(1 / sqrt(2))
-        [InlineData( 0.202699566f,           -0.693147181f,           CrossPlatformMachineEpsilon)]         // expected: -(ln(2))
-        [InlineData( 0.230876765f,           -0.636619772f,           CrossPlatformMachineEpsilon)]         // expected: -(2 / pi)
-        [InlineData( 0.367879441f,           -0.434294482f,           CrossPlatformMachineEpsilon)]         // expected: -(log10(e))
-        [InlineData( 0.480496373f,           -0.318309886f,           CrossPlatformMachineEpsilon)]         // expected: -(1 / pi)
-        [InlineData( 1.0f,                    0.0f,                   0.0f)]
-        [InlineData( 2.08118116f,             0.318309886f,           CrossPlatformMachineEpsilon)]         // expected:  (1 / pi)
-        [InlineData( 2.71828183f,             0.434294482f,           CrossPlatformMachineEpsilon)]         // expected:  (log10(e))        value: (e)
-        [InlineData( 4.33131503f,             0.636619772f,           CrossPlatformMachineEpsilon)]         // expected:  (2 / pi)
-        [InlineData( 4.93340967f,             0.693147181f,           CrossPlatformMachineEpsilon)]         // expected:  (ln(2))
-        [InlineData( 5.09456117f,             0.707106781f,           CrossPlatformMachineEpsilon)]         // expected:  (1 / sqrt(2))
-        [InlineData( 6.10095980f,             0.785398163f,           CrossPlatformMachineEpsilon)]         // expected:  (pi / 4)
-        [InlineData( 10.0f,                   1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 13.4393779f,             1.12837917f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (2 / sqrt(pi))
-        [InlineData( 25.9545535f,             1.41421356f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (sqrt(2))
-        [InlineData( 27.7137338f,             1.44269504f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (log2(e))
-        [InlineData( 37.2217105f,             1.57079633f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (pi / 2)
-        [InlineData( 200.717432f,             2.30258509f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (ln(10))
-        [InlineData( 522.735300f,             2.71828183f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (e)
-        [InlineData( 1385.45573f,             3.14159265f,            CrossPlatformMachineEpsilon * 10)]    // expected:  (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                                //                              value: -(pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                                //                              value: -(e)
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                                //                              value: -(sqrt(2))
+        [InlineData(-1.0f, float.NaN, 0.0f)]
+        [InlineData(-0.693147181f, float.NaN, 0.0f)]                                //                              value: -(ln(2))
+        [InlineData(-0.434294482f, float.NaN, 0.0f)]                                //                              value: -(log10(e))
+        [InlineData(-0.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(0.000721784159f, -3.14159265f, CrossPlatformMachineEpsilon * 10)]    // expected: -(pi)
+        [InlineData(0.00191301410f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]    // expected: -(e)
+        [InlineData(0.00498212830f, -2.30258509f, CrossPlatformMachineEpsilon * 10)]    // expected: -(ln(10))
+        [InlineData(0.0268660410f, -1.57079633f, CrossPlatformMachineEpsilon * 10)]    // expected: -(pi / 2)
+        [InlineData(0.0360831928f, -1.44269504f, CrossPlatformMachineEpsilon * 10)]    // expected: -(log2(e))
+        [InlineData(0.0385288847f, -1.41421356f, CrossPlatformMachineEpsilon * 10)]    // expected: -(sqrt(2))
+        [InlineData(0.0744082059f, -1.12837917f, CrossPlatformMachineEpsilon * 10)]    // expected: -(2 / sqrt(pi))
+        [InlineData(0.1f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.163908636f, -0.785398163f, CrossPlatformMachineEpsilon)]         // expected: -(pi / 4)
+        [InlineData(0.196287760f, -0.707106781f, CrossPlatformMachineEpsilon)]         // expected: -(1 / sqrt(2))
+        [InlineData(0.202699566f, -0.693147181f, CrossPlatformMachineEpsilon)]         // expected: -(ln(2))
+        [InlineData(0.230876765f, -0.636619772f, CrossPlatformMachineEpsilon)]         // expected: -(2 / pi)
+        [InlineData(0.367879441f, -0.434294482f, CrossPlatformMachineEpsilon)]         // expected: -(log10(e))
+        [InlineData(0.480496373f, -0.318309886f, CrossPlatformMachineEpsilon)]         // expected: -(1 / pi)
+        [InlineData(1.0f, 0.0f, 0.0f)]
+        [InlineData(2.08118116f, 0.318309886f, CrossPlatformMachineEpsilon)]         // expected:  (1 / pi)
+        [InlineData(2.71828183f, 0.434294482f, CrossPlatformMachineEpsilon)]         // expected:  (log10(e))        value: (e)
+        [InlineData(4.33131503f, 0.636619772f, CrossPlatformMachineEpsilon)]         // expected:  (2 / pi)
+        [InlineData(4.93340967f, 0.693147181f, CrossPlatformMachineEpsilon)]         // expected:  (ln(2))
+        [InlineData(5.09456117f, 0.707106781f, CrossPlatformMachineEpsilon)]         // expected:  (1 / sqrt(2))
+        [InlineData(6.10095980f, 0.785398163f, CrossPlatformMachineEpsilon)]         // expected:  (pi / 4)
+        [InlineData(10.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(13.4393779f, 1.12837917f, CrossPlatformMachineEpsilon * 10)]    // expected:  (2 / sqrt(pi))
+        [InlineData(25.9545535f, 1.41421356f, CrossPlatformMachineEpsilon * 10)]    // expected:  (sqrt(2))
+        [InlineData(27.7137338f, 1.44269504f, CrossPlatformMachineEpsilon * 10)]    // expected:  (log2(e))
+        [InlineData(37.2217105f, 1.57079633f, CrossPlatformMachineEpsilon * 10)]    // expected:  (pi / 2)
+        [InlineData(200.717432f, 2.30258509f, CrossPlatformMachineEpsilon * 10)]    // expected:  (ln(10))
+        [InlineData(522.735300f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]    // expected:  (e)
+        [InlineData(1385.45573f, 3.14159265f, CrossPlatformMachineEpsilon * 10)]    // expected:  (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Log10(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Log10(value), allowedVariance);
@@ -1266,161 +1266,161 @@ namespace System.Tests
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NegativeInfinity,  0.0f,                   0.0f)]
-        [InlineData( float.NegativeInfinity, -1.0f,                   -0.0f,                   0.0f)]
-        [InlineData( float.NegativeInfinity, -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NegativeInfinity,  float.NaN,               float.NaN,              0.0f)]
-        [InlineData( float.NegativeInfinity,  0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NegativeInfinity,  1.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData( float.NegativeInfinity,  float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
-        [InlineData(-10.0f,                   float.NegativeInfinity,  0.0f,                   0.0f)]
-        [InlineData(-10.0f,                  -1.57079633f,             float.NaN,              0.0f)]                                   //          y: -(pi / 2)
-        [InlineData(-10.0f,                  -1.0f,                   -0.1f,                   CrossPlatformMachineEpsilon)]
-        [InlineData(-10.0f,                  -0.785398163f,            float.NaN,              0.0f)]                                   //          y: -(pi / 4)
-        [InlineData(-10.0f,                  -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-10.0f,                   float.NaN,               float.NaN,              0.0f)]
-        [InlineData(-10.0f,                   0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-10.0f,                   0.785398163f,            float.NaN,              0.0f)]                                   //          y:  (pi / 4)
-        [InlineData(-10.0f,                   1.0f,                   -10.0f,                  CrossPlatformMachineEpsilon * 100)]
-        [InlineData(-10.0f,                   1.57079633f,             float.NaN,              0.0f)]                                   //          y:  (pi / 2)
-        [InlineData(-10.0f,                   float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
-        [InlineData(-2.71828183f,             float.NegativeInfinity,  0.0f,                   0.0f)]                                   // x: -(e)
-        [InlineData(-2.71828183f,            -1.57079633f,             float.NaN,              0.0f)]                                   // x: -(e)  y: -(pi / 2)
-        [InlineData(-2.71828183f,            -1.0f,                   -0.367879441f,           CrossPlatformMachineEpsilon)]            // x: -(e)
-        [InlineData(-2.71828183f,            -0.785398163f,            float.NaN,              0.0f)]                                   // x: -(e)  y: -(pi / 4)
-        [InlineData(-2.71828183f,            -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]       // x: -(e)
-        [InlineData(-2.71828183f,             float.NaN,               float.NaN,              0.0f)]
-        [InlineData(-2.71828183f,             0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]       // x: -(e)
-        [InlineData(-2.71828183f,             0.785398163f,            float.NaN,              0.0f)]                                   // x: -(e)  y:  (pi / 4)
-        [InlineData(-2.71828183f,             1.0f,                   -2.71828183f,            CrossPlatformMachineEpsilon * 10)]       // x: -(e)  expected: (e)
-        [InlineData(-2.71828183f,             1.57079633f,             float.NaN,              0.0f)]                                   // x: -(e)  y:  (pi / 2)
-        [InlineData(-2.71828183f,             float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
-        [InlineData(-1.0f,                   -1.0f,                   -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-1.0f,                   -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-1.0f,                    float.NaN,               float.NaN,              0.0f)]
-        [InlineData(-1.0f,                    0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-1.0f,                    1.0f,                   -1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.0f,                    float.NegativeInfinity,  float.PositiveInfinity, 0.0f)]
-        [InlineData(-0.0f,                   -3.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData(-0.0f,                   -2.0f,                    float.PositiveInfinity, 0.0f)]
-        [InlineData(-0.0f,                   -1.57079633f,             float.PositiveInfinity, 0.0f)]                                   //          y: -(pi / 2)
-        [InlineData(-0.0f,                   -1.0f,                    float.NegativeInfinity, 0.0f)]
-        [InlineData(-0.0f,                   -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.0f,                    float.NaN,               float.NaN,              0.0f)]
-        [InlineData(-0.0f,                    0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.0f,                    1.0f,                   -0.0f,                   0.0f)]
-        [InlineData(-0.0f,                    1.57079633f,             0.0f,                   0.0f)]                                   //          y: -(pi / 2)
-        [InlineData(-0.0f,                    2.0f,                    0.0f,                   0.0f)]
-        [InlineData(-0.0f,                    3.0f,                   -0.0f,                   0.0f)]
-        [InlineData(-0.0f,                    float.PositiveInfinity,  0.0f,                   0.0f)]
-        [InlineData( float.NaN,               float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData( float.NaN,              -1.0f,                    float.NaN,              0.0f)]
-        [InlineData( float.NaN,               float.NaN,               float.NaN,              0.0f)]
-        [InlineData( float.NaN,               1.0f,                    float.NaN,              0.0f)]
-        [InlineData( float.NaN,               float.PositiveInfinity,  float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    float.NegativeInfinity,  float.PositiveInfinity, 0.0f)]
-        [InlineData( 0.0f,                   -3.0f,                    float.PositiveInfinity, 0.0f)]
-        [InlineData( 0.0f,                   -2.0f,                    float.PositiveInfinity, 0.0f)]
-        [InlineData( 0.0f,                   -1.57079633f,             float.PositiveInfinity, 0.0f)]                                   //          y: -(pi / 2)
-        [InlineData( 0.0f,                   -1.0f,                    float.PositiveInfinity, 0.0f)]
-        [InlineData( 0.0f,                   -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.0f,                    float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 0.0f,                    1.0f,                    0.0f,                   0.0f)]
-        [InlineData( 0.0f,                    1.57079633f,             0.0f,                   0.0f)]                                   //          y: -(pi / 2)
-        [InlineData( 0.0f,                    2.0f,                    0.0f,                   0.0f)]
-        [InlineData( 0.0f,                    3.0f,                    0.0f,                   0.0f)]
-        [InlineData( 0.0f,                    float.PositiveInfinity,  0.0f,                   0.0f)]
-        [InlineData( 1.0f,                    float.NegativeInfinity,  1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.0f,                   -1.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.0f,                   -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.0f,                    0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.0f,                    1.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.0f,                    float.PositiveInfinity,  1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2.71828183f,             float.NegativeInfinity,  0.0f,                   0.0f)]
-        [InlineData( 2.71828183f,            -3.14159265f,             0.0432139183f,          CrossPlatformMachineEpsilon / 10)]       // x:  (e)  y: -(pi)
-        [InlineData( 2.71828183f,            -2.71828183f,             0.0659880358f,          CrossPlatformMachineEpsilon / 10)]       // x:  (e)  y: -(e)
-        [InlineData( 2.71828183f,            -2.30258509f,             0.1f,                   CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(ln(10))
-        [InlineData( 2.71828183f,            -1.57079633f,             0.207879576f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(pi / 2)
-        [InlineData( 2.71828183f,            -1.44269504f,             0.236290088f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(log2(e))
-        [InlineData( 2.71828183f,            -1.41421356f,             0.243116734f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(sqrt(2))
-        [InlineData( 2.71828183f,            -1.12837917f,             0.323557264f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(2 / sqrt(pi))
-        [InlineData( 2.71828183f,            -1.0f,                    0.367879441f,           CrossPlatformMachineEpsilon)]            // x:  (e)
-        [InlineData( 2.71828183f,            -0.785398163f,            0.455938128f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(pi / 4)
-        [InlineData( 2.71828183f,            -0.707106781f,            0.493068691f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(1 / sqrt(2))
-        [InlineData( 2.71828183f,            -0.693147181f,            0.5f,                   CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(ln(2))
-        [InlineData( 2.71828183f,            -0.636619772f,            0.529077808f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(2 / pi)
-        [InlineData( 2.71828183f,            -0.434294482f,            0.647721485f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(log10(e))
-        [InlineData( 2.71828183f,            -0.318309886f,            0.727377349f,           CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(1 / pi)
-        [InlineData( 2.71828183f,            -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]       // x:  (e)
-        [InlineData( 2.71828183f,             float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 2.71828183f,             0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]       // x:  (e)
-        [InlineData( 2.71828183f,             0.318309886f,            1.37480223f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (1 / pi)
-        [InlineData( 2.71828183f,             0.434294482f,            1.54387344f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (log10(e))
-        [InlineData( 2.71828183f,             0.636619772f,            1.89008116f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (2 / pi)
-        [InlineData( 2.71828183f,             0.693147181f,            2.0f,                   CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (ln(2))
-        [InlineData( 2.71828183f,             0.707106781f,            2.02811498f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (1 / sqrt(2))
-        [InlineData( 2.71828183f,             0.785398163f,            2.19328005f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (pi / 4)
-        [InlineData( 2.71828183f,             1.0f,                    2.71828183f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)                      expected: (e)
-        [InlineData( 2.71828183f,             1.12837917f,             3.09064302f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (2 / sqrt(pi))
-        [InlineData( 2.71828183f,             1.41421356f,             4.11325038f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (sqrt(2))
-        [InlineData( 2.71828183f,             1.44269504f,             4.23208611f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (log2(e))
-        [InlineData( 2.71828183f,             1.57079633f,             4.81047738f,            CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (pi / 2)
-        [InlineData( 2.71828183f,             2.30258509f,             10.0f,                  CrossPlatformMachineEpsilon * 100)]      // x:  (e)  y:  (ln(10))
-        [InlineData( 2.71828183f,             2.71828183f,             15.1542622f,            CrossPlatformMachineEpsilon * 100)]      // x:  (e)  y:  (e)
-        [InlineData( 2.71828183f,             3.14159265f,             23.1406926f,            CrossPlatformMachineEpsilon * 100)]      // x:  (e)  y:  (pi)
-        [InlineData( 2.71828183f,             float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]                                   // x:  (e)
-        [InlineData( 10.0f,                   float.NegativeInfinity,  0.0f,                   0.0f)]
-        [InlineData( 10.0f,                  -3.14159265f,             0.000721784159f,        CrossPlatformMachineEpsilon / 1000)]     //          y: -(pi)
-        [InlineData( 10.0f,                  -2.71828183f,             0.00191301410f,         CrossPlatformMachineEpsilon / 100)]      //          y: -(e)
-        [InlineData( 10.0f,                  -2.30258509f,             0.00498212830f,         CrossPlatformMachineEpsilon / 100)]      //          y: -(ln(10))
-        [InlineData( 10.0f,                  -1.57079633f,             0.0268660410f,          CrossPlatformMachineEpsilon / 10)]       //          y: -(pi / 2)
-        [InlineData( 10.0f,                  -1.44269504f,             0.0360831928f,          CrossPlatformMachineEpsilon / 10)]       //          y: -(log2(e))
-        [InlineData( 10.0f,                  -1.41421356f,             0.0385288847f,          CrossPlatformMachineEpsilon / 10)]       //          y: -(sqrt(2))
-        [InlineData( 10.0f,                  -1.12837917f,             0.0744082059f,          CrossPlatformMachineEpsilon / 10)]       //          y: -(2 / sqrt(pi))
-        [InlineData( 10.0f,                  -1.0f,                    0.1f,                   CrossPlatformMachineEpsilon)]
-        [InlineData( 10.0f,                  -0.785398163f,            0.163908636f,           CrossPlatformMachineEpsilon)]            //          y: -(pi / 4)
-        [InlineData( 10.0f,                  -0.707106781f,            0.196287760f,           CrossPlatformMachineEpsilon)]            //          y: -(1 / sqrt(2))
-        [InlineData( 10.0f,                  -0.693147181f,            0.202699566f,           CrossPlatformMachineEpsilon)]            //          y: -(ln(2))
-        [InlineData( 10.0f,                  -0.636619772f,            0.230876765f,           CrossPlatformMachineEpsilon)]            //          y: -(2 / pi)
-        [InlineData( 10.0f,                  -0.434294482f,            0.367879441f,           CrossPlatformMachineEpsilon)]            //          y: -(log10(e))
-        [InlineData( 10.0f,                  -0.318309886f,            0.480496373f,           CrossPlatformMachineEpsilon)]            //          y: -(1 / pi)
-        [InlineData( 10.0f,                  -0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 10.0f,                   float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 10.0f,                   0.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 10.0f,                   0.318309886f,            2.08118116f,            CrossPlatformMachineEpsilon * 10)]       //          y:  (1 / pi)
-        [InlineData( 10.0f,                   0.434294482f,            2.71828183f,            CrossPlatformMachineEpsilon * 10)]       //          y:  (log10(e))      expected: (e)
-        [InlineData( 10.0f,                   0.636619772f,            4.33131503f,            CrossPlatformMachineEpsilon * 10)]       //          y:  (2 / pi)
-        [InlineData( 10.0f,                   0.693147181f,            4.93340967f,            CrossPlatformMachineEpsilon * 10)]       //          y:  (ln(2))
-        [InlineData( 10.0f,                   0.707106781f,            5.09456117f,            CrossPlatformMachineEpsilon * 10)]       //          y:  (1 / sqrt(2))
-        [InlineData( 10.0f,                   0.785398163f,            6.10095980f,            CrossPlatformMachineEpsilon * 10)]       //          y:  (pi / 4)
-        [InlineData( 10.0f,                   1.0f,                    10.0f,                  CrossPlatformMachineEpsilon * 100)]
-        [InlineData( 10.0f,                   1.12837917f,             13.4393779f,            CrossPlatformMachineEpsilon * 100)]      //          y:  (2 / sqrt(pi))
-        [InlineData( 10.0f,                   1.41421356f,             25.9545535f,            CrossPlatformMachineEpsilon * 100)]      //          y:  (sqrt(2))
-        [InlineData( 10.0f,                   1.44269504f,             27.7137338f,            CrossPlatformMachineEpsilon * 100)]      //          y:  (log2(e))
-        [InlineData( 10.0f,                   1.57079633f,             37.2217105f,            CrossPlatformMachineEpsilon * 100)]      //          y:  (pi / 2)
-        [InlineData( 10.0f,                   2.30258509f,             200.717432f,            CrossPlatformMachineEpsilon * 1000)]     //          y:  (ln(10))
-        [InlineData( 10.0f,                   2.71828183f,             522.735300f,            CrossPlatformMachineEpsilon * 1000)]     //          y:  (e)
-        [InlineData( 10.0f,                   3.14159265f,             1385.45573f,            CrossPlatformMachineEpsilon * 10000)]    //          y:  (pi)
-        [InlineData( 10.0f,                   float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
-        [InlineData( float.PositiveInfinity,  float.NegativeInfinity,  0.0f,                   0.0f)]
-        [InlineData( float.PositiveInfinity, -1.0f,                    0.0f,                   0.0f)]
-        [InlineData( float.PositiveInfinity, -0.0f,                    1.0f,                   0.0f)]
-        [InlineData( float.PositiveInfinity,  float.NaN,               float.NaN,              0.0f)]
-        [InlineData( float.PositiveInfinity,  0.0f,                    1.0f,                   0.0f)]
-        [InlineData( float.PositiveInfinity,  1.0f,                    float.PositiveInfinity, 0.0f)]
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NegativeInfinity, 0.0f, 0.0f)]
+        [InlineData(float.NegativeInfinity, -1.0f, -0.0f, 0.0f)]
+        [InlineData(float.NegativeInfinity, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NegativeInfinity, float.NaN, float.NaN, 0.0f)]
+        [InlineData(float.NegativeInfinity, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NegativeInfinity, 1.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(-10.0f, float.NegativeInfinity, 0.0f, 0.0f)]
+        [InlineData(-10.0f, -1.57079633f, float.NaN, 0.0f)]                                   //          y: -(pi / 2)
+        [InlineData(-10.0f, -1.0f, -0.1f, CrossPlatformMachineEpsilon)]
+        [InlineData(-10.0f, -0.785398163f, float.NaN, 0.0f)]                                   //          y: -(pi / 4)
+        [InlineData(-10.0f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-10.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(-10.0f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-10.0f, 0.785398163f, float.NaN, 0.0f)]                                   //          y:  (pi / 4)
+        [InlineData(-10.0f, 1.0f, -10.0f, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(-10.0f, 1.57079633f, float.NaN, 0.0f)]                                   //          y:  (pi / 2)
+        [InlineData(-10.0f, float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(-2.71828183f, float.NegativeInfinity, 0.0f, 0.0f)]                                   // x: -(e)
+        [InlineData(-2.71828183f, -1.57079633f, float.NaN, 0.0f)]                                   // x: -(e)  y: -(pi / 2)
+        [InlineData(-2.71828183f, -1.0f, -0.367879441f, CrossPlatformMachineEpsilon)]            // x: -(e)
+        [InlineData(-2.71828183f, -0.785398163f, float.NaN, 0.0f)]                                   // x: -(e)  y: -(pi / 4)
+        [InlineData(-2.71828183f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]       // x: -(e)
+        [InlineData(-2.71828183f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(-2.71828183f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]       // x: -(e)
+        [InlineData(-2.71828183f, 0.785398163f, float.NaN, 0.0f)]                                   // x: -(e)  y:  (pi / 4)
+        [InlineData(-2.71828183f, 1.0f, -2.71828183f, CrossPlatformMachineEpsilon * 10)]       // x: -(e)  expected: (e)
+        [InlineData(-2.71828183f, 1.57079633f, float.NaN, 0.0f)]                                   // x: -(e)  y:  (pi / 2)
+        [InlineData(-2.71828183f, float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(-1.0f, -1.0f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-1.0f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-1.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(-1.0f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-1.0f, 1.0f, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.0f, float.NegativeInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(-0.0f, -3.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(-0.0f, -2.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(-0.0f, -1.57079633f, float.PositiveInfinity, 0.0f)]                                   //          y: -(pi / 2)
+        [InlineData(-0.0f, -1.0f, float.NegativeInfinity, 0.0f)]
+        [InlineData(-0.0f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(-0.0f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.0f, 1.0f, -0.0f, 0.0f)]
+        [InlineData(-0.0f, 1.57079633f, 0.0f, 0.0f)]                                   //          y: -(pi / 2)
+        [InlineData(-0.0f, 2.0f, 0.0f, 0.0f)]
+        [InlineData(-0.0f, 3.0f, -0.0f, 0.0f)]
+        [InlineData(-0.0f, float.PositiveInfinity, 0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(float.NaN, -1.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, float.NaN, float.NaN, 0.0f)]
+        [InlineData(float.NaN, 1.0f, float.NaN, 0.0f)]
+        [InlineData(float.NaN, float.PositiveInfinity, float.NaN, 0.0f)]
+        [InlineData(0.0f, float.NegativeInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(0.0f, -3.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(0.0f, -2.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(0.0f, -1.57079633f, float.PositiveInfinity, 0.0f)]                                   //          y: -(pi / 2)
+        [InlineData(0.0f, -1.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(0.0f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.0f, 1.0f, 0.0f, 0.0f)]
+        [InlineData(0.0f, 1.57079633f, 0.0f, 0.0f)]                                   //          y: -(pi / 2)
+        [InlineData(0.0f, 2.0f, 0.0f, 0.0f)]
+        [InlineData(0.0f, 3.0f, 0.0f, 0.0f)]
+        [InlineData(0.0f, float.PositiveInfinity, 0.0f, 0.0f)]
+        [InlineData(1.0f, float.NegativeInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0f, -1.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0f, 1.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0f, float.PositiveInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2.71828183f, float.NegativeInfinity, 0.0f, 0.0f)]
+        [InlineData(2.71828183f, -3.14159265f, 0.0432139183f, CrossPlatformMachineEpsilon / 10)]       // x:  (e)  y: -(pi)
+        [InlineData(2.71828183f, -2.71828183f, 0.0659880358f, CrossPlatformMachineEpsilon / 10)]       // x:  (e)  y: -(e)
+        [InlineData(2.71828183f, -2.30258509f, 0.1f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(ln(10))
+        [InlineData(2.71828183f, -1.57079633f, 0.207879576f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(pi / 2)
+        [InlineData(2.71828183f, -1.44269504f, 0.236290088f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(log2(e))
+        [InlineData(2.71828183f, -1.41421356f, 0.243116734f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(sqrt(2))
+        [InlineData(2.71828183f, -1.12837917f, 0.323557264f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(2 / sqrt(pi))
+        [InlineData(2.71828183f, -1.0f, 0.367879441f, CrossPlatformMachineEpsilon)]            // x:  (e)
+        [InlineData(2.71828183f, -0.785398163f, 0.455938128f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(pi / 4)
+        [InlineData(2.71828183f, -0.707106781f, 0.493068691f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(1 / sqrt(2))
+        [InlineData(2.71828183f, -0.693147181f, 0.5f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(ln(2))
+        [InlineData(2.71828183f, -0.636619772f, 0.529077808f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(2 / pi)
+        [InlineData(2.71828183f, -0.434294482f, 0.647721485f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(log10(e))
+        [InlineData(2.71828183f, -0.318309886f, 0.727377349f, CrossPlatformMachineEpsilon)]            // x:  (e)  y: -(1 / pi)
+        [InlineData(2.71828183f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)
+        [InlineData(2.71828183f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(2.71828183f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)
+        [InlineData(2.71828183f, 0.318309886f, 1.37480223f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (1 / pi)
+        [InlineData(2.71828183f, 0.434294482f, 1.54387344f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (log10(e))
+        [InlineData(2.71828183f, 0.636619772f, 1.89008116f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (2 / pi)
+        [InlineData(2.71828183f, 0.693147181f, 2.0f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (ln(2))
+        [InlineData(2.71828183f, 0.707106781f, 2.02811498f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (1 / sqrt(2))
+        [InlineData(2.71828183f, 0.785398163f, 2.19328005f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (pi / 4)
+        [InlineData(2.71828183f, 1.0f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)                      expected: (e)
+        [InlineData(2.71828183f, 1.12837917f, 3.09064302f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (2 / sqrt(pi))
+        [InlineData(2.71828183f, 1.41421356f, 4.11325038f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (sqrt(2))
+        [InlineData(2.71828183f, 1.44269504f, 4.23208611f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (log2(e))
+        [InlineData(2.71828183f, 1.57079633f, 4.81047738f, CrossPlatformMachineEpsilon * 10)]       // x:  (e)  y:  (pi / 2)
+        [InlineData(2.71828183f, 2.30258509f, 10.0f, CrossPlatformMachineEpsilon * 100)]      // x:  (e)  y:  (ln(10))
+        [InlineData(2.71828183f, 2.71828183f, 15.1542622f, CrossPlatformMachineEpsilon * 100)]      // x:  (e)  y:  (e)
+        [InlineData(2.71828183f, 3.14159265f, 23.1406926f, CrossPlatformMachineEpsilon * 100)]      // x:  (e)  y:  (pi)
+        [InlineData(2.71828183f, float.PositiveInfinity, float.PositiveInfinity, 0.0f)]                                   // x:  (e)
+        [InlineData(10.0f, float.NegativeInfinity, 0.0f, 0.0f)]
+        [InlineData(10.0f, -3.14159265f, 0.000721784159f, CrossPlatformMachineEpsilon / 1000)]     //          y: -(pi)
+        [InlineData(10.0f, -2.71828183f, 0.00191301410f, CrossPlatformMachineEpsilon / 100)]      //          y: -(e)
+        [InlineData(10.0f, -2.30258509f, 0.00498212830f, CrossPlatformMachineEpsilon / 100)]      //          y: -(ln(10))
+        [InlineData(10.0f, -1.57079633f, 0.0268660410f, CrossPlatformMachineEpsilon / 10)]       //          y: -(pi / 2)
+        [InlineData(10.0f, -1.44269504f, 0.0360831928f, CrossPlatformMachineEpsilon / 10)]       //          y: -(log2(e))
+        [InlineData(10.0f, -1.41421356f, 0.0385288847f, CrossPlatformMachineEpsilon / 10)]       //          y: -(sqrt(2))
+        [InlineData(10.0f, -1.12837917f, 0.0744082059f, CrossPlatformMachineEpsilon / 10)]       //          y: -(2 / sqrt(pi))
+        [InlineData(10.0f, -1.0f, 0.1f, CrossPlatformMachineEpsilon)]
+        [InlineData(10.0f, -0.785398163f, 0.163908636f, CrossPlatformMachineEpsilon)]            //          y: -(pi / 4)
+        [InlineData(10.0f, -0.707106781f, 0.196287760f, CrossPlatformMachineEpsilon)]            //          y: -(1 / sqrt(2))
+        [InlineData(10.0f, -0.693147181f, 0.202699566f, CrossPlatformMachineEpsilon)]            //          y: -(ln(2))
+        [InlineData(10.0f, -0.636619772f, 0.230876765f, CrossPlatformMachineEpsilon)]            //          y: -(2 / pi)
+        [InlineData(10.0f, -0.434294482f, 0.367879441f, CrossPlatformMachineEpsilon)]            //          y: -(log10(e))
+        [InlineData(10.0f, -0.318309886f, 0.480496373f, CrossPlatformMachineEpsilon)]            //          y: -(1 / pi)
+        [InlineData(10.0f, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(10.0f, float.NaN, float.NaN, 0.0f)]
+        [InlineData(10.0f, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(10.0f, 0.318309886f, 2.08118116f, CrossPlatformMachineEpsilon * 10)]       //          y:  (1 / pi)
+        [InlineData(10.0f, 0.434294482f, 2.71828183f, CrossPlatformMachineEpsilon * 10)]       //          y:  (log10(e))      expected: (e)
+        [InlineData(10.0f, 0.636619772f, 4.33131503f, CrossPlatformMachineEpsilon * 10)]       //          y:  (2 / pi)
+        [InlineData(10.0f, 0.693147181f, 4.93340967f, CrossPlatformMachineEpsilon * 10)]       //          y:  (ln(2))
+        [InlineData(10.0f, 0.707106781f, 5.09456117f, CrossPlatformMachineEpsilon * 10)]       //          y:  (1 / sqrt(2))
+        [InlineData(10.0f, 0.785398163f, 6.10095980f, CrossPlatformMachineEpsilon * 10)]       //          y:  (pi / 4)
+        [InlineData(10.0f, 1.0f, 10.0f, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(10.0f, 1.12837917f, 13.4393779f, CrossPlatformMachineEpsilon * 100)]      //          y:  (2 / sqrt(pi))
+        [InlineData(10.0f, 1.41421356f, 25.9545535f, CrossPlatformMachineEpsilon * 100)]      //          y:  (sqrt(2))
+        [InlineData(10.0f, 1.44269504f, 27.7137338f, CrossPlatformMachineEpsilon * 100)]      //          y:  (log2(e))
+        [InlineData(10.0f, 1.57079633f, 37.2217105f, CrossPlatformMachineEpsilon * 100)]      //          y:  (pi / 2)
+        [InlineData(10.0f, 2.30258509f, 200.717432f, CrossPlatformMachineEpsilon * 1000)]     //          y:  (ln(10))
+        [InlineData(10.0f, 2.71828183f, 522.735300f, CrossPlatformMachineEpsilon * 1000)]     //          y:  (e)
+        [InlineData(10.0f, 3.14159265f, 1385.45573f, CrossPlatformMachineEpsilon * 10000)]    //          y:  (pi)
+        [InlineData(10.0f, float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
+        [InlineData(float.PositiveInfinity, float.NegativeInfinity, 0.0f, 0.0f)]
+        [InlineData(float.PositiveInfinity, -1.0f, 0.0f, 0.0f)]
+        [InlineData(float.PositiveInfinity, -0.0f, 1.0f, 0.0f)]
+        [InlineData(float.PositiveInfinity, float.NaN, float.NaN, 0.0f)]
+        [InlineData(float.PositiveInfinity, 0.0f, 1.0f, 0.0f)]
+        [InlineData(float.PositiveInfinity, 1.0f, float.PositiveInfinity, 0.0f)]
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Pow(float x, float y, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Pow(x, y), allowedVariance);
         }
 
         [Theory]
-        [InlineData(-1.0f,       float.NegativeInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-1.0f,       float.PositiveInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NaN, -0.0f,                   1.0f, CrossPlatformMachineEpsilon * 10)]
-        [InlineData( float.NaN,  0.0f,                   1.0f, CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.0f,       float.NaN,              1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-1.0f, float.NegativeInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-1.0f, float.PositiveInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NaN, -0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NaN, 0.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0f, float.NaN, 1.0f, CrossPlatformMachineEpsilon * 10)]
         public static void Pow_IEEE(float x, float y, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Pow(x, y), allowedVariance);
@@ -1508,41 +1508,41 @@ namespace System.Tests
         {
             get
             {
-                yield return new object[] {float.NaN, float.NaN, 3, MidpointRounding.ToEven};
-                yield return new object[] {float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToEven};
-                yield return new object[] {float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToEven};
-                yield return new object[] {0, 0, 3, MidpointRounding.ToEven};
-                yield return new object[] {3.42156f, 3.422f, 3, MidpointRounding.ToEven};
-                yield return new object[] {-3.42156f, -3.422f, 3, MidpointRounding.ToEven};
-
-                yield return new object[] {float.NaN, float.NaN, 3, MidpointRounding.AwayFromZero};
-                yield return new object[] {float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.AwayFromZero};
-                yield return new object[] {float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.AwayFromZero};
-                yield return new object[] {0, 0, 3, MidpointRounding.AwayFromZero};
-                yield return new object[] {3.42156f, 3.422f, 3, MidpointRounding.AwayFromZero};
-                yield return new object[] {-3.42156f, -3.422f, 3, MidpointRounding.AwayFromZero};
-
-                yield return new object[] {float.NaN, float.NaN, 3, MidpointRounding.ToZero};
-                yield return new object[] {float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToZero};
-                yield return new object[] {float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToZero};
-                yield return new object[] {0, 0, 3, MidpointRounding.ToZero};
-                yield return new object[] {3.42156f, 3.421f, 3, MidpointRounding.ToZero};
-                yield return new object[] {-3.42156f, -3.421f, 3, MidpointRounding.ToZero};
-
-                yield return new object[] {float.NaN, float.NaN, 3, MidpointRounding.ToNegativeInfinity};
-                yield return new object[] {float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToNegativeInfinity};
-                yield return new object[] {float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToNegativeInfinity};
-                yield return new object[] {0, 0, 3, MidpointRounding.ToNegativeInfinity};
-                yield return new object[] {3.42156f, 3.421f, 3, MidpointRounding.ToNegativeInfinity};
-                yield return new object[] {-3.42156f, -3.422f, 3, MidpointRounding.ToNegativeInfinity};
-
-                yield return new object[] {float.NaN, float.NaN, 3, MidpointRounding.ToPositiveInfinity};
-                yield return new object[] {float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToPositiveInfinity};
-                yield return new object[] {float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToPositiveInfinity};
-                yield return new object[] {0, 0, 3, MidpointRounding.ToPositiveInfinity};
-                yield return new object[] {3.42156f, 3.422f, 3, MidpointRounding.ToPositiveInfinity};
-                yield return new object[] {-3.42156f, -3.421f, 3, MidpointRounding.ToPositiveInfinity};
-              }
+                yield return new object[] { float.NaN, float.NaN, 3, MidpointRounding.ToEven };
+                yield return new object[] { float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToEven };
+                yield return new object[] { float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToEven };
+                yield return new object[] { 0, 0, 3, MidpointRounding.ToEven };
+                yield return new object[] { 3.42156f, 3.422f, 3, MidpointRounding.ToEven };
+                yield return new object[] { -3.42156f, -3.422f, 3, MidpointRounding.ToEven };
+
+                yield return new object[] { float.NaN, float.NaN, 3, MidpointRounding.AwayFromZero };
+                yield return new object[] { float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.AwayFromZero };
+                yield return new object[] { float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.AwayFromZero };
+                yield return new object[] { 0, 0, 3, MidpointRounding.AwayFromZero };
+                yield return new object[] { 3.42156f, 3.422f, 3, MidpointRounding.AwayFromZero };
+                yield return new object[] { -3.42156f, -3.422f, 3, MidpointRounding.AwayFromZero };
+
+                yield return new object[] { float.NaN, float.NaN, 3, MidpointRounding.ToZero };
+                yield return new object[] { float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToZero };
+                yield return new object[] { float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToZero };
+                yield return new object[] { 0, 0, 3, MidpointRounding.ToZero };
+                yield return new object[] { 3.42156f, 3.421f, 3, MidpointRounding.ToZero };
+                yield return new object[] { -3.42156f, -3.421f, 3, MidpointRounding.ToZero };
+
+                yield return new object[] { float.NaN, float.NaN, 3, MidpointRounding.ToNegativeInfinity };
+                yield return new object[] { float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToNegativeInfinity };
+                yield return new object[] { float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToNegativeInfinity };
+                yield return new object[] { 0, 0, 3, MidpointRounding.ToNegativeInfinity };
+                yield return new object[] { 3.42156f, 3.421f, 3, MidpointRounding.ToNegativeInfinity };
+                yield return new object[] { -3.42156f, -3.422f, 3, MidpointRounding.ToNegativeInfinity };
+
+                yield return new object[] { float.NaN, float.NaN, 3, MidpointRounding.ToPositiveInfinity };
+                yield return new object[] { float.PositiveInfinity, float.PositiveInfinity, 3, MidpointRounding.ToPositiveInfinity };
+                yield return new object[] { float.NegativeInfinity, float.NegativeInfinity, 3, MidpointRounding.ToPositiveInfinity };
+                yield return new object[] { 0, 0, 3, MidpointRounding.ToPositiveInfinity };
+                yield return new object[] { 3.42156f, 3.422f, 3, MidpointRounding.ToPositiveInfinity };
+                yield return new object[] { -3.42156f, -3.421f, 3, MidpointRounding.ToPositiveInfinity };
+            }
         }
 
         [Fact]
@@ -1573,45 +1573,74 @@ namespace System.Tests
         [MemberData(nameof(Round_Digits_TestData))]
         public static void Round_Digits(float x, float expected, int digits, MidpointRounding mode)
         {
-           AssertEqual(expected, MathF.Round(x, digits, mode), CrossPlatformMachineEpsilon * 10);
+            AssertEqual(expected, MathF.Round(x, digits, mode), CrossPlatformMachineEpsilon * 10);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  unchecked((int)(0x7FFFFFFF)),  float.NegativeInfinity,  0)]
-        [InlineData(-0.113314732f,           -3,                            -0.0141643415f,           CrossPlatformMachineEpsilon / 10)]
-        [InlineData(-0.0f,                    unchecked((int)(0x80000000)), -0.0f,                    0)]
-        [InlineData( float.NaN,               unchecked((int)(0x7FFFFFFF)),  float.NaN,               0)]
-        [InlineData( 0,                       unchecked((int)(0x80000000)),  0,                       0)]
-        [InlineData( 0.113314732f,           -4,                             0.00708217081f,          CrossPlatformMachineEpsilon / 100)]
-        [InlineData( 0.151955223f,           -3,                             0.0189944021f,           CrossPlatformMachineEpsilon / 10)]
-        [InlineData( 0.202699566f,           -3,                             0.0253374465f,           CrossPlatformMachineEpsilon / 10)]
-        [InlineData( 0.336622537f,           -2,                             0.084155634f,            CrossPlatformMachineEpsilon / 10)]
-        [InlineData( 0.367879441f,           -2,                             0.0919698626f,           CrossPlatformMachineEpsilon / 10)]
-        [InlineData( 0.375214227f,           -2,                             0.0938035548f,           CrossPlatformMachineEpsilon / 10)]
-        [InlineData( 0.457429347f,           -2,                             0.114357337f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 0.5f,                   -1,                             0.25f,                   CrossPlatformMachineEpsilon)]
-        [InlineData( 0.580191810f,           -1,                             0.290095896f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 0.612547327f,           -1,                             0.306273669f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 0.618503138f,           -1,                             0.309251577f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 0.643218242f,           -1,                             0.321609110f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 0.740055574f,           -1,                             0.370027781f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 0.802008879f,           -1,                             0.401004434f,            CrossPlatformMachineEpsilon)]
-        [InlineData( 1,                       0,                             1,                       CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.24686899f,             0,                             1.24686899f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.35124987f,             0,                             1.35124987f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.55468228f,             0,                             1.55468228f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.61680667f,             0,                             1.61680667f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.63252692f,             0,                             1.63252692f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.72356793f,             0,                             1.72356793f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2,                       1,                             4,                       CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2.18612996f,             1,                             4.37225992f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2.66514414f,             1,                             5.33028829f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2.71828183f,             1,                             5.43656366f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 2.97068642f,             1,                             5.94137285f,             CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 4.93340967f,             2,                             19.7336387f,             CrossPlatformMachineEpsilon * 100)]
-        [InlineData( 6.58088599f,             2,                             26.3235440f,             CrossPlatformMachineEpsilon * 100)]
-        [InlineData( 8.82497783f,             3,                             70.5998226f,             CrossPlatformMachineEpsilon * 100)]
-        [InlineData( float.PositiveInfinity,  unchecked((int)(0x7FFFFFFF)),  float.PositiveInfinity,  0)]
+        [InlineData(float.NegativeInfinity, unchecked((int)(0x7FFFFFFF)), float.NegativeInfinity, 0)]
+        [InlineData(float.PositiveInfinity, unchecked((int)(0x7FFFFFFF)), float.PositiveInfinity, 0)]
+        [InlineData(float.NaN, 0, float.NaN, 0)]
+        [InlineData(float.NaN, 0, float.NaN, 0)]
+        [InlineData(float.PositiveInfinity, 0, float.PositiveInfinity, 0)]
+        [InlineData(float.NaN, 0, float.NaN, 0)]
+        [InlineData(float.NaN, 1, float.NaN, 0)]
+        [InlineData(float.PositiveInfinity, 2147483647, float.PositiveInfinity, 0)]
+        [InlineData(float.PositiveInfinity, -2147483647, float.PositiveInfinity, 0)]
+        [InlineData(float.NaN, 2147483647, float.NaN, 0)]
+        [InlineData(-0.0f, unchecked((int)(0x80000000)), -0.0f, 0)]
+        [InlineData(float.NaN, unchecked((int)(0x7FFFFFFF)), float.NaN, 0)]
+        [InlineData(0, unchecked((int)(0x80000000)), 0, 0)]
+        [InlineData(0.113314732f, -4, 0.00708217081f, CrossPlatformMachineEpsilon / 100)]
+        [InlineData(-0.113314732f, -3, -0.0141643415f, CrossPlatformMachineEpsilon / 10)]
+        [InlineData(0.151955223f, -3, 0.0189944021f, CrossPlatformMachineEpsilon / 10)]
+        [InlineData(0.202699566f, -3, 0.0253374465f, CrossPlatformMachineEpsilon / 10)]
+        [InlineData(0.336622537f, -2, 0.084155634f, CrossPlatformMachineEpsilon / 10)]
+        [InlineData(0.367879441f, -2, 0.0919698626f, CrossPlatformMachineEpsilon / 10)]
+        [InlineData(0.375214227f, -2, 0.0938035548f, CrossPlatformMachineEpsilon / 10)]
+        [InlineData(0.457429347f, -2, 0.114357337f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.5f, -1, 0.25f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.580191810f, -1, 0.290095896f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.612547327f, -1, 0.306273669f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.618503138f, -1, 0.309251577f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.643218242f, -1, 0.321609110f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.740055574f, -1, 0.370027781f, CrossPlatformMachineEpsilon)]
+        [InlineData(0.802008879f, -1, 0.401004434f, CrossPlatformMachineEpsilon)]
+        [InlineData(0, 2147483647, 0, CrossPlatformMachineEpsilon)]
+        [InlineData(0, -2147483647, 0, CrossPlatformMachineEpsilon)]
+        [InlineData(0, 2147483647, 0, CrossPlatformMachineEpsilon)]
+        [InlineData(1, -1, 0.5, CrossPlatformMachineEpsilon)]
+        [InlineData(1, 0, 1, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.24686899f, 0, 1.24686899f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.35124987f, 0, 1.35124987f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.55468228f, 0, 1.55468228f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.61680667f, 0, 1.61680667f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.63252692f, 0, 1.63252692f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.72356793f, 0, 1.72356793f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2, 1, 4, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2.18612996f, 1, 4.37225992f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2.66514414f, 1, 5.33028829f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2.71828183f, 1, 5.43656366f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(2.97068642f, 1, 5.94137285f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1, 0, 1, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1, 1, 2, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.7014118E+38, -276, 1E-45, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1E-45, 276, 1.7014118E+38, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.0002441, -149, 1E-45, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.74999994, -148, 1E-45, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.50000066, -128, 1.46937E-39, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-8.066849, -2, -2.0167122, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(4.3452396, -1, 2.1726198, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-8.3814335, 0, -8.3814335, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(0.6619859, 3, 5.295887, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.40660393, 4, -6.505663, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-6.5316734, 1, -13.063347, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(9.267057, 2, 37.06823, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(0.56175977, 5, 17.976313, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(0.7741523, 6, 49.545746, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(-0.6787637, 7, -86.88175, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(4.93340967f, 2, 19.7336387f, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(6.58088599f, 2, 26.3235440f, CrossPlatformMachineEpsilon * 100)]
+        [InlineData(8.82497783f, 3, 70.5998226f, CrossPlatformMachineEpsilon * 100)]
         public static void ScaleB(float x, int n, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.ScaleB(x, n), allowedVariance);
@@ -1630,39 +1659,39 @@ namespace System.Tests
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,    0.0f)]
-        [InlineData(-3.14159265f,            -0.0f,         CrossPlatformMachineEpsilon)]       // value: -(pi)
-        [InlineData(-2.71828183f,            -0.410781291f, CrossPlatformMachineEpsilon)]       // value: -(e)
-        [InlineData(-2.30258509f,            -0.743980337f, CrossPlatformMachineEpsilon)]       // value: -(ln(10))
-        [InlineData(-1.57079633f,            -1.0f,         CrossPlatformMachineEpsilon * 10)]  // value: -(pi / 2)
-        [InlineData(-1.44269504f,            -0.991806244f, CrossPlatformMachineEpsilon)]       // value: -(log2(e))
-        [InlineData(-1.41421356f,            -0.987765946f, CrossPlatformMachineEpsilon)]       // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            -0.903719457f, CrossPlatformMachineEpsilon)]       // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   -0.841470985f, CrossPlatformMachineEpsilon)]
-        [InlineData(-0.785398163f,           -0.707106781f, CrossPlatformMachineEpsilon)]       // value: -(pi / 4),        expected: -(1 / sqrt(2))
-        [InlineData(-0.707106781f,           -0.649636939f, CrossPlatformMachineEpsilon)]       // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           -0.638961276f, CrossPlatformMachineEpsilon)]       // value: -(ln(2))
-        [InlineData(-0.636619772f,           -0.594480769f, CrossPlatformMachineEpsilon)]       // value: -(2 / pi)
-        [InlineData(-0.434294482f,           -0.420770483f, CrossPlatformMachineEpsilon)]       // value: -(log10(e))
-        [InlineData(-0.318309886f,           -0.312961796f, CrossPlatformMachineEpsilon)]       // value: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,         0.0f)]
-        [InlineData( float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    0.0f,         0.0f)]
-        [InlineData( 0.318309886f,            0.312961796f, CrossPlatformMachineEpsilon)]       // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.420770483f, CrossPlatformMachineEpsilon)]       // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.594480769f, CrossPlatformMachineEpsilon)]       // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.638961276f, CrossPlatformMachineEpsilon)]       // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.649636939f, CrossPlatformMachineEpsilon)]       // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.707106781f, CrossPlatformMachineEpsilon)]       // value:  (pi / 4),        expected:  (1 / sqrt(2))
-        [InlineData( 1.0f,                    0.841470985f, CrossPlatformMachineEpsilon)]
-        [InlineData( 1.12837917f,             0.903719457f, CrossPlatformMachineEpsilon)]       // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             0.987765946f, CrossPlatformMachineEpsilon)]       // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             0.991806244f, CrossPlatformMachineEpsilon)]       // value:  (log2(e))
-        [InlineData( 1.57079633f,             1.0f,         CrossPlatformMachineEpsilon * 10)]  // value:  (pi / 2)
-        [InlineData( 2.30258509f,             0.743980337f, CrossPlatformMachineEpsilon)]       // value:  (ln(10))
-        [InlineData( 2.71828183f,             0.410781291f, CrossPlatformMachineEpsilon)]       // value:  (e)
-        [InlineData( 3.14159265f,             0.0f,         CrossPlatformMachineEpsilon)]       // value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.NaN,    0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, -0.0f, CrossPlatformMachineEpsilon)]       // value: -(pi)
+        [InlineData(-2.71828183f, -0.410781291f, CrossPlatformMachineEpsilon)]       // value: -(e)
+        [InlineData(-2.30258509f, -0.743980337f, CrossPlatformMachineEpsilon)]       // value: -(ln(10))
+        [InlineData(-1.57079633f, -1.0f, CrossPlatformMachineEpsilon * 10)]  // value: -(pi / 2)
+        [InlineData(-1.44269504f, -0.991806244f, CrossPlatformMachineEpsilon)]       // value: -(log2(e))
+        [InlineData(-1.41421356f, -0.987765946f, CrossPlatformMachineEpsilon)]       // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -0.903719457f, CrossPlatformMachineEpsilon)]       // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -0.841470985f, CrossPlatformMachineEpsilon)]
+        [InlineData(-0.785398163f, -0.707106781f, CrossPlatformMachineEpsilon)]       // value: -(pi / 4),        expected: -(1 / sqrt(2))
+        [InlineData(-0.707106781f, -0.649636939f, CrossPlatformMachineEpsilon)]       // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.638961276f, CrossPlatformMachineEpsilon)]       // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.594480769f, CrossPlatformMachineEpsilon)]       // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.420770483f, CrossPlatformMachineEpsilon)]       // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.312961796f, CrossPlatformMachineEpsilon)]       // value: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.312961796f, CrossPlatformMachineEpsilon)]       // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.420770483f, CrossPlatformMachineEpsilon)]       // value:  (log10(e))
+        [InlineData(0.636619772f, 0.594480769f, CrossPlatformMachineEpsilon)]       // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.638961276f, CrossPlatformMachineEpsilon)]       // value:  (ln(2))
+        [InlineData(0.707106781f, 0.649636939f, CrossPlatformMachineEpsilon)]       // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.707106781f, CrossPlatformMachineEpsilon)]       // value:  (pi / 4),        expected:  (1 / sqrt(2))
+        [InlineData(1.0f, 0.841470985f, CrossPlatformMachineEpsilon)]
+        [InlineData(1.12837917f, 0.903719457f, CrossPlatformMachineEpsilon)]       // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 0.987765946f, CrossPlatformMachineEpsilon)]       // value:  (sqrt(2))
+        [InlineData(1.44269504f, 0.991806244f, CrossPlatformMachineEpsilon)]       // value:  (log2(e))
+        [InlineData(1.57079633f, 1.0f, CrossPlatformMachineEpsilon * 10)]  // value:  (pi / 2)
+        [InlineData(2.30258509f, 0.743980337f, CrossPlatformMachineEpsilon)]       // value:  (ln(10))
+        [InlineData(2.71828183f, 0.410781291f, CrossPlatformMachineEpsilon)]       // value:  (e)
+        [InlineData(3.14159265f, 0.0f, CrossPlatformMachineEpsilon)]       // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.NaN, 0.0f)]
         public static void Sin(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Sin(value), allowedVariance);
@@ -1749,117 +1778,117 @@ namespace System.Tests
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-3.14159265f,             float.NaN,              0.0f)]                                 // value: (pi)
-        [InlineData(-2.71828183f,             float.NaN,              0.0f)]                                 // value: (e)
-        [InlineData(-2.30258509f,             float.NaN,              0.0f)]                                 // value: (ln(10))
-        [InlineData(-1.57079633f,             float.NaN,              0.0f)]                                 // value: (pi / 2)
-        [InlineData(-1.44269504f,             float.NaN,              0.0f)]                                 // value: (log2(e))
-        [InlineData(-1.41421356f,             float.NaN,              0.0f)]                                 // value: (sqrt(2))
-        [InlineData(-1.12837917f,             float.NaN,              0.0f)]                                 // value: (2 / sqrt(pi))
-        [InlineData(-1.0f,                    float.NaN,              0.0f)]
-        [InlineData(-0.785398163f,            float.NaN,              0.0f)]                                 // value: (pi / 4)
-        [InlineData(-0.707106781f,            float.NaN,              0.0f)]                                 // value: (1 / sqrt(2))
-        [InlineData(-0.693147181f,            float.NaN,              0.0f)]                                 // value: (ln(2))
-        [InlineData(-0.636619772f,            float.NaN,              0.0f)]                                 // value: (2 / pi)
-        [InlineData(-0.434294482f,            float.NaN,              0.0f)]                                 // value: (log10(e))
-        [InlineData(-0.318309886f,            float.NaN,              0.0f)]                                 // value: (1 / pi)
-        [InlineData(-0.0f,                   -0.0f,                   0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    0.0f,                   0.0f)]
-        [InlineData( 0.318309886f,            0.564189584f,           CrossPlatformMachineEpsilon)]          // value: (1 / pi)
-        [InlineData( 0.434294482f,            0.659010229f,           CrossPlatformMachineEpsilon)]          // value: (log10(e))
-        [InlineData( 0.636619772f,            0.797884561f,           CrossPlatformMachineEpsilon)]          // value: (2 / pi)
-        [InlineData( 0.693147181f,            0.832554611f,           CrossPlatformMachineEpsilon)]          // value: (ln(2))
-        [InlineData( 0.707106781f,            0.840896415f,           CrossPlatformMachineEpsilon)]          // value: (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.886226925f,           CrossPlatformMachineEpsilon)]          // value: (pi / 4)
-        [InlineData( 1.0f,                    1.0f,                   CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.12837917f,             1.06225193f,            CrossPlatformMachineEpsilon * 10)]     // value: (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             1.18920712f,            CrossPlatformMachineEpsilon * 10)]     // value: (sqrt(2))
-        [InlineData( 1.44269504f,             1.20112241f,            CrossPlatformMachineEpsilon * 10)]     // value: (log2(e))
-        [InlineData( 1.57079633f,             1.25331414f,            CrossPlatformMachineEpsilon * 10)]     // value: (pi / 2)
-        [InlineData( 2.30258509f,             1.51742713f,            CrossPlatformMachineEpsilon * 10)]     // value: (ln(10))
-        [InlineData( 2.71828183f,             1.64872127f,            CrossPlatformMachineEpsilon * 10)]     // value: (e)
-        [InlineData( 3.14159265f,             1.77245385F,            CrossPlatformMachineEpsilon * 10)]     // value: (pi)
-        [InlineData( float.PositiveInfinity,  float.PositiveInfinity, 0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, float.NaN, 0.0f)]                                 // value: (pi)
+        [InlineData(-2.71828183f, float.NaN, 0.0f)]                                 // value: (e)
+        [InlineData(-2.30258509f, float.NaN, 0.0f)]                                 // value: (ln(10))
+        [InlineData(-1.57079633f, float.NaN, 0.0f)]                                 // value: (pi / 2)
+        [InlineData(-1.44269504f, float.NaN, 0.0f)]                                 // value: (log2(e))
+        [InlineData(-1.41421356f, float.NaN, 0.0f)]                                 // value: (sqrt(2))
+        [InlineData(-1.12837917f, float.NaN, 0.0f)]                                 // value: (2 / sqrt(pi))
+        [InlineData(-1.0f, float.NaN, 0.0f)]
+        [InlineData(-0.785398163f, float.NaN, 0.0f)]                                 // value: (pi / 4)
+        [InlineData(-0.707106781f, float.NaN, 0.0f)]                                 // value: (1 / sqrt(2))
+        [InlineData(-0.693147181f, float.NaN, 0.0f)]                                 // value: (ln(2))
+        [InlineData(-0.636619772f, float.NaN, 0.0f)]                                 // value: (2 / pi)
+        [InlineData(-0.434294482f, float.NaN, 0.0f)]                                 // value: (log10(e))
+        [InlineData(-0.318309886f, float.NaN, 0.0f)]                                 // value: (1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.564189584f, CrossPlatformMachineEpsilon)]          // value: (1 / pi)
+        [InlineData(0.434294482f, 0.659010229f, CrossPlatformMachineEpsilon)]          // value: (log10(e))
+        [InlineData(0.636619772f, 0.797884561f, CrossPlatformMachineEpsilon)]          // value: (2 / pi)
+        [InlineData(0.693147181f, 0.832554611f, CrossPlatformMachineEpsilon)]          // value: (ln(2))
+        [InlineData(0.707106781f, 0.840896415f, CrossPlatformMachineEpsilon)]          // value: (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.886226925f, CrossPlatformMachineEpsilon)]          // value: (pi / 4)
+        [InlineData(1.0f, 1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.12837917f, 1.06225193f, CrossPlatformMachineEpsilon * 10)]     // value: (2 / sqrt(pi))
+        [InlineData(1.41421356f, 1.18920712f, CrossPlatformMachineEpsilon * 10)]     // value: (sqrt(2))
+        [InlineData(1.44269504f, 1.20112241f, CrossPlatformMachineEpsilon * 10)]     // value: (log2(e))
+        [InlineData(1.57079633f, 1.25331414f, CrossPlatformMachineEpsilon * 10)]     // value: (pi / 2)
+        [InlineData(2.30258509f, 1.51742713f, CrossPlatformMachineEpsilon * 10)]     // value: (ln(10))
+        [InlineData(2.71828183f, 1.64872127f, CrossPlatformMachineEpsilon * 10)]     // value: (e)
+        [InlineData(3.14159265f, 1.77245385F, CrossPlatformMachineEpsilon * 10)]     // value: (pi)
+        [InlineData(float.PositiveInfinity, float.PositiveInfinity, 0.0f)]
         public static void Sqrt(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Sqrt(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity,  float.NaN,              0.0f)]
-        [InlineData(-3.14159265f,            -0.0f,                   CrossPlatformMachineEpsilon)]         // value: -(pi)
-        [InlineData(-2.71828183f,             0.450549534f,           CrossPlatformMachineEpsilon)]         // value: -(e)
-        [InlineData(-2.30258509f,             1.11340715f,            CrossPlatformMachineEpsilon * 10)]    // value: -(ln(10))
-        [InlineData(-1.57079633f,             22877332.0f,            10.0f)]                               // value: -(pi / 2)
-        [InlineData(-1.44269504f,            -7.76357567f,            CrossPlatformMachineEpsilon * 10)]    // value: -(log2(e))
-        [InlineData(-1.41421356f,            -6.33411917f,            CrossPlatformMachineEpsilon * 10)]    // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            -2.11087684f,            CrossPlatformMachineEpsilon * 10)]    // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   -1.55740772f,            CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-0.785398163f,           -1.0f,                   CrossPlatformMachineEpsilon * 10)]    // value: -(pi / 4)
-        [InlineData(-0.707106781f,           -0.854510432f,           CrossPlatformMachineEpsilon)]         // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           -0.830640878f,           CrossPlatformMachineEpsilon)]         // value: -(ln(2))
-        [InlineData(-0.636619772f,           -0.739302950f,           CrossPlatformMachineEpsilon)]         // value: -(2 / pi)
-        [InlineData(-0.434294482f,           -0.463829067f,           CrossPlatformMachineEpsilon)]         // value: -(log10(e))
-        [InlineData(-0.318309886f,           -0.329514733f,           CrossPlatformMachineEpsilon)]         // value: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,                   0.0f)]
-        [InlineData( float.NaN,               float.NaN,              0.0f)]
-        [InlineData( 0.0f,                    0.0f,                   0.0f)]
-        [InlineData( 0.318309886f,            0.329514733f,           CrossPlatformMachineEpsilon)]         // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.463829067f,           CrossPlatformMachineEpsilon)]         // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.739302950f,           CrossPlatformMachineEpsilon)]         // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.830640878f,           CrossPlatformMachineEpsilon)]         // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.854510432f,           CrossPlatformMachineEpsilon)]         // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            1.0f,                   CrossPlatformMachineEpsilon * 10)]    // value:  (pi / 4)
-        [InlineData( 1.0f,                    1.55740772f,            CrossPlatformMachineEpsilon * 10)]
-        [InlineData( 1.12837917f,             2.11087684f,            CrossPlatformMachineEpsilon * 10)]    // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             6.33411917f,            CrossPlatformMachineEpsilon * 10)]    // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             7.76357567f,            CrossPlatformMachineEpsilon * 10)]    // value:  (log2(e))
-        [InlineData( 1.57079633f,            -22877332.0f,            10.0f)]                               // value:  (pi / 2)
-        [InlineData( 2.30258509f,            -1.11340715f,            CrossPlatformMachineEpsilon * 10)]    // value:  (ln(10))
-        [InlineData( 2.71828183f,            -0.450549534f,           CrossPlatformMachineEpsilon)]         // value:  (e)
-        [InlineData( 3.14159265f,             0.0f,                   CrossPlatformMachineEpsilon)]         // value:  (pi)
-        [InlineData( float.PositiveInfinity,  float.NaN,              0.0f)]
+        [InlineData(float.NegativeInfinity, float.NaN, 0.0f)]
+        [InlineData(-3.14159265f, -0.0f, CrossPlatformMachineEpsilon)]         // value: -(pi)
+        [InlineData(-2.71828183f, 0.450549534f, CrossPlatformMachineEpsilon)]         // value: -(e)
+        [InlineData(-2.30258509f, 1.11340715f, CrossPlatformMachineEpsilon * 10)]    // value: -(ln(10))
+        [InlineData(-1.57079633f, 22877332.0f, 10.0f)]                               // value: -(pi / 2)
+        [InlineData(-1.44269504f, -7.76357567f, CrossPlatformMachineEpsilon * 10)]    // value: -(log2(e))
+        [InlineData(-1.41421356f, -6.33411917f, CrossPlatformMachineEpsilon * 10)]    // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -2.11087684f, CrossPlatformMachineEpsilon * 10)]    // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -1.55740772f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-0.785398163f, -1.0f, CrossPlatformMachineEpsilon * 10)]    // value: -(pi / 4)
+        [InlineData(-0.707106781f, -0.854510432f, CrossPlatformMachineEpsilon)]         // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.830640878f, CrossPlatformMachineEpsilon)]         // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.739302950f, CrossPlatformMachineEpsilon)]         // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.463829067f, CrossPlatformMachineEpsilon)]         // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.329514733f, CrossPlatformMachineEpsilon)]         // value: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.329514733f, CrossPlatformMachineEpsilon)]         // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.463829067f, CrossPlatformMachineEpsilon)]         // value:  (log10(e))
+        [InlineData(0.636619772f, 0.739302950f, CrossPlatformMachineEpsilon)]         // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.830640878f, CrossPlatformMachineEpsilon)]         // value:  (ln(2))
+        [InlineData(0.707106781f, 0.854510432f, CrossPlatformMachineEpsilon)]         // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 1.0f, CrossPlatformMachineEpsilon * 10)]    // value:  (pi / 4)
+        [InlineData(1.0f, 1.55740772f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(1.12837917f, 2.11087684f, CrossPlatformMachineEpsilon * 10)]    // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 6.33411917f, CrossPlatformMachineEpsilon * 10)]    // value:  (sqrt(2))
+        [InlineData(1.44269504f, 7.76357567f, CrossPlatformMachineEpsilon * 10)]    // value:  (log2(e))
+        [InlineData(1.57079633f, -22877332.0f, 10.0f)]                               // value:  (pi / 2)
+        [InlineData(2.30258509f, -1.11340715f, CrossPlatformMachineEpsilon * 10)]    // value:  (ln(10))
+        [InlineData(2.71828183f, -0.450549534f, CrossPlatformMachineEpsilon)]         // value:  (e)
+        [InlineData(3.14159265f, 0.0f, CrossPlatformMachineEpsilon)]         // value:  (pi)
+        [InlineData(float.PositiveInfinity, float.NaN, 0.0f)]
         public static void Tan(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Tan(value), allowedVariance);
         }
 
         [Theory]
-        [InlineData( float.NegativeInfinity, -1.0f,         CrossPlatformMachineEpsilon * 10)]
-        [InlineData(-3.14159265f,            -0.996272076f, CrossPlatformMachineEpsilon)]       // value: -(pi)
-        [InlineData(-2.71828183f,            -0.991328916f, CrossPlatformMachineEpsilon)]       // value: -(e)
-        [InlineData(-2.30258509f,            -0.980198020f, CrossPlatformMachineEpsilon)]       // value: -(ln(10))
-        [InlineData(-1.57079633f,            -0.917152336f, CrossPlatformMachineEpsilon)]       // value: -(pi / 2)
-        [InlineData(-1.44269504f,            -0.894238946f, CrossPlatformMachineEpsilon)]       // value: -(log2(e))
-        [InlineData(-1.41421356f,            -0.888385562f, CrossPlatformMachineEpsilon)]       // value: -(sqrt(2))
-        [InlineData(-1.12837917f,            -0.810463806f, CrossPlatformMachineEpsilon)]       // value: -(2 / sqrt(pi))
-        [InlineData(-1.0f,                   -0.761594156f, CrossPlatformMachineEpsilon)]
-        [InlineData(-0.785398163f,           -0.655794203f, CrossPlatformMachineEpsilon)]       // value: -(pi / 4)
-        [InlineData(-0.707106781f,           -0.608859365f, CrossPlatformMachineEpsilon)]       // value: -(1 / sqrt(2))
-        [InlineData(-0.693147181f,           -0.6f,         CrossPlatformMachineEpsilon)]       // value: -(ln(2))
-        [InlineData(-0.636619772f,           -0.562593600f, CrossPlatformMachineEpsilon)]       // value: -(2 / pi)
-        [InlineData(-0.434294482f,           -0.408904012f, CrossPlatformMachineEpsilon)]       // value: -(log10(e))
-        [InlineData(-0.318309886f,           -0.307977913f, CrossPlatformMachineEpsilon)]       // value: -(1 / pi)
-        [InlineData(-0.0f,                   -0.0f,         0.0f)]
-        [InlineData( float.NaN,               float.NaN,    0.0f)]
-        [InlineData( 0.0f,                    0.0f,         0.0f)]
-        [InlineData( 0.318309886f,            0.307977913f, CrossPlatformMachineEpsilon)]       // value:  (1 / pi)
-        [InlineData( 0.434294482f,            0.408904012f, CrossPlatformMachineEpsilon)]       // value:  (log10(e))
-        [InlineData( 0.636619772f,            0.562593600f, CrossPlatformMachineEpsilon)]       // value:  (2 / pi)
-        [InlineData( 0.693147181f,            0.6f,         CrossPlatformMachineEpsilon)]       // value:  (ln(2))
-        [InlineData( 0.707106781f,            0.608859365f, CrossPlatformMachineEpsilon)]       // value:  (1 / sqrt(2))
-        [InlineData( 0.785398163f,            0.655794203f, CrossPlatformMachineEpsilon)]       // value:  (pi / 4)
-        [InlineData( 1.0f,                    0.761594156f, CrossPlatformMachineEpsilon)]
-        [InlineData( 1.12837917f,             0.810463806f, CrossPlatformMachineEpsilon)]       // value:  (2 / sqrt(pi))
-        [InlineData( 1.41421356f,             0.888385562f, CrossPlatformMachineEpsilon)]       // value:  (sqrt(2))
-        [InlineData( 1.44269504f,             0.894238946f, CrossPlatformMachineEpsilon)]       // value:  (log2(e))
-        [InlineData( 1.57079633f,             0.917152336f, CrossPlatformMachineEpsilon)]       // value:  (pi / 2)
-        [InlineData( 2.30258509f,             0.980198020f, CrossPlatformMachineEpsilon)]       // value:  (ln(10))
-        [InlineData( 2.71828183f,             0.991328916f, CrossPlatformMachineEpsilon)]       // value:  (e)
-        [InlineData( 3.14159265f,             0.996272076f, CrossPlatformMachineEpsilon)]       // value:  (pi)
-        [InlineData( float.PositiveInfinity,  1.0f,         CrossPlatformMachineEpsilon * 10)]
+        [InlineData(float.NegativeInfinity, -1.0f, CrossPlatformMachineEpsilon * 10)]
+        [InlineData(-3.14159265f, -0.996272076f, CrossPlatformMachineEpsilon)]       // value: -(pi)
+        [InlineData(-2.71828183f, -0.991328916f, CrossPlatformMachineEpsilon)]       // value: -(e)
+        [InlineData(-2.30258509f, -0.980198020f, CrossPlatformMachineEpsilon)]       // value: -(ln(10))
+        [InlineData(-1.57079633f, -0.917152336f, CrossPlatformMachineEpsilon)]       // value: -(pi / 2)
+        [InlineData(-1.44269504f, -0.894238946f, CrossPlatformMachineEpsilon)]       // value: -(log2(e))
+        [InlineData(-1.41421356f, -0.888385562f, CrossPlatformMachineEpsilon)]       // value: -(sqrt(2))
+        [InlineData(-1.12837917f, -0.810463806f, CrossPlatformMachineEpsilon)]       // value: -(2 / sqrt(pi))
+        [InlineData(-1.0f, -0.761594156f, CrossPlatformMachineEpsilon)]
+        [InlineData(-0.785398163f, -0.655794203f, CrossPlatformMachineEpsilon)]       // value: -(pi / 4)
+        [InlineData(-0.707106781f, -0.608859365f, CrossPlatformMachineEpsilon)]       // value: -(1 / sqrt(2))
+        [InlineData(-0.693147181f, -0.6f, CrossPlatformMachineEpsilon)]       // value: -(ln(2))
+        [InlineData(-0.636619772f, -0.562593600f, CrossPlatformMachineEpsilon)]       // value: -(2 / pi)
+        [InlineData(-0.434294482f, -0.408904012f, CrossPlatformMachineEpsilon)]       // value: -(log10(e))
+        [InlineData(-0.318309886f, -0.307977913f, CrossPlatformMachineEpsilon)]       // value: -(1 / pi)
+        [InlineData(-0.0f, -0.0f, 0.0f)]
+        [InlineData(float.NaN, float.NaN, 0.0f)]
+        [InlineData(0.0f, 0.0f, 0.0f)]
+        [InlineData(0.318309886f, 0.307977913f, CrossPlatformMachineEpsilon)]       // value:  (1 / pi)
+        [InlineData(0.434294482f, 0.408904012f, CrossPlatformMachineEpsilon)]       // value:  (log10(e))
+        [InlineData(0.636619772f, 0.562593600f, CrossPlatformMachineEpsilon)]       // value:  (2 / pi)
+        [InlineData(0.693147181f, 0.6f, CrossPlatformMachineEpsilon)]       // value:  (ln(2))
+        [InlineData(0.707106781f, 0.608859365f, CrossPlatformMachineEpsilon)]       // value:  (1 / sqrt(2))
+        [InlineData(0.785398163f, 0.655794203f, CrossPlatformMachineEpsilon)]       // value:  (pi / 4)
+        [InlineData(1.0f, 0.761594156f, CrossPlatformMachineEpsilon)]
+        [InlineData(1.12837917f, 0.810463806f, CrossPlatformMachineEpsilon)]       // value:  (2 / sqrt(pi))
+        [InlineData(1.41421356f, 0.888385562f, CrossPlatformMachineEpsilon)]       // value:  (sqrt(2))
+        [InlineData(1.44269504f, 0.894238946f, CrossPlatformMachineEpsilon)]       // value:  (log2(e))
+        [InlineData(1.57079633f, 0.917152336f, CrossPlatformMachineEpsilon)]       // value:  (pi / 2)
+        [InlineData(2.30258509f, 0.980198020f, CrossPlatformMachineEpsilon)]       // value:  (ln(10))
+        [InlineData(2.71828183f, 0.991328916f, CrossPlatformMachineEpsilon)]       // value:  (e)
+        [InlineData(3.14159265f, 0.996272076f, CrossPlatformMachineEpsilon)]       // value:  (pi)
+        [InlineData(float.PositiveInfinity, 1.0f, CrossPlatformMachineEpsilon * 10)]
         public static void Tanh(float value, float expectedResult, float allowedVariance)
         {
             AssertEqual(expectedResult, MathF.Tanh(value), allowedVariance);

diff --git a/src/mono/mono/metadata/icall-decl.h b/src/mono/mono/metadata/icall-decl.h
index 16b5278..b00b1aa 100644 (file)
--- a/src/mono/mono/metadata/icall-decl.h
+++ b/src/mono/mono/metadata/icall-decl.h
@@ -139,11 +139,9 @@ ICALL_EXPORT float ves_icall_System_Math_Abs_single (float);
 #if ENABLE_NETCORE
 ICALL_EXPORT gint32 ves_icall_System_Math_ILogB (double);
 ICALL_EXPORT double ves_icall_System_Math_Log2 (double);
-ICALL_EXPORT double ves_icall_System_Math_ScaleB (double, gint32);
 ICALL_EXPORT double ves_icall_System_Math_FusedMultiplyAdd (double, double, double);
 ICALL_EXPORT gint32 ves_icall_System_MathF_ILogB (float);
 ICALL_EXPORT float ves_icall_System_MathF_Log2 (float);
-ICALL_EXPORT float ves_icall_System_MathF_ScaleB (float, gint32);
 ICALL_EXPORT float ves_icall_System_MathF_FusedMultiplyAdd (float, float, float);
 #endif
 ICALL_EXPORT gint ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void);

diff --git a/src/mono/mono/metadata/icall-def-netcore.h b/src/mono/mono/metadata/icall-def-netcore.h
index 5146c88..ac9d50b 100644 (file)
--- a/src/mono/mono/metadata/icall-def-netcore.h
+++ b/src/mono/mono/metadata/icall-def-netcore.h
@@ -145,7 +145,6 @@ NOHANDLES(ICALL(MATH_24, "Log2", ves_icall_System_Math_Log2))
 NOHANDLES(ICALL(MATH_10a, "ModF", ves_icall_System_Math_ModF))
 NOHANDLES(ICALL(MATH_11, "Pow", ves_icall_System_Math_Pow))
 NOHANDLES(ICALL(MATH_12, "Round", ves_icall_System_Math_Round))
-NOHANDLES(ICALL(MATH_25, "ScaleB", ves_icall_System_Math_ScaleB))
 NOHANDLES(ICALL(MATH_14, "Sin", ves_icall_System_Math_Sin))
 NOHANDLES(ICALL(MATH_15, "Sinh", ves_icall_System_Math_Sinh))
 NOHANDLES(ICALL(MATH_16, "Sqrt", ves_icall_System_Math_Sqrt))
@@ -174,7 +173,6 @@ NOHANDLES(ICALL(MATHF_15, "Log10", ves_icall_System_MathF_Log10))
 NOHANDLES(ICALL(MATHF_26, "Log2", ves_icall_System_MathF_Log2))
 NOHANDLES(ICALL(MATHF_23, "ModF(single,single*)", ves_icall_System_MathF_ModF))
 NOHANDLES(ICALL(MATHF_16, "Pow", ves_icall_System_MathF_Pow))
-NOHANDLES(ICALL(MATHF_27, "ScaleB", ves_icall_System_MathF_ScaleB))
 NOHANDLES(ICALL(MATHF_17, "Sin", ves_icall_System_MathF_Sin))
 NOHANDLES(ICALL(MATHF_18, "Sinh", ves_icall_System_MathF_Sinh))
 NOHANDLES(ICALL(MATHF_19, "Sqrt", ves_icall_System_MathF_Sqrt))

diff --git a/src/mono/mono/metadata/sysmath.c b/src/mono/mono/metadata/sysmath.c
index b3775e5..b845711 100644 (file)
--- a/src/mono/mono/metadata/sysmath.c
+++ b/src/mono/mono/metadata/sysmath.c
@@ -207,12 +207,6 @@ ves_icall_System_Math_Log2 (gdouble x)
 }
 
 gdouble
-ves_icall_System_Math_ScaleB (gdouble x, gint32 n)
-{
-       return scalbn (x, n);
-}
-
-gdouble
 ves_icall_System_Math_FusedMultiplyAdd (gdouble x, gdouble y, gdouble z)
 {
        return fma (x, y, z);
@@ -376,12 +370,6 @@ ves_icall_System_MathF_Log2 (float x)
 }
 
 float
-ves_icall_System_MathF_ScaleB (float x, gint32 n)
-{
-       return scalbnf (x, n);
-}
-
-float
 ves_icall_System_MathF_FusedMultiplyAdd (float x, float y, float z)
 {
        return fmaf (x, y, z);

diff --git a/src/mono/netcore/System.Private.CoreLib/src/System/Math.Mono.cs b/src/mono/netcore/System.Private.CoreLib/src/System/Math.Mono.cs
index 6854997..5b626e3 100644 (file)
--- a/src/mono/netcore/System.Private.CoreLib/src/System/Math.Mono.cs
+++ b/src/mono/netcore/System.Private.CoreLib/src/System/Math.Mono.cs
@@ -89,9 +89,6 @@ namespace System
         public static extern double Log2(double x);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern double ScaleB(double x, int n);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern double FMod(double x, double y);
 
         [MethodImpl(MethodImplOptions.InternalCall)]

diff --git a/src/mono/netcore/System.Private.CoreLib/src/System/MathF.Mono.cs b/src/mono/netcore/System.Private.CoreLib/src/System/MathF.Mono.cs
index 43b2c92..da8f160 100644 (file)
--- a/src/mono/netcore/System.Private.CoreLib/src/System/MathF.Mono.cs
+++ b/src/mono/netcore/System.Private.CoreLib/src/System/MathF.Mono.cs
@@ -83,9 +83,6 @@ namespace System
         public static extern float Log2(float x);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        public static extern float ScaleB(float x, int n);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern float FMod(float x, float y);
 
         [MethodImpl(MethodImplOptions.InternalCall)]