Fix some small bugs in the Sin, Cos, and SinCos impls

tannergooding · tannergooding · commit 549ef80a3e46 · 2024-07-15T07:17:32.000-07:00
diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
@@ -4546,7 +4546,7 @@ public void CosDoubleTest(double value, double expectedResult, double variance)
 
         [Theory]
         [MemberData(nameof(GenericMathTestMemberData.CosSingle), MemberType = typeof(GenericMathTestMemberData))]
-        public void CosCosgleTest(float value, float expectedResult, float variance)
+        public void CosSingleTest(float value, float expectedResult, float variance)
         {
             Vector<float> actualResult = Vector.Cos(Vector.Create(value));
             AssertEqual(Vector.Create(expectedResult), actualResult, Vector.Create(variance));
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
@@ -3207,7 +3207,7 @@ public static Vector128<double> Sin(Vector128<double> vector)
         {
             if (IsHardwareAccelerated)
             {
-                return VectorMath.CosDouble<Vector128<double>, Vector128<long>>(vector);
+                return VectorMath.SinDouble<Vector128<double>, Vector128<long>>(vector);
             }
             else
             {
@@ -3226,11 +3226,11 @@ public static Vector128<float> Sin(Vector128<float> vector)
             {
                 if (Vector256.IsHardwareAccelerated)
                 {
-                    return VectorMath.CosSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector);
+                    return VectorMath.SinSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector);
                 }
                 else
                 {
-                    return VectorMath.CosSingle<Vector128<float>, Vector128<int>, Vector128<double>, Vector128<long>>(vector);
+                    return VectorMath.SinSingle<Vector128<float>, Vector128<int>, Vector128<double>, Vector128<long>>(vector);
                 }
             }
             else
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
@@ -3090,7 +3090,7 @@ public static Vector256<double> Sin(Vector256<double> vector)
         {
             if (IsHardwareAccelerated)
             {
-                return VectorMath.CosDouble<Vector256<double>, Vector256<long>>(vector);
+                return VectorMath.SinDouble<Vector256<double>, Vector256<long>>(vector);
             }
             else
             {
@@ -3109,11 +3109,11 @@ public static Vector256<float> Sin(Vector256<float> vector)
             {
                 if (Vector512.IsHardwareAccelerated)
                 {
-                    return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector);
+                    return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector);
                 }
                 else
                 {
-                    return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector);
+                    return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector);
                 }
             }
             else
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
@@ -3131,7 +3131,7 @@ public static Vector512<double> Sin(Vector512<double> vector)
         {
             if (IsHardwareAccelerated)
             {
-                return VectorMath.CosDouble<Vector512<double>, Vector512<long>>(vector);
+                return VectorMath.SinDouble<Vector512<double>, Vector512<long>>(vector);
             }
             else
             {
@@ -3148,7 +3148,7 @@ public static Vector512<float> Sin(Vector512<float> vector)
         {
             if (IsHardwareAccelerated)
             {
-                return VectorMath.CosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector);
+                return VectorMath.SinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector);
             }
             else
             {
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs
@@ -211,30 +211,29 @@ public static TVectorSingle CosSingle<TVectorSingle, TVectorInt32, TVectorDouble
             const int ARG_SMALLER = 0x39000000; // 2^-27
 
             TVectorSingle ax = TVectorSingle.Abs(x);
-            TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(x);
+            TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax);
 
             TVectorSingle result;
 
-            if (TVectorSingle.LessThanOrEqualAll(ax, TVectorSingle.Create(ARG_LARGE)))
+            if (TVectorInt32.LessThanOrEqualAll(ux, TVectorInt32.Create(ARG_LARGE)))
             {
                 // We must be a finite value: (pi / 4) >= |x|
 
                 if (TVectorInt32.GreaterThanAny(ux, TVectorInt32.Create(ARG_SMALL - 1)))
                 {
                     // at least one element is: |x| >= 2^-13
-                    TVectorSingle x2 = x * x;
 
                     if (TVectorSingle.Count == TVectorDouble.Count)
                     {
                         result = Narrow<TVectorDouble, TVectorSingle>(
-                            CosSingleSmall(Widen<TVectorSingle, TVectorDouble>(x2))
+                            CosSingleSmall(Widen<TVectorSingle, TVectorDouble>(x))
                         );
                     }
                     else
                     {
                         result = Narrow<TVectorDouble, TVectorSingle>(
-                            CosSingleSmall(WidenLower<TVectorSingle, TVectorDouble>(x2)),
-                            CosSingleSmall(WidenUpper<TVectorSingle, TVectorDouble>(x2))
+                            CosSingleSmall(WidenLower<TVectorSingle, TVectorDouble>(x)),
+                            CosSingleSmall(WidenUpper<TVectorSingle, TVectorDouble>(x))
                         );
                     }
                 }
@@ -1760,8 +1759,8 @@ public static (TVectorDouble Sin, TVectorDouble Cos) SinCosDouble<TVectorDouble,
 
                 sinResult = TVectorDouble.ConditionalSelect(
                     Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & region) | (~sign & ~region)) & TVectorInt64.One, TVectorInt64.Zero)),
-                    -sinResult, // negative in region 1 or 3, positive in region 0 or 2
-                    +sinResult  // negative in region 0 or 2, positive in region 1 or 3
+                    +sinResult, // negative in region 1 or 3, positive in region 0 or 2
+                    -sinResult  // negative in region 0 or 2, positive in region 1 or 3
                 );
 
                 cosResult = TVectorDouble.ConditionalSelect(
@@ -1806,12 +1805,12 @@ public static (TVectorDouble Sin, TVectorDouble Cos) SinCosDouble<TVectorDouble,
             sinResult = TVectorDouble.ConditionalSelect(
                 argNotSmallerMask,
                 sinResult,          // for elements: |x| >= 2^-27, infinity, or NaN
-                TVectorDouble.One   // for elements: 2^-27 > |x|
+                x                   // for elements: 2^-27 > |x|
             );
 
             cosResult = TVectorDouble.ConditionalSelect(
                 argNotSmallerMask,
-                cosResult,             // for elements: |x| >= 2^-27, infinity, or NaN
+                cosResult,          // for elements: |x| >= 2^-27, infinity, or NaN
                 TVectorDouble.One   // for elements: 2^-27 > |x|
             );
 
@@ -1838,11 +1837,11 @@ public static (TVectorSingle Sin, TVectorSingle Cos) SinCosSingle<TVectorSingle,
             const int ARG_SMALLER = 0x39000000; // 2^-27
 
             TVectorSingle ax = TVectorSingle.Abs(x);
-            TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(x);
+            TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax);
 
             TVectorSingle sinResult, cosResult;
 
-            if (TVectorSingle.LessThanOrEqualAll(ax, TVectorSingle.Create(ARG_LARGE)))
+            if (TVectorInt32.LessThanOrEqualAll(ux, TVectorInt32.Create(ARG_LARGE)))
             {
                 // We must be a finite value: (pi / 4) >= |x|
 
@@ -1945,7 +1944,7 @@ public static (TVectorSingle Sin, TVectorSingle Cos) SinCosSingle<TVectorSingle,
             sinResult = TVectorSingle.ConditionalSelect(
                 argNotSmallerMask,
                 sinResult,          // for elements: |x| >= 2^-27, infinity, or NaN
-                TVectorSingle.One   // for elements: 2^-27 > |x|
+                x                   // for elements: 2^-27 > |x|
             );
 
             cosResult = TVectorSingle.ConditionalSelect(
@@ -1982,8 +1981,8 @@ public static (TVectorSingle Sin, TVectorSingle Cos) SinCosSingle<TVectorSingle,
 
                 sinResult = TVectorDouble.ConditionalSelect(
                     Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & region) | (~sign & ~region)) & TVectorInt64.One, TVectorInt64.Zero)),
-                    -sinResult, // negative in region 1 or 3, positive in region 0 or 2
-                    +sinResult  // negative in region 0 or 2, positive in region 1 or 3
+                    +sinResult, // negative in region 1 or 3, positive in region 0 or 2
+                    -sinResult  // negative in region 0 or 2, positive in region 1 or 3
                 );
 
                 cosResult = TVectorDouble.ConditionalSelect(
@@ -2095,8 +2094,8 @@ public static TVectorDouble SinDouble<TVectorDouble, TVectorInt64>(TVectorDouble
 
                 result = TVectorDouble.ConditionalSelect(
                     Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & region) | (~sign & ~region)) & TVectorInt64.One, TVectorInt64.Zero)),
-                    -result,    // negative in region 1 or 3, positive in region 0 or 2
-                    +result     // negative in region 0 or 2, positive in region 1 or 3
+                    +result,    // negative in region 1 or 3, positive in region 0 or 2
+                    -result     // negative in region 0 or 2, positive in region 1 or 3
                 );
 
                 // Propagate the NaN that was passed in
@@ -2116,8 +2115,8 @@ public static TVectorDouble SinDouble<TVectorDouble, TVectorInt64>(TVectorDouble
 
             return TVectorDouble.ConditionalSelect(
                 Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))),
-                result,             // for elements: |x| >= 2^-27, infinity, or NaN
-                TVectorDouble.One   // for elements: 2^-27 > |x|
+                result,     // for elements: |x| >= 2^-27, infinity, or NaN
+                x           // for elements: 2^-27 > |x|
             );
         }
 
@@ -2183,11 +2182,11 @@ public static TVectorSingle SinSingle<TVectorSingle, TVectorInt32, TVectorDouble
             const int ARG_SMALLER = 0x39000000; // 2^-27
 
             TVectorSingle ax = TVectorSingle.Abs(x);
-            TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(x);
+            TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax);
 
             TVectorSingle result;
 
-            if (TVectorSingle.LessThanOrEqualAll(ax, TVectorSingle.Create(ARG_LARGE)))
+            if (TVectorInt32.LessThanOrEqualAll(ux, TVectorInt32.Create(ARG_LARGE)))
             {
                 // We must be a finite value: (pi / 4) >= |x|
 
@@ -2251,8 +2250,8 @@ public static TVectorSingle SinSingle<TVectorSingle, TVectorInt32, TVectorDouble
 
             return TVectorSingle.ConditionalSelect(
                 Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))),
-                result,             // for elements: |x| >= 2^-27, infinity, or NaN
-                TVectorSingle.One   // for elements: 2^-27 > |x|
+                result,     // for elements: |x| >= 2^-27, infinity, or NaN
+                x           // for elements: 2^-27 > |x|
             );
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -2274,8 +2273,8 @@ static TVectorDouble CoreImpl(TVectorDouble x)
 
                 return TVectorDouble.ConditionalSelect(
                     Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & region) | (~sign & ~region)) & TVectorInt64.One, TVectorInt64.Zero)),
-                    -result,    // negative in region 1 or 3, positive in region 0 or 2
-                    +result     // negative in region 0 or 2, positive in region 1 or 3
+                    +result,    // negative in region 1 or 3, positive in region 0 or 2
+                    -result     // negative in region 0 or 2, positive in region 1 or 3
                 );
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -4546,7 +4546,7 @@ public void CosDoubleTest(double value, double expectedResult, double variance)`
`4546`	`4546`
`4547`	`4547`	`[Theory]`
`4548`	`4548`	`[MemberData(nameof(GenericMathTestMemberData.CosSingle), MemberType = typeof(GenericMathTestMemberData))]`
`4549`		`- public void CosCosgleTest(float value, float expectedResult, float variance)`
	`4549`	`+ public void CosSingleTest(float value, float expectedResult, float variance)`
`4550`	`4550`	`{`
`4551`	`4551`	`Vector<float> actualResult = Vector.Cos(Vector.Create(value));`
`4552`	`4552`	`AssertEqual(Vector.Create(expectedResult), actualResult, Vector.Create(variance));`
Original file line number	Diff line number	Diff line change
`@@ -3207,7 +3207,7 @@ public static Vector128<double> Sin(Vector128<double> vector)`
`3207`	`3207`	`{`
`3208`	`3208`	`if (IsHardwareAccelerated)`
`3209`	`3209`	`{`
`3210`		`- return VectorMath.CosDouble<Vector128<double>, Vector128<long>>(vector);`
	`3210`	`+ return VectorMath.SinDouble<Vector128<double>, Vector128<long>>(vector);`
`3211`	`3211`	`}`
`3212`	`3212`	`else`
`3213`	`3213`	`{`
`@@ -3226,11 +3226,11 @@ public static Vector128<float> Sin(Vector128<float> vector)`
`3226`	`3226`	`{`
`3227`	`3227`	`if (Vector256.IsHardwareAccelerated)`
`3228`	`3228`	`{`
`3229`		`- return VectorMath.CosSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector);`
	`3229`	`+ return VectorMath.SinSingle<Vector128<float>, Vector128<int>, Vector256<double>, Vector256<long>>(vector);`
`3230`	`3230`	`}`
`3231`	`3231`	`else`
`3232`	`3232`	`{`
`3233`		`- return VectorMath.CosSingle<Vector128<float>, Vector128<int>, Vector128<double>, Vector128<long>>(vector);`
	`3233`	`+ return VectorMath.SinSingle<Vector128<float>, Vector128<int>, Vector128<double>, Vector128<long>>(vector);`
`3234`	`3234`	`}`
`3235`	`3235`	`}`
`3236`	`3236`	`else`
Original file line number	Diff line number	Diff line change
`@@ -3090,7 +3090,7 @@ public static Vector256<double> Sin(Vector256<double> vector)`
`3090`	`3090`	`{`
`3091`	`3091`	`if (IsHardwareAccelerated)`
`3092`	`3092`	`{`
`3093`		`- return VectorMath.CosDouble<Vector256<double>, Vector256<long>>(vector);`
	`3093`	`+ return VectorMath.SinDouble<Vector256<double>, Vector256<long>>(vector);`
`3094`	`3094`	`}`
`3095`	`3095`	`else`
`3096`	`3096`	`{`
`@@ -3109,11 +3109,11 @@ public static Vector256<float> Sin(Vector256<float> vector)`
`3109`	`3109`	`{`
`3110`	`3110`	`if (Vector512.IsHardwareAccelerated)`
`3111`	`3111`	`{`
`3112`		`- return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector);`
	`3112`	`+ return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector512<double>, Vector512<long>>(vector);`
`3113`	`3113`	`}`
`3114`	`3114`	`else`
`3115`	`3115`	`{`
`3116`		`- return VectorMath.CosSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector);`
	`3116`	`+ return VectorMath.SinSingle<Vector256<float>, Vector256<int>, Vector256<double>, Vector256<long>>(vector);`
`3117`	`3117`	`}`
`3118`	`3118`	`}`
`3119`	`3119`	`else`
Original file line number	Diff line number	Diff line change
`@@ -3131,7 +3131,7 @@ public static Vector512<double> Sin(Vector512<double> vector)`
`3131`	`3131`	`{`
`3132`	`3132`	`if (IsHardwareAccelerated)`
`3133`	`3133`	`{`
`3134`		`- return VectorMath.CosDouble<Vector512<double>, Vector512<long>>(vector);`
	`3134`	`+ return VectorMath.SinDouble<Vector512<double>, Vector512<long>>(vector);`
`3135`	`3135`	`}`
`3136`	`3136`	`else`
`3137`	`3137`	`{`
`@@ -3148,7 +3148,7 @@ public static Vector512<float> Sin(Vector512<float> vector)`
`3148`	`3148`	`{`
`3149`	`3149`	`if (IsHardwareAccelerated)`
`3150`	`3150`	`{`
`3151`		`- return VectorMath.CosSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector);`
	`3151`	`+ return VectorMath.SinSingle<Vector512<float>, Vector512<int>, Vector512<double>, Vector512<long>>(vector);`
`3152`	`3152`	`}`
`3153`	`3153`	`else`
`3154`	`3154`	`{`