Expose the Sin, Cos, and SinCos methods on the Vector types

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cos.cs

@@ -60,12 +60,24 @@ public static void Cos<T>(ReadOnlySpan<T> x, Span<T> destination)
             // 3. Reconstruction
             //      Hence, cos(x) = sin(x + pi/2) = (-1)^N * sin(f)
 
-            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+            public static bool Vectorizable => (typeof(T) == typeof(float))
+                                            || (typeof(T) == typeof(double));
 
             public static T Invoke(T x) => T.Cos(x);
 
             public static Vector128<T> Invoke(Vector128<T> x)
             {
+#if NET9_0_OR_GREATER
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector128.Cos(x.AsDouble()).As<double, T>();
+                }
+                else
+                {
+                    Debug.Assert(typeof(T) == typeof(float));
+                    return Vector128.Cos(x.AsSingle()).As<float, T>();
+                }
+#else
                 if (typeof(T) == typeof(float))
                 {
                     return CosOperatorSingle.Invoke(x.AsSingle()).As<float, T>();
@@ -75,10 +87,22 @@ public static Vector128<T> Invoke(Vector128<T> x)
                     Debug.Assert(typeof(T) == typeof(double));
                     return CosOperatorDouble.Invoke(x.AsDouble()).As<double, T>();
                 }
+#endif
             }
 
             public static Vector256<T> Invoke(Vector256<T> x)
             {
+#if NET9_0_OR_GREATER
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector256.Cos(x.AsDouble()).As<double, T>();
+                }
+                else
+                {
+                    Debug.Assert(typeof(T) == typeof(float));
+                    return Vector256.Cos(x.AsSingle()).As<float, T>();
+                }
+#else
                 if (typeof(T) == typeof(float))
                 {
                     return CosOperatorSingle.Invoke(x.AsSingle()).As<float, T>();
@@ -88,10 +112,22 @@ public static Vector256<T> Invoke(Vector256<T> x)
                     Debug.Assert(typeof(T) == typeof(double));
                     return CosOperatorDouble.Invoke(x.AsDouble()).As<double, T>();
                 }
+#endif
             }
 
             public static Vector512<T> Invoke(Vector512<T> x)
             {
+#if NET9_0_OR_GREATER
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector512.Cos(x.AsDouble()).As<double, T>();
+                }
+                else
+                {
+                    Debug.Assert(typeof(T) == typeof(float));
+                    return Vector512.Cos(x.AsSingle()).As<float, T>();
+                }
+#else
                 if (typeof(T) == typeof(float))
                 {
                     return CosOperatorSingle.Invoke(x.AsSingle()).As<float, T>();
@@ -101,9 +137,25 @@ public static Vector512<T> Invoke(Vector512<T> x)
                     Debug.Assert(typeof(T) == typeof(double));
                     return CosOperatorDouble.Invoke(x.AsDouble()).As<double, T>();
                 }
+#endif
             }
         }
 
+#if NET9_0_OR_GREATER
+        // These are still used by CosPiOperator
+
+        private readonly struct CosOperatorSingle
+        {
+            internal const uint MaxVectorizedValue = 0x4A989680u;
+            internal const uint SignMask = 0x7FFFFFFFu;
+        }
+
+        private readonly struct CosOperatorDouble
+        {
+            internal const ulong SignMask = 0x7FFFFFFFFFFFFFFFul;
+            internal const ulong MaxVectorizedValue = 0x4160000000000000ul;
+        }
+#else
         /// <summary>float.Cos(x)</summary>
         private readonly struct CosOperatorSingle : IUnaryOperator<float, float>
         {
@@ -347,5 +399,6 @@ public static Vector512<double> Invoke(Vector512<double> x)
                 return (poly.AsUInt64() ^ odd).AsDouble();
             }
         }
+#endif
     }
 }

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.CosPi.cs

@@ -33,13 +33,15 @@ public static void CosPi<T>(ReadOnlySpan<T> x, Span<T> destination)
         private readonly struct CosPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
-            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+            public static bool Vectorizable => (typeof(T) == typeof(float))
+                                            || (typeof(T) == typeof(double));
 
             public static T Invoke(T x) => T.CosPi(x);
 
             public static Vector128<T> Invoke(Vector128<T> x)
             {
                 Vector128<T> xpi = x * Vector128.Create(T.Pi);
+
                 if (typeof(T) == typeof(float))
                 {
                     if (Vector128.GreaterThanAny(xpi.AsUInt32() & Vector128.Create(CosOperatorSingle.SignMask), Vector128.Create(CosOperatorSingle.MaxVectorizedValue)))
@@ -62,6 +64,7 @@ public static Vector128<T> Invoke(Vector128<T> x)
             public static Vector256<T> Invoke(Vector256<T> x)
             {
                 Vector256<T> xpi = x * Vector256.Create(T.Pi);
+
                 if (typeof(T) == typeof(float))
                 {
                     if (Vector256.GreaterThanAny(xpi.AsUInt32() & Vector256.Create(CosOperatorSingle.SignMask), Vector256.Create(CosOperatorSingle.MaxVectorizedValue)))
@@ -84,6 +87,7 @@ public static Vector256<T> Invoke(Vector256<T> x)
             public static Vector512<T> Invoke(Vector512<T> x)
             {
                 Vector512<T> xpi = x * Vector512.Create(T.Pi);
+
                 if (typeof(T) == typeof(float))
                 {
                     if (Vector512.GreaterThanAny(xpi.AsUInt32() & Vector512.Create(CosOperatorSingle.SignMask), Vector512.Create(CosOperatorSingle.MaxVectorizedValue)))

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.FloatHelpers.cs

@@ -24,5 +24,79 @@ private static Vector256<double> ApplyScalar<TOperator>(Vector256<double> double
 
         private static Vector512<double> ApplyScalar<TOperator>(Vector512<double> doubles) where TOperator : IUnaryOperator<double, double> =>
             Vector512.Create(ApplyScalar<TOperator>(doubles.GetLower()), ApplyScalar<TOperator>(doubles.GetUpper()));
+
+        private static (Vector128<float> First, Vector128<float> Second) Apply2xScalar<TOperator>(Vector128<float> floats)
+            where TOperator : IUnaryInputBinaryOutput<float>
+        {
+            (float firstRes0, float secondRes0) = TOperator.Invoke(floats[0]);
+            (float firstRes1, float secondRes1) = TOperator.Invoke(floats[1]);
+            (float firstRes2, float secondRes2) = TOperator.Invoke(floats[2]);
+            (float firstRes3, float secondRes3) = TOperator.Invoke(floats[3]);
+
+            return (
+                Vector128.Create(firstRes0, firstRes1, firstRes2, firstRes3),
+                Vector128.Create(secondRes0, secondRes1, secondRes2, secondRes3)
+            );
+        }
+
+        private static (Vector256<float> First, Vector256<float> Second) Apply2xScalar<TOperator>(Vector256<float> floats)
+            where TOperator : IUnaryInputBinaryOutput<float>
+        {
+            (Vector128<float> firstLower, Vector128<float> secondLower) = Apply2xScalar<TOperator>(floats.GetLower());
+            (Vector128<float> firstUpper, Vector128<float> secondUpper) = Apply2xScalar<TOperator>(floats.GetUpper());
+
+            return (
+                Vector256.Create(firstLower, firstUpper),
+                Vector256.Create(secondLower, secondUpper)
+            );
+        }
+
+        private static (Vector512<float> First, Vector512<float> Second) Apply2xScalar<TOperator>(Vector512<float> floats)
+            where TOperator : IUnaryInputBinaryOutput<float>
+        {
+            (Vector256<float> firstLower, Vector256<float> secondLower) = Apply2xScalar<TOperator>(floats.GetLower());
+            (Vector256<float> firstUpper, Vector256<float> secondUpper) = Apply2xScalar<TOperator>(floats.GetUpper());
+
+            return (
+                Vector512.Create(firstLower, firstUpper),
+                Vector512.Create(secondLower, secondUpper)
+            );
+        }
+
+        private static (Vector128<double> First, Vector128<double> Second) Apply2xScalar<TOperator>(Vector128<double> doubles)
+            where TOperator : IUnaryInputBinaryOutput<double>
+        {
+            (double firstRes0, double secondRes0) = TOperator.Invoke(doubles[0]);
+            (double firstRes1, double secondRes1) = TOperator.Invoke(doubles[1]);
+
+            return (
+                Vector128.Create(firstRes0, firstRes1),
+                Vector128.Create(secondRes0, secondRes1)
+            );
+        }
+
+        private static (Vector256<double> First, Vector256<double> Second) Apply2xScalar<TOperator>(Vector256<double> doubles)
+            where TOperator : IUnaryInputBinaryOutput<double>
+        {
+            (Vector128<double> firstLower, Vector128<double> secondLower) = Apply2xScalar<TOperator>(doubles.GetLower());
+            (Vector128<double> firstUpper, Vector128<double> secondUpper) = Apply2xScalar<TOperator>(doubles.GetUpper());
+
+            return (
+                Vector256.Create(firstLower, firstUpper),
+                Vector256.Create(secondLower, secondUpper)
+            );
+        }
+
+        private static (Vector512<double> First, Vector512<double> Second) Apply2xScalar<TOperator>(Vector512<double> doubles)
+            where TOperator : IUnaryInputBinaryOutput<double>
+        {
+            (Vector256<double> firstLower, Vector256<double> secondLower) = Apply2xScalar<TOperator>(doubles.GetLower());
+            (Vector256<double> firstUpper, Vector256<double> secondUpper) = Apply2xScalar<TOperator>(doubles.GetUpper());
+
+            return (
+                Vector512.Create(firstLower, firstUpper),
+                Vector512.Create(secondLower, secondUpper)
+            );
+        }
     }
 }

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sin.cs

@@ -50,12 +50,24 @@ public static void Sin<T>(ReadOnlySpan<T> x, Span<T> destination)
             //
             // The term sin(f) can be approximated by using a polynomial
 
-            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+            public static bool Vectorizable => (typeof(T) == typeof(float))
+                                            || (typeof(T) == typeof(double));
 
             public static T Invoke(T x) => T.Sin(x);
 
             public static Vector128<T> Invoke(Vector128<T> x)
             {
+#if NET9_0_OR_GREATER
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector128.Sin(x.AsDouble()).As<double, T>();
+                }
+                else
+                {
+                    Debug.Assert(typeof(T) == typeof(float));
+                    return Vector128.Sin(x.AsSingle()).As<float, T>();
+                }
+#else
                 if (typeof(T) == typeof(float))
                 {
                     return SinOperatorSingle.Invoke(x.AsSingle()).As<float, T>();
@@ -65,10 +77,22 @@ public static Vector128<T> Invoke(Vector128<T> x)
                     Debug.Assert(typeof(T) == typeof(double));
                     return SinOperatorDouble.Invoke(x.AsDouble()).As<double, T>();
                 }
+#endif
             }
 
             public static Vector256<T> Invoke(Vector256<T> x)
             {
+#if NET9_0_OR_GREATER
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector256.Sin(x.AsDouble()).As<double, T>();
+                }
+                else
+                {
+                    Debug.Assert(typeof(T) == typeof(float));
+                    return Vector256.Sin(x.AsSingle()).As<float, T>();
+                }
+#else
                 if (typeof(T) == typeof(float))
                 {
                     return SinOperatorSingle.Invoke(x.AsSingle()).As<float, T>();
@@ -78,10 +102,22 @@ public static Vector256<T> Invoke(Vector256<T> x)
                     Debug.Assert(typeof(T) == typeof(double));
                     return SinOperatorDouble.Invoke(x.AsDouble()).As<double, T>();
                 }
+#endif
             }
 
             public static Vector512<T> Invoke(Vector512<T> x)
             {
+#if NET9_0_OR_GREATER
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector512.Sin(x.AsDouble()).As<double, T>();
+                }
+                else
+                {
+                    Debug.Assert(typeof(T) == typeof(float));
+                    return Vector512.Sin(x.AsSingle()).As<float, T>();
+                }
+#else
                 if (typeof(T) == typeof(float))
                 {
                     return SinOperatorSingle.Invoke(x.AsSingle()).As<float, T>();
@@ -91,9 +127,25 @@ public static Vector512<T> Invoke(Vector512<T> x)
                     Debug.Assert(typeof(T) == typeof(double));
                     return SinOperatorDouble.Invoke(x.AsDouble()).As<double, T>();
                 }
+#endif
             }
         }
 
+#if NET9_0_OR_GREATER
+        // These are still used by SinPiOperator
+
+        private readonly struct SinOperatorSingle
+        {
+            internal const uint MaxVectorizedValue = 0x49800000u;
+            internal const uint SignMask = 0x7FFFFFFFu;
+        }
+
+        private readonly struct SinOperatorDouble
+        {
+            internal const ulong SignMask = 0x7FFFFFFFFFFFFFFFul;
+            internal const ulong MaxVectorizedValue = 0x4160000000000000ul;
+        }
+#else
         /// <summary>float.Sin(x)</summary>
         private readonly struct SinOperatorSingle : IUnaryOperator<float, float>
         {
@@ -334,5 +386,6 @@ public static Vector512<double> Invoke(Vector512<double> x)
                 return (poly.AsUInt64() ^ (x.AsUInt64() & Vector512.Create(~SignMask)) ^ odd).AsDouble();
             }
         }
+#endif
     }
 }

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.SinPi.cs

@@ -33,13 +33,15 @@ public static void SinPi<T>(ReadOnlySpan<T> x, Span<T> destination)
         private readonly struct SinPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
-            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+            public static bool Vectorizable => (typeof(T) == typeof(float))
+                                            || (typeof(T) == typeof(double));
 
             public static T Invoke(T x) => T.SinPi(x);
 
             public static Vector128<T> Invoke(Vector128<T> x)
             {
                 Vector128<T> xpi = x * Vector128.Create(T.Pi);
+
                 if (typeof(T) == typeof(float))
                 {
                     if (Vector128.GreaterThanAny(xpi.AsUInt32() & Vector128.Create(SinOperatorSingle.SignMask), Vector128.Create(SinOperatorSingle.MaxVectorizedValue)))
@@ -62,6 +64,7 @@ public static Vector128<T> Invoke(Vector128<T> x)
             public static Vector256<T> Invoke(Vector256<T> x)
             {
                 Vector256<T> xpi = x * Vector256.Create(T.Pi);
+
                 if (typeof(T) == typeof(float))
                 {
                     if (Vector256.GreaterThanAny(xpi.AsUInt32() & Vector256.Create(SinOperatorSingle.SignMask), Vector256.Create(SinOperatorSingle.MaxVectorizedValue)))
@@ -84,6 +87,7 @@ public static Vector256<T> Invoke(Vector256<T> x)
             public static Vector512<T> Invoke(Vector512<T> x)
             {
                 Vector512<T> xpi = x * Vector512.Create(T.Pi);
+
                 if (typeof(T) == typeof(float))
                 {
                     if (Vector512.GreaterThanAny(xpi.AsUInt32() & Vector512.Create(SinOperatorSingle.SignMask), Vector512.Create(SinOperatorSingle.MaxVectorizedValue)))