From 003fcd3ba1ab8f6d50cc6bf2112d119a6c8951a7 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 10:50:16 -0700
Subject: [PATCH 01/20] Ensure the DynamicallyAccessedMembersAnalyzer doesn't
 crash for new language features

---
 .../DynamicallyAccessedMembersAnalyzer.cs      | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs b/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs
index 7391b1809abc69..5f63510347c8c7 100644
--- a/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs
+++ b/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs
@@ -106,11 +106,21 @@ public override void Initialize(AnalysisContext context)
 
                 context.RegisterOperationBlockAction(context =>
                 {
-                    foreach (var operationBlock in context.OperationBlocks)
+                    try
                     {
-                        TrimDataFlowAnalysis trimDataFlowAnalysis = new(context, dataFlowAnalyzerContext, operationBlock);
-                        trimDataFlowAnalysis.InterproceduralAnalyze();
-                        trimDataFlowAnalysis.ReportDiagnostics(context.ReportDiagnostic);
+                        foreach (var operationBlock in context.OperationBlocks)
+                        {
+                            TrimDataFlowAnalysis trimDataFlowAnalysis = new(context, dataFlowAnalyzerContext, operationBlock);
+                            trimDataFlowAnalysis.InterproceduralAnalyze();
+                            trimDataFlowAnalysis.ReportDiagnostics(context.ReportDiagnostic);
+                        }
+                    }
+                    catch (InvalidCastException)
+                    {
+                        // Newer language features may produce NonErrorNamedTypeSymbol
+                        // which will fail to cast to a given target type. Catch and
+                        // ignore the failure in this scenario since it otherwise blocks
+                        // the analyzer
                     }
                 });
 

From 166c3d456103c15d619bc65575eedbdc2ff23096 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:17:07 -0700
Subject: [PATCH 02/20] Adding the extensions for operator + and operator +=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  25 ++++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  56 --------
 .../Tensors/netcore/Tensor.op_Addition.cs     | 132 ++++++++++++++++++
 4 files changed, 158 insertions(+), 56 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Addition.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 84d727f4011b00..7a520954b6c491 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -578,6 +578,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Xor<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Xor<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, T y) where T : System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Xor<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, T y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IAdditionOperators<TScalar, TScalar, TScalar>, System.Numerics.IAdditiveIdentity<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IAdditionOperators<TScalar, TScalar, TScalar>, System.Numerics.IAdditiveIdentity<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator +=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator +=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IAdditionOperators<TScalar, TScalar, TScalar>, System.Numerics.IAdditiveIdentity<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator +=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator +=(TScalar other) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 73464e9b6106ed..2da2a555f9e710 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -39,6 +39,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\ReadOnlyTensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\ReadOnlyTensorSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index bba7b8c07c050c..e83b0e8a728c20 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -2453,62 +2453,6 @@ public static ref readonly TensorSpan<T> AcosPi<T>(scoped in ReadOnlyTensorSpan<
         }
         #endregion
 
-        #region Add
-        /// <summary>
-        /// Adds each element of <paramref name="x"/> to each element of <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
-            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Adds <paramref name="y"/> to each element of <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The <typeparamref name="T"/> to add to each element of <paramref name="x"/>.</param>
-        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Adds each element of <paramref name="x"/> to each element of <paramref name="y"/> and returns a new <see cref="ReadOnlyTensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, destination);
-            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Adds <paramref name="y"/> to each element of <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The <typeparamref name="T"/> to add to each element of <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region Asin
         /// <summary>
         /// Takes the inverse sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Addition.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Addition.cs
new file mode 100644
index 00000000000000..1da8f2c678d998
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Addition.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs element-wise addition between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to add with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to add with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> + <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise addition between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to add with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to add with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> + <paramref name="y" />.</returns>
+        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise addition between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to add with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to add with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> + <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs element-wise addition between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to add with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to add with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> + <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IAdditionOperators<TScalar, TScalar, TScalar>, IAdditiveIdentity<TScalar, TScalar>
+        {
+            /// <summary>Performs element-wise addition between two tensors.</summary>
+            /// <param name="left">The tensor to add with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to add with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> + <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator +(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => Add(left, right);
+
+            /// <summary>Performs element-wise addition between a tensor and scalar.</summary>
+            /// <param name="left">The tensor to add with <paramref name="right" />.</param>
+            /// <param name="right">The scalar to add with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> + <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator +(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => Add(left, right);
+
+            /// <summary>Performs element-wise addition between a tensor and scalar.</summary>
+            /// <param name="left">The scalar to add with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to add with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> + <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator +(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Add(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IAdditionOperators<TScalar, TScalar, TScalar>, IAdditiveIdentity<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Addition{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator +(Tensor<TScalar> left, Tensor<TScalar> right) => Add<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Addition{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator +(Tensor<TScalar> left, TScalar right) => Add(left, right);
+
+            /// <inheritdoc cref="op_Addition{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator +(TScalar left, Tensor<TScalar> right) => Add(right, left);
+
+            /// <inheritdoc cref="op_AdditionAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator +=(in ReadOnlyTensorSpan<TScalar> other) => Add(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_AdditionAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator +=(TScalar other) => Add(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IAdditionOperators<TScalar, TScalar, TScalar>, IAdditiveIdentity<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Addition{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator +(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => Add<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Addition{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator +(in TensorSpan<TScalar> left, TScalar right) => Add(left, right);
+
+            /// <inheritdoc cref="op_Addition{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator +(TScalar left, in TensorSpan<TScalar> right) => Add(right, left);
+
+            /// <summary>Performs in-place element-wise addition between two tensors.</summary>
+            /// <param name="other">The tensor to add to the tensor being operated on.</param>
+            public void operator +=(in ReadOnlyTensorSpan<TScalar> other) => Add(tensor, other, tensor);
+
+            /// <summary>Performs in-place element-wise addition between a tensor and scalar.</summary>
+            /// <param name="other">The scalar to add to the tensor being operated on.</param>
+            public void operator +=(TScalar other) => Add(tensor, other, tensor);
+        }
+    }
+}

From 1a797d849e6287708f87f3783ce28dca4f2a05ad Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:18:11 -0700
Subject: [PATCH 03/20] Adding the extensions for operator / and operator /=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  25 +++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  85 ----------
 .../Tensors/netcore/Tensor.op_Division.cs     | 159 ++++++++++++++++++
 4 files changed, 185 insertions(+), 85 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 7a520954b6c491..5ed2c3e183230f 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -603,6 +603,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator +=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator +=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator /=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator /=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator /(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator /=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator /=(TScalar other) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 2da2a555f9e710..0af5b0817f5e1c 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -40,6 +40,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\ReadOnlyTensorSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index e83b0e8a728c20..71ce9c8f3d2b48 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -3273,91 +3273,6 @@ public static T Distance<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnl
         }
         #endregion
 
-        #region Divide
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The divisor</param>
-        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IDivisionOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Divides <paramref name="x"/> by each element of <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result."/>
-        /// </summary>
-        /// <param name="x">The value to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        public static Tensor<T> Divide<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IDivisionOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(y.Lengths);
-            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by its corresponding element in <paramref name="y"/> and returns
-        /// a new <see cref="ReadOnlyTensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IDivisionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
-            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The divisor</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IDivisionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Divides <paramref name="x"/> by each element of <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result."/>
-        /// </summary>
-        /// <param name="x">The value to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IDivisionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(y, destination);
-            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by its corresponding element in <paramref name="y"/> and returns
-        /// a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IDivisionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, destination);
-            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region Dot
         /// <summary>
         /// Computes the dot product of two tensors containing numbers.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs
new file mode 100644
index 00000000000000..c94881f48091a1
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs
@@ -0,0 +1,159 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs element-wise division between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor dividend.</param>
+        /// <param name="y">The tensor divisor.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> / <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise division between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor dividend.</param>
+        /// <param name="y">The scalar divisor.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> / <paramref name="y" />.</returns>
+        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IDivisionOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise division between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The scalar dividend.</param>
+        /// <param name="y">The tensor divisor.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> / <paramref name="y" />.</returns>
+        public static Tensor<T> Divide<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IDivisionOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise division between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor dividend.</param>
+        /// <param name="y">The tensor divisor.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> / <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs element-wise division between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor dividend.</param>
+        /// <param name="y">The scalar divisor.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> / <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs element-wise division between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The scalar dividend.</param>
+        /// <param name="y">The tensor divisor.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> / <paramref name="y" /> is written.</param>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="y" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IDivisionOperators<TScalar, TScalar, TScalar>
+        {
+            /// <summary>Performs element-wise division between two tensors.</summary>
+            /// <param name="left">The tensor dividend.</param>
+            /// <param name="right">The tensor divisor.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> / <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator /(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => Divide(left, right);
+
+            /// <summary>Performs element-wise division between a tensor and scalar.</summary>
+            /// <param name="left">The tensor dividend.</param>
+            /// <param name="right">The scalar divisor.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> / <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator /(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => Divide(left, right);
+
+            /// <summary>Performs element-wise division between a tensor and scalar.</summary>
+            /// <param name="left">The scalar dividend.</param>
+            /// <param name="right">The tensor divisor.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> / <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator /(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Divide(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IDivisionOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Division{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator /(Tensor<TScalar> left, Tensor<TScalar> right) => Divide<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Division{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator /(Tensor<TScalar> left, TScalar right) => Divide(left, right);
+
+            /// <inheritdoc cref="op_Division{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator /(TScalar left, Tensor<TScalar> right) => Divide(right, left);
+
+            /// <inheritdoc cref="op_DivisionAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator /=(in ReadOnlyTensorSpan<TScalar> other) => Divide(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_DivisionAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator /=(TScalar other) => Divide(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IDivisionOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Division{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator /(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => Divide<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Division{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator /(in TensorSpan<TScalar> left, TScalar right) => Divide(left, right);
+
+            /// <inheritdoc cref="op_Division{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator /(TScalar left, in TensorSpan<TScalar> right) => Divide(right, left);
+
+            /// <summary>Performs in-place element-wise division between two tensors.</summary>
+            /// <param name="other">The tensor divisor.</param>
+            public void operator /=(in ReadOnlyTensorSpan<TScalar> other) => Divide(tensor, other, tensor);
+
+            /// <summary>Performs in-place element-wise division between a tensor and scalar.</summary>
+            /// <param name="other">The scalar divisor.</param>
+            public void operator /=(TScalar other) => Divide(tensor, other, tensor);
+        }
+    }
+}

From 9688da1096daec3e0bc59f093eaa00671a880f7b Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:18:55 -0700
Subject: [PATCH 04/20] Adding the extensions for operator * and operator *=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  25 ++++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  58 --------
 .../Tensors/netcore/Tensor.op_Multiply.cs     | 132 ++++++++++++++++++
 4 files changed, 158 insertions(+), 58 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Multiply.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 5ed2c3e183230f..d4b71fd2065f7d 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -628,6 +628,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator /=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator /=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator *=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator *=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator *(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator *=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator *=(TScalar other) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 0af5b0817f5e1c..ede6f90ab9c452 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -41,6 +41,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 71ce9c8f3d2b48..97410fc81f355f 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -4371,64 +4371,6 @@ public static ref readonly TensorSpan<T> MinNumber<T>(scoped in ReadOnlyTensorSp
         }
         #endregion
 
-        #region Multiply
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="y"><typeparamref name="T"/> value to multiply by.</param>
-        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            Tensor<T> destination = CreateFromShape<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
-        /// </summary>
-        /// <param name="x">Left <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
-            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="y"><typeparamref name="T"/> value to multiply by.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
-        /// </summary>
-        /// <param name="x">Left <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, destination);
-            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region Negate
         /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
         /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Multiply.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Multiply.cs
new file mode 100644
index 00000000000000..ca38d7b970a1f8
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Multiply.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs element-wise multiplication between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to multiply with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to multiply with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> * <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise multiplication between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to multiply with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to multiply with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> * <paramref name="y" />.</returns>
+        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            Tensor<T> destination = CreateFromShape<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise multiplication between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to multiply with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to multiply with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> * <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs element-wise multiplication between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to multiply with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to multiply with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> * <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
+        {
+            /// <summary>Performs element-wise multiplication between two tensors.</summary>
+            /// <param name="left">The tensor to multiply with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to multiply with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> * <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator *(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => Multiply(left, right);
+
+            /// <summary>Performs element-wise multiplication between a tensor and scalar.</summary>
+            /// <param name="left">The tensor to multiply with <paramref name="right" />.</param>
+            /// <param name="right">The scalar to multiply with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> * <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator *(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => Multiply(left, right);
+
+            /// <summary>Performs element-wise multiplication between a tensor and scalar.</summary>
+            /// <param name="left">The scalar to multiply with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to multiply with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> * <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator *(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Multiply(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Multiply{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator *(Tensor<TScalar> left, Tensor<TScalar> right) => Multiply<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Multiply{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator *(Tensor<TScalar> left, TScalar right) => Multiply(left, right);
+
+            /// <inheritdoc cref="op_Multiply{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator *(TScalar left, Tensor<TScalar> right) => Multiply(right, left);
+
+            /// <inheritdoc cref="op_MultiplicationAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator *=(in ReadOnlyTensorSpan<TScalar> other) => Multiply(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_MultiplicationAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator *=(TScalar other) => Multiply(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Multiply{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator *(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => Multiply<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Multiply{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator *(in TensorSpan<TScalar> left, TScalar right) => Multiply(left, right);
+
+            /// <inheritdoc cref="op_Multiply{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator *(TScalar left, in TensorSpan<TScalar> right) => Multiply(right, left);
+
+            /// <summary>Performs in-place element-wise multiplication between two tensors.</summary>
+            /// <param name="other">The tensor used to multiply the tensor being operated on.</param>
+            public void operator *=(in ReadOnlyTensorSpan<TScalar> other) => Multiply(tensor, other, tensor);
+
+            /// <summary>Performs in-place element-wise multiplication between a tensor and scalar.</summary>
+            /// <param name="other">The scalar used to multiply the tensor being operated on.</param>
+            public void operator *=(TScalar other) => Multiply(tensor, other, tensor);
+        }
+    }
+}

From b79804bffbe09436d18d0b7a6e9cedaf49ad5e26 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:14:08 -0700
Subject: [PATCH 05/20] Adding the extensions for operator - and operator -=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  25 +++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  83 ---------
 .../Tensors/netcore/Tensor.op_Subtraction.cs  | 160 ++++++++++++++++++
 4 files changed, 186 insertions(+), 83 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index d4b71fd2065f7d..a182231affaf18 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -653,6 +653,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator *=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator *=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator -=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator -=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator -=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator -=(TScalar other) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index ede6f90ab9c452..c85c0f4c3dfb84 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -42,6 +42,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 97410fc81f355f..b5339be6796093 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -4926,89 +4926,6 @@ public static T StdDev<T>(in ReadOnlyTensorSpan<T> x)
         }
         #endregion
 
-        #region Subtract
-        /// <summary>
-        /// Subtracts <paramref name="y"/> from each element of <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The <typeparamref name="T"/> to subtract.</param>
-        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="y"/> from <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <typeparamref name="T"/> to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> of values to subtract.</param>
-        public static Tensor<T> Subtract<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(y.Lengths);
-            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="x"/> from <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> with values to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> with values to subtract.</param>
-        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
-            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Subtracts <paramref name="y"/> from each element of <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> with values to be subtracted from.</param>
-        /// <param name="y">The <typeparamref name="T"/> value to subtract.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="y"/> from <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <typeparamref name="T"/> value to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> values to subtract.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(y, destination);
-            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="x"/> from <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/>of values to subtract.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, destination);
-            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region Sum
         /// <summary>
         /// Sums the elements of the specified tensor.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs
new file mode 100644
index 00000000000000..0a601528529052
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs
@@ -0,0 +1,160 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs element-wise subtraction between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor from which to subtract <paramref name="y" />.</param>
+        /// <param name="y">The tensor to subtract from <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> - <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise subtraction between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor from which to subtract <paramref name="y" />.</param>
+        /// <param name="y">The scalar to subtract from <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> - <paramref name="y" />.</returns>
+        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise subtraction between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The scalar from which to subtract <paramref name="y" />.</param>
+        /// <param name="y">The tensor to subtract from <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> - <paramref name="y" />.</returns>
+        public static Tensor<T> Subtract<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise subtraction between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor from which to subtract <paramref name="y" />.</param>
+        /// <param name="y">The tensor to subtract from <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> - <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs element-wise subtraction between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor from which to subtract <paramref name="y" />.</param>
+        /// <param name="y">The scalar to subtract from <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> - <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs element-wise subtraction between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The scalar from which to subtract <paramref name="y" />.</param>
+        /// <param name="y">The tensor to subtract from <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> - <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="y" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : ISubtractionOperators<TScalar, TScalar, TScalar>
+        {
+            /// <summary>Performs element-wise subtraction between two tensors.</summary>
+            /// <param name="left">The tensor from which to subtract <paramref name="right" />.</param>
+            /// <param name="right">The tensor to subtract from <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> - <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator -(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => Subtract(left, right);
+
+            /// <summary>Performs element-wise subtraction between a tensor and scalar.</summary>
+            /// <param name="left">The tensor from which to subtract <paramref name="right" />.</param>
+            /// <param name="right">The scalar to subtract from <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> - <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator -(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => Subtract(left, right);
+
+            /// <summary>Performs element-wise subtraction between a tensor and scalar.</summary>
+            /// <param name="left">The scalar from which to subtract <paramref name="right" />.</param>
+            /// <param name="right">The tensor to subtract from <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> - <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator -(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Subtract(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : ISubtractionOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Subtraction{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator -(Tensor<TScalar> left, Tensor<TScalar> right) => Subtract<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Subtraction{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator -(Tensor<TScalar> left, TScalar right) => Subtract(left, right);
+
+            /// <inheritdoc cref="op_Subtraction{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator -(TScalar left, Tensor<TScalar> right) => Subtract(right, left);
+
+            /// <inheritdoc cref="op_SubtractionAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator -=(in ReadOnlyTensorSpan<TScalar> other) => Subtract(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_SubtractionAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator -=(TScalar other) => Subtract(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : ISubtractionOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_Subtraction{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator -(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => Subtract<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_Subtraction{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator -(in TensorSpan<TScalar> left, TScalar right) => Subtract(left, right);
+
+            /// <inheritdoc cref="op_Subtraction{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator -(TScalar left, in TensorSpan<TScalar> right) => Subtract(right, left);
+
+            /// <summary>Performs in-place element-wise subtraction between two tensors.</summary>
+            /// <param name="other">The tensor to subtract from the tensor being operated on.</param>
+            public void operator -=(in ReadOnlyTensorSpan<TScalar> other) => Subtract(tensor, other, tensor);
+
+            /// <summary>Performs in-place element-wise subtraction between a tensor and scalar.</summary>
+            /// <param name="other">The scalar to subtract from the tensor being operated on.</param>
+            public void operator -=(TScalar other) => Subtract(tensor, other, tensor);
+        }
+    }
+}

From b6e34c4a3c5ca333597c623cc8b3ac88478ef683 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:33:23 -0700
Subject: [PATCH 06/20] Adding the extensions for operator & and operator &=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  25 ++++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  56 --------
 .../Tensors/netcore/Tensor.op_BitwiseAnd.cs   | 132 ++++++++++++++++++
 4 files changed, 158 insertions(+), 56 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseAnd.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index a182231affaf18..7b37144e1d4056 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -603,6 +603,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator +=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator +=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator &=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator &=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator &=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator &=(TScalar other) { throw null; }
+        }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index c85c0f4c3dfb84..77ab1eb029ffc4 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -40,6 +40,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\ReadOnlyTensorSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseAnd.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index b5339be6796093..4e9e1e787d6035 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -2798,62 +2798,6 @@ public static T Average<T>(scoped in ReadOnlyTensorSpan<T> x)
         }
         #endregion
 
-        #region BitwiseAnd
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, destination);
-            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region BitwiseOr
         /// <summary>
         /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseAnd.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseAnd.cs
new file mode 100644
index 00000000000000..dc2417aeb7db48
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseAnd.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs bitwise-and between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-and with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to bitwise-and with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> &amp; <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs bitwise-and between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-and with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to bitwise-and with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> &amp; <paramref name="y" />.</returns>
+        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs bitwise-and between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-and with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to bitwise-and with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> &amp; <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs bitwise-and between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-and with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to bitwise-and with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> &amp; <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <summary>Performs bitwise-and between two tensors.</summary>
+            /// <param name="left">The tensor to bitwise-and with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to bitwise-and with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> &amp; <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator &(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => BitwiseAnd(left, right);
+
+            /// <summary>Performs bitwise-and between a tensor and scalar.</summary>
+            /// <param name="left">The tensor to bitwise-and with <paramref name="right" />.</param>
+            /// <param name="right">The scalar to bitwise-and with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> &amp; <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator &(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => BitwiseAnd(left, right);
+
+            /// <summary>Performs bitwise-and between a tensor and scalar.</summary>
+            /// <param name="left">The scalar to bitwise-and with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to bitwise-and with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> &amp; <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator &(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => BitwiseAnd(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_BitwiseAnd{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator &(Tensor<TScalar> left, Tensor<TScalar> right) => BitwiseAnd<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_BitwiseAnd{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator &(Tensor<TScalar> left, TScalar right) => BitwiseAnd(left, right);
+
+            /// <inheritdoc cref="op_BitwiseAnd{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator &(TScalar left, Tensor<TScalar> right) => BitwiseAnd(right, left);
+
+            /// <inheritdoc cref="op_BitwiseAndAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator &=(in ReadOnlyTensorSpan<TScalar> other) => BitwiseAnd(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_BitwiseAndAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator &=(TScalar other) => BitwiseAnd(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_BitwiseAnd{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator &(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => BitwiseAnd<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_BitwiseAnd{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator &(in TensorSpan<TScalar> left, TScalar right) => BitwiseAnd(left, right);
+
+            /// <inheritdoc cref="op_BitwiseAnd{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator &(TScalar left, in TensorSpan<TScalar> right) => BitwiseAnd(right, left);
+
+            /// <summary>Performs in-place bitwise-and between two tensors.</summary>
+            /// <param name="other">The tensor to bitwise-and with the tensor being operated on.</param>
+            public void operator &=(in ReadOnlyTensorSpan<TScalar> other) => BitwiseAnd(tensor, other, tensor);
+
+            /// <summary>Performs in-place bitwise-and between a tensor and scalar.</summary>
+            /// <param name="other">The scalar to bitwise-and with the tensor being operated on.</param>
+            public void operator &=(TScalar other) => BitwiseAnd(tensor, other, tensor);
+        }
+    }
+}

From 237895f8bb8e4e02ffd3fdd959d0d43c5710d70e Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:37:20 -0700
Subject: [PATCH 07/20] Adding the extensions for operator | and operator |=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  13 ++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  56 --------
 .../Tensors/netcore/Tensor.op_BitwiseOr.cs    | 132 ++++++++++++++++++
 4 files changed, 146 insertions(+), 56 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseOr.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 7b37144e1d4056..c12ccad3de4aff 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -609,6 +609,9 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
@@ -618,6 +621,11 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
             public void operator &=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator &=(TScalar other) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator |=(TScalar other) { throw null; }
         }
         extension<TScalar>(ref TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
@@ -627,6 +635,11 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
             public void operator &=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator &=(TScalar other) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator |=(TScalar other) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 77ab1eb029ffc4..17d75b10be4420 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -41,6 +41,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseAnd.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 4e9e1e787d6035..b56e3c179b04d0 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -2798,62 +2798,6 @@ public static T Average<T>(scoped in ReadOnlyTensorSpan<T> x)
         }
         #endregion
 
-        #region BitwiseOr
-        /// <summary>
-        /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise or of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise or of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region CubeRoot
         /// <summary>
         /// Computes the element-wise cube root of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseOr.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseOr.cs
new file mode 100644
index 00000000000000..f54f3600adeb12
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_BitwiseOr.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs bitwise-or between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-or with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to bitwise-or with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> | <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs bitwise-or between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-or with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to bitwise-or with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> | <paramref name="y" />.</returns>
+        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs bitwise-or between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-or with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to bitwise-or with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> | <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs bitwise-or between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to bitwise-or with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to bitwise-or with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> | <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <summary>Performs bitwise-or between two tensors.</summary>
+            /// <param name="left">The tensor to bitwise-or with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to bitwise-or with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> | <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator |(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => BitwiseOr(left, right);
+
+            /// <summary>Performs bitwise-or between a tensor and scalar.</summary>
+            /// <param name="left">The tensor to bitwise-or with <paramref name="right" />.</param>
+            /// <param name="right">The scalar to bitwise-or with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> | <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator |(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => BitwiseOr(left, right);
+
+            /// <summary>Performs bitwise-or between a tensor and scalar.</summary>
+            /// <param name="left">The scalar to bitwise-or with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to bitwise-or with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> | <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator |(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => BitwiseOr(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_BitwiseOr{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator |(Tensor<TScalar> left, Tensor<TScalar> right) => BitwiseOr<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_BitwiseOr{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator |(Tensor<TScalar> left, TScalar right) => BitwiseOr(left, right);
+
+            /// <inheritdoc cref="op_BitwiseOr{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator |(TScalar left, Tensor<TScalar> right) => BitwiseOr(right, left);
+
+            /// <inheritdoc cref="op_BitwiseOrAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator |=(in ReadOnlyTensorSpan<TScalar> other) => BitwiseOr(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_BitwiseOrAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator |=(TScalar other) => BitwiseOr(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_BitwiseOr{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator |(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => BitwiseOr<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_BitwiseOr{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator |(in TensorSpan<TScalar> left, TScalar right) => BitwiseOr(left, right);
+
+            /// <inheritdoc cref="op_BitwiseOr{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator |(TScalar left, in TensorSpan<TScalar> right) => BitwiseOr(right, left);
+
+            /// <summary>Performs in-place bitwise-or between two tensors.</summary>
+            /// <param name="other">The tensor to bitwise-or with the tensor being operated on.</param>
+            public void operator |=(in ReadOnlyTensorSpan<TScalar> other) => BitwiseOr(tensor, other, tensor);
+
+            /// <summary>Performs in-place bitwise-or between a tensor and scalar.</summary>
+            /// <param name="other">The scalar to bitwise-or with the tensor being operated on.</param>
+            public void operator |=(TScalar other) => BitwiseOr(tensor, other, tensor);
+        }
+    }
+}

From 939e9d3a31a0946e42e34104c3706ccee9ea0b31 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:39:55 -0700
Subject: [PATCH 08/20] Adding the extensions for operator ^ and operator ^=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  13 ++
 .../src/System.Numerics.Tensors.csproj        |   1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs |  52 -------
 .../Tensors/netcore/Tensor.op_ExclusiveOr.cs  | 132 ++++++++++++++++++
 4 files changed, 146 insertions(+), 52 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_ExclusiveOr.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index c12ccad3de4aff..a1398c22c45b0c 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -612,6 +612,9 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
@@ -626,6 +629,11 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
             public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator |=(TScalar other) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator ^=(TScalar other) { throw null; }
         }
         extension<TScalar>(ref TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
@@ -640,6 +648,11 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
             public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator |=(TScalar other) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator ^=(TScalar other) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 17d75b10be4420..22915f8a70a9e5 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -43,6 +43,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseAnd.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_ExclusiveOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index b56e3c179b04d0..4d3bf117a72ad6 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -4958,58 +4958,6 @@ public static ref readonly TensorSpan<T> Truncate<T>(scoped in ReadOnlyTensorSpa
             return ref destination;
         }
         #endregion
-
-        #region Xor
-        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
-            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, y, destination);
-            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise Xor of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
-            return destination;
-        }
-
-        /// <summary>
-        /// Computes the element-wise Xor of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
-            return ref destination;
-        }
-        #endregion
         #endregion
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_ExclusiveOr.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_ExclusiveOr.cs
new file mode 100644
index 00000000000000..867873be53aa24
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_ExclusiveOr.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs exclusive-or between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to exclusive-or with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to exclusive-or with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> ^ <paramref name="y" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="y" /> are not compatible.</exception>
+        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs exclusive-or between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to exclusive-or with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to exclusive-or with <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> ^ <paramref name="y" />.</returns>
+        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Performs exclusive-or between two tensors.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to exclusive-or with <paramref name="y" />.</param>
+        /// <param name="y">The tensor to exclusive-or with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> ^ <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" />, <paramref name="y" />, and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Performs exclusive-or between a tensor and scalar.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to exclusive-or with <paramref name="y" />.</param>
+        /// <param name="y">The scalar to exclusive-or with <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> ^ <paramref name="y" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <summary>Performs exclusive-or between two tensors.</summary>
+            /// <param name="left">The tensor to exclusive-or with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to exclusive-or with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> ^ <paramref name="right" />.</returns>
+            /// <exception cref="ArgumentException">The shapes of <paramref name="left" /> and <paramref name="right" /> are not compatible.</exception>
+            public static Tensor<TScalar> operator ^(in ReadOnlyTensorSpan<TScalar> left, in ReadOnlyTensorSpan<TScalar> right) => Xor(left, right);
+
+            /// <summary>Performs exclusive-or between a tensor and scalar.</summary>
+            /// <param name="left">The tensor to exclusive-or with <paramref name="right" />.</param>
+            /// <param name="right">The scalar to exclusive-or with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> ^ <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator ^(in ReadOnlyTensorSpan<TScalar> left, TScalar right) => Xor(left, right);
+
+            /// <summary>Performs exclusive-or between a tensor and scalar.</summary>
+            /// <param name="left">The scalar to exclusive-or with <paramref name="right" />.</param>
+            /// <param name="right">The tensor to exclusive-or with <paramref name="left" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="left" /> ^ <paramref name="right" />.</returns>
+            public static Tensor<TScalar> operator ^(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Xor(right, left);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_ExclusiveOr{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator ^(Tensor<TScalar> left, Tensor<TScalar> right) => Xor<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_ExclusiveOr{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator ^(Tensor<TScalar> left, TScalar right) => Xor(left, right);
+
+            /// <inheritdoc cref="op_ExclusiveOr{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator ^(TScalar left, Tensor<TScalar> right) => Xor(right, left);
+
+            /// <inheritdoc cref="op_ExclusiveOrAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public void operator ^=(in ReadOnlyTensorSpan<TScalar> other) => Xor(tensor, other, tensor);
+
+            /// <inheritdoc cref="op_ExclusiveOrAssignment{T}(ref TensorSpan{T}, T)" />
+            public void operator ^=(TScalar other) => Xor(tensor, other, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_ExclusiveOr{T}(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator ^(in TensorSpan<TScalar> left, in TensorSpan<TScalar> right) => Xor<TScalar>(left, right);
+
+            /// <inheritdoc cref="op_ExclusiveOr{T}(in ReadOnlyTensorSpan{T}, T)" />
+            public static Tensor<TScalar> operator ^(in TensorSpan<TScalar> left, TScalar right) => Xor(left, right);
+
+            /// <inheritdoc cref="op_ExclusiveOr{T}(T, in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator ^(TScalar left, in TensorSpan<TScalar> right) => Xor(right, left);
+
+            /// <summary>Performs in-place exclusive-or between two tensors.</summary>
+            /// <param name="other">The tensor to exclusive-or with the tensor being operated on.</param>
+            public void operator ^=(in ReadOnlyTensorSpan<TScalar> other) => Xor(tensor, other, tensor);
+
+            /// <summary>Performs in-place exclusive-or between a tensor and scalar.</summary>
+            /// <param name="other">The scalar to exclusive-or with the tensor being operated on.</param>
+            public void operator ^=(TScalar other) => Xor(tensor, other, tensor);
+        }
+    }
+}

From 2eab0d8ccfbb44728bd2f8dc890bf5f62d19628c Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 12:48:45 -0700
Subject: [PATCH 09/20] Adding the extensions for operator ~

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 11 ++++
 .../src/CompatibilitySuppressions.xml         | 18 ++++++
 .../src/System.Numerics.Tensors.csproj        |  1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs | 23 -------
 .../netcore/Tensor.op_OnesComplement.cs       | 60 +++++++++++++++++++
 5 files changed, 90 insertions(+), 23 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_OnesComplement.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index a1398c22c45b0c..ac2ddbdeffdded 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -615,6 +615,12 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
@@ -635,6 +641,11 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator ^=(TScalar other) { throw null; }
         }
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
+        }
         extension<TScalar>(ref TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml b/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
index 9c2a17e39157a9..a4ce8a42bcd7e0 100644
--- a/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
+++ b/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
@@ -1107,6 +1107,24 @@
     <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
     <IsBaselineSuppression>true</IsBaselineSuppression>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.OnesComplement``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)$0</Target>
+    <Left>ref/net10.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net10.0/System.Numerics.Tensors.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.OnesComplement``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)$0</Target>
+    <Left>ref/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.OnesComplement``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)$0</Target>
+    <Left>ref/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0021</DiagnosticId>
     <Target>M:System.Numerics.Tensors.Tensor.Average``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)``0:T:System.Numerics.INumberBase{``0}</Target>
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 22915f8a70a9e5..66789a65f0c958 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -45,6 +45,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_ExclusiveOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_OnesComplement.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 4d3bf117a72ad6..569e90c664968d 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -4296,29 +4296,6 @@ public static T Norm<T>(scoped in ReadOnlyTensorSpan<T> x)
         }
         #endregion
 
-        #region OnesComplement
-        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> OnesComplement<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.OnesComplement<T>, T, T>(x, destination);
-            return destination;
-        }
-
-        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> OnesComplement<T>(scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            TensorOperation.ValidateCompatibility(y, destination);
-            TensorOperation.Invoke<TensorOperation.OnesComplement<T>, T, T>(y, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region PopCount
         /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
         /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_OnesComplement.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_OnesComplement.cs
new file mode 100644
index 00000000000000..484a134d6548c6
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_OnesComplement.cs
@@ -0,0 +1,60 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs a one's complement on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to one's complement.</param>
+        /// <returns>A new tensor containing the result of ~<paramref name="x" />.</returns>
+        public static Tensor<T> OnesComplement<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.OnesComplement<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Performs a one's complement on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to one's complement.</param>
+        /// <param name="destination">The destination where the result of ~<paramref name="x" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> OnesComplement<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.OnesComplement<T>, T, T>(x, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <summary>Performs a one's complement on a tensor.</summary>
+            /// <param name="tensor">The tensor to one's complement.</param>
+            /// <returns>A new tensor containing the result of ~<paramref name="tensor" />.</returns>
+            public static Tensor<TScalar> operator ~(in ReadOnlyTensorSpan<TScalar> tensor) => OnesComplement(tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_OnesComplement{T}(in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator ~(Tensor<TScalar> tensor) => OnesComplement<TScalar>(tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_OnesComplement{T}(in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator ~(in TensorSpan<TScalar> tensor) => OnesComplement<TScalar>(tensor);
+        }
+    }
+}

From 58d8f1c29ec10d531fd57afa1f63f88d64d6836b Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 13:07:24 -0700
Subject: [PATCH 10/20] Adding the extensions for operator - (unary)

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 16 +++++
 .../src/System.Numerics.Tensors.csproj        |  1 +
 .../System/Numerics/Tensors/netcore/Tensor.cs | 23 --------
 .../netcore/Tensor.op_UnaryNegation.cs        | 58 +++++++++++++++++++
 4 files changed, 75 insertions(+), 23 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryNegation.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index ac2ddbdeffdded..7467b8cec76609 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -740,6 +740,22 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator -=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator -=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IUnaryNegationOperators<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : System.Numerics.IUnaryNegationOperators<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
+        }
+
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IUnaryNegationOperators<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 66789a65f0c958..18ac694673dd45 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -47,6 +47,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_OnesComplement.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryNegation.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 569e90c664968d..8bc145f8e0e042 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -4259,29 +4259,6 @@ public static ref readonly TensorSpan<T> MinNumber<T>(scoped in ReadOnlyTensorSp
         }
         #endregion
 
-        #region Negate
-        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> Negate<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IUnaryNegationOperators<T, T>
-        {
-            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
-            TensorOperation.Invoke<TensorOperation.Negate<T>, T, T>(x, destination);
-            return destination;
-        }
-
-        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Negate<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IUnaryNegationOperators<T, T>
-        {
-            TensorOperation.ValidateCompatibility(x, destination);
-            TensorOperation.Invoke<TensorOperation.Negate<T>, T, T>(x, destination);
-            return ref destination;
-        }
-        #endregion
-
         #region Norm
         /// <summary>
         ///  Takes the norm of the <see cref="ReadOnlyTensorSpan{T}"/> and returns the result.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryNegation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryNegation.cs
new file mode 100644
index 00000000000000..261ed655688352
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryNegation.cs
@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs element-wise unary negation on a tensor.</summary>
+        /// <param name="x">The tensor to negate.</param>
+        /// <returns>A new tensor containing the result of -<paramref name="x" />.</returns>
+        public static Tensor<T> Negate<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IUnaryNegationOperators<T, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Negate<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Performs element-wise unary negation on a tensor.</summary>
+        /// <param name="x">The tensor to negate.</param>
+        /// <param name="destination">The destination where the result of -<paramref name="x" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Negate<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IUnaryNegationOperators<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Negate<T>, T, T>(x, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IUnaryNegationOperators<TScalar, TScalar>
+        {
+            /// <summary>Performs element-wise unary negation on a tensor.</summary>
+            /// <param name="tensor">The tensor to negate.</param>
+            /// <returns>A new tensor containing the result of -<paramref name="tensor" />.</returns>
+            public static Tensor<TScalar> operator -(in ReadOnlyTensorSpan<TScalar> tensor) => Negate(tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IUnaryNegationOperators<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_UnaryNegation{T}(in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator -(Tensor<TScalar> tensor) => Negate<TScalar>(tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IUnaryNegationOperators<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_UnaryNegation{T}(in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator -(in TensorSpan<TScalar> tensor) => Negate<TScalar>(tensor);
+        }
+    }
+}

From 8c00f6e1fd5f2e9929366323b40399212bf62ab1 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 13:16:45 -0700
Subject: [PATCH 11/20] Adding the extensions for operator + (unary)

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 16 +++++++++
 .../src/System.Numerics.Tensors.csproj        |  1 +
 .../Tensors/netcore/Tensor.op_UnaryPlus.cs    | 34 +++++++++++++++++++
 3 files changed, 51 insertions(+)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryPlus.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 7467b8cec76609..39c05a4099f2ce 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -756,6 +756,22 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IUnaryPlusOperators<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> operator +(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : System.Numerics.IUnaryPlusOperators<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
+        }
+
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IUnaryPlusOperators<TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.TensorSpan<TScalar> operator +(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 18ac694673dd45..0512e4fe45bb1e 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -48,6 +48,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_OnesComplement.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryNegation.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryPlus.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryPlus.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryPlus.cs
new file mode 100644
index 00000000000000..db11f6d750c962
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnaryPlus.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IUnaryPlusOperators<TScalar, TScalar>
+        {
+            /// <summary>Performs element-wise unary plus on a tensor.</summary>
+            /// <param name="tensor">The tensor to return.</param>
+            /// <returns><paramref name="tensor" /></returns>
+            public static ReadOnlyTensorSpan<TScalar> operator +(in ReadOnlyTensorSpan<TScalar> tensor) => tensor;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IUnaryPlusOperators<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_UnaryPlus{T}(in ReadOnlyTensorSpan{T})" />
+            public static Tensor<TScalar> operator +(Tensor<TScalar> tensor) => tensor;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IUnaryPlusOperators<TScalar, TScalar>
+        {
+            /// <inheritdoc cref="op_UnaryPlus{T}(in ReadOnlyTensorSpan{T})" />
+            public static TensorSpan<TScalar> operator +(in TensorSpan<TScalar> tensor) => tensor;
+        }
+    }
+}

From 6aa410867713eba046075f6595fcea1f207ed2f2 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 22 Jul 2025 13:35:19 -0700
Subject: [PATCH 12/20] Adding the extensions for operator << and operator <<=

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 27 ++++++
 .../src/System.Numerics.Tensors.csproj        |  1 +
 .../Tensors/netcore/Tensor.op_LeftShift.cs    | 82 +++++++++++++++++++
 .../Tensors/netcore/TensorOperation.cs        | 15 ++++
 4 files changed, 125 insertions(+)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_LeftShift.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 39c05a4099f2ce..097f1a5b4dbd0d 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -523,6 +523,8 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         public static bool SequenceEqual<T>(this scoped in System.Numerics.Tensors.TensorSpan<T> tensor, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> other) where T : System.IEquatable<T>? { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> SetSlice<T>(this in System.Numerics.Tensors.TensorSpan<T> tensor, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> values, params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> SetSlice<T>(this System.Numerics.Tensors.Tensor<T> tensor, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> values, params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public static Tensor<T> ShiftLeft<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount) where T : IShiftOperators<T, int, T> { throw null; }
+        public static ref readonly TensorSpan<T> ShiftLeft<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination) where T : IShiftOperators<T, int, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sigmoid<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IExponentialFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Sigmoid<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IExponentialFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sinh<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IHyperbolicFunctions<T> { throw null; }
@@ -715,6 +717,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator *=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator *=(TScalar other) { throw null; }
         }
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            public static Tensor<TScalar> operator <<(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            public static Tensor<TScalar> operator <<(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            public void operator <<=(int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            public static Tensor<TScalar> operator <<(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            public void operator <<=(int shiftAmount) { throw null; }
+        }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 0512e4fe45bb1e..d3f9f336a68017 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -44,6 +44,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_ExclusiveOr.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_LeftShift.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_OnesComplement.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_LeftShift.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_LeftShift.cs
new file mode 100644
index 00000000000000..68f1e304e7c2f8
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_LeftShift.cs
@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs an element-wise left shift on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to left shift.</param>
+        /// <param name="shiftAmount">The amount to shift each element in <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> &lt;&lt; <paramref name="shiftAmount" />.</returns>
+        public static Tensor<T> ShiftLeft<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount)
+            where T : IShiftOperators<T, int, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.ShiftLeft<T>, T, int, T>(x, shiftAmount, destination);
+            return destination;
+        }
+
+        /// <summary>Performs an element-wise left shift on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to left shift.</param>
+        /// <param name="shiftAmount">The amount to shift each element in <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> &lt;&lt; <paramref name="shiftAmount" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> ShiftLeft<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination)
+            where T : IShiftOperators<T, int, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.ShiftLeft<T>, T, int, T>(x, shiftAmount, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <summary>Performs an element-wise left shift on a tensor.</summary>
+            /// <param name="tensor">The tensor to left shift.</param>
+            /// <param name="shiftAmount">The amount to shift each element in <paramref name="tensor" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="tensor" /> &lt;&lt; <paramref name="shiftAmount" />.</returns>
+            public static Tensor<TScalar> operator <<(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) => ShiftLeft(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShift{T}(in ReadOnlyTensorSpan{T}, int)" />
+            public static Tensor<TScalar> operator <<(Tensor<TScalar> tensor, int shiftAmount) => ShiftLeft<TScalar>(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShiftAssignment{T}(ref TensorSpan{T}, int)" />
+            public void operator <<=(int shiftAmount) => ShiftLeft<TScalar>(tensor, shiftAmount, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShift{T}(in ReadOnlyTensorSpan{T}, int)" />
+            public static Tensor<TScalar> operator <<(in TensorSpan<TScalar> tensor, int shiftAmount) => ShiftLeft<TScalar>(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <summary>Performs in-place element-wise left shift on a tensor.</summary>
+            /// <param name="shiftAmount">The amount to shift each element in the tensor.</param>
+            public void operator <<=(int shiftAmount) => ShiftLeft<TScalar>(tensor, shiftAmount, tensor);
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
index 42092b950a156f..01514214009f5a 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
@@ -1831,6 +1831,21 @@ public static void Invoke(ReadOnlySpan<T> x, Tuple<int, MidpointRounding> y, Spa
             }
         }
 
+        public readonly struct ShiftLeft<T>
+            : IBinaryOperation_Tensor_Scalar<T, int, T>
+            where T : IShiftOperators<T, int, T>
+        {
+            public static void Invoke(ref readonly T x, int shiftAmount, ref T destination)
+            {
+                destination = x << shiftAmount;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            {
+                TensorPrimitives.ShiftLeft(x, shiftAmount, destination);
+            }
+        }
+
         public readonly struct Sigmoid<T>
         : IUnaryOperation_Tensor<T, T>
         where T : IExponentialFunctions<T>

From bebb06fb31a6bcee396fde59c7d509f081570d86 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Wed, 23 Jul 2025 10:21:43 -0700
Subject: [PATCH 13/20] Adding the extensions for operator >> and operator >>=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  7 ++
 .../src/System.Numerics.Tensors.csproj        |  2 +
 .../Tensors/netcore/Tensor.op_RightShift.cs   | 82 +++++++++++++++++++
 .../Tensors/netcore/TensorOperation.cs        | 15 ++++
 .../netcore/TensorPrimitives.ShiftLeft.cs     | 28 -------
 .../TensorPrimitives.ShiftRightArithmetic.cs  | 38 +++++++++
 6 files changed, 144 insertions(+), 28 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_RightShift.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightArithmetic.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 097f1a5b4dbd0d..f05246328e292d 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -525,6 +525,8 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         public static System.Numerics.Tensors.Tensor<T> SetSlice<T>(this System.Numerics.Tensors.Tensor<T> tensor, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> values, params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
         public static Tensor<T> ShiftLeft<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount) where T : IShiftOperators<T, int, T> { throw null; }
         public static ref readonly TensorSpan<T> ShiftLeft<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination) where T : IShiftOperators<T, int, T> { throw null; }
+        public static Tensor<T> ShiftRightArithmetic<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount) where T : IShiftOperators<T, int, T> { throw null; }
+        public static ref readonly TensorSpan<T> ShiftRightArithmetic<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination) where T : IShiftOperators<T, int, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sigmoid<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IExponentialFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Sigmoid<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IExponentialFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sinh<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IHyperbolicFunctions<T> { throw null; }
@@ -721,26 +723,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public static Tensor<TScalar> operator <<(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+            public static Tensor<TScalar> operator >>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar>)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public static Tensor<TScalar> operator <<(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+            public static Tensor<TScalar> operator >>(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar> tensor)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public void operator <<=(int shiftAmount) { throw null; }
+            public void operator >>=(int shiftAmount) { throw null; }
         }
         extension<TScalar>(TensorSpan<TScalar>)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public static Tensor<TScalar> operator <<(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+            public static Tensor<TScalar> operator >>(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
         }
         extension<TScalar>(ref TensorSpan<TScalar> tensor)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public void operator <<=(int shiftAmount) { throw null; }
+            public void operator >>=(int shiftAmount) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index d3f9f336a68017..1e91285f6e30a3 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -47,6 +47,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_LeftShift.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_OnesComplement.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_RightShift.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryNegation.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryPlus.cs" />
@@ -160,6 +161,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Round.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ScaleB.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ShiftLeft.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ShiftRightArithmetic.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Sigmoid.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Sign.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Sin.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_RightShift.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_RightShift.cs
new file mode 100644
index 00000000000000..d61559441b96ec
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_RightShift.cs
@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs an element-wise arithmetic right shift on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to arithmetic right shift.</param>
+        /// <param name="shiftAmount">The amount to shift each element in <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> &gt;&gt; <paramref name="shiftAmount" />.</returns>
+        public static Tensor<T> ShiftRightArithmetic<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount)
+            where T : IShiftOperators<T, int, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.ShiftRightArithmetic<T>, T, int, T>(x, shiftAmount, destination);
+            return destination;
+        }
+
+        /// <summary>Performs an element-wise arithmetic right shift on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to arithmetic right shift.</param>
+        /// <param name="shiftAmount">The amount to shift each element in <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> &gt;&gt; <paramref name="shiftAmount" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> ShiftRightArithmetic<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination)
+            where T : IShiftOperators<T, int, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.ShiftRightArithmetic<T>, T, int, T>(x, shiftAmount, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <summary>Performs an element-wise arithmetic right shift on a tensor.</summary>
+            /// <param name="tensor">The tensor to arithmetic right shift.</param>
+            /// <param name="shiftAmount">The amount to shift each element in <paramref name="tensor" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="tensor" /> &gt;&gt; <paramref name="shiftAmount" />.</returns>
+            public static Tensor<TScalar> operator >>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) => ShiftRightArithmetic(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShift{T}(in ReadOnlyTensorSpan{T}, int)" />
+            public static Tensor<TScalar> operator >>(Tensor<TScalar> tensor, int shiftAmount) => ShiftRightArithmetic<TScalar>(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShiftAssignment{T}(ref TensorSpan{T}, int)" />
+            public void operator >>=(int shiftAmount) => ShiftRightArithmetic<TScalar>(tensor, shiftAmount, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShift{T}(in ReadOnlyTensorSpan{T}, int)" />
+            public static Tensor<TScalar> operator >>(in TensorSpan<TScalar> tensor, int shiftAmount) => ShiftRightArithmetic<TScalar>(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <summary>Performs in-place element-wise arithmetic right shift on a tensor.</summary>
+            /// <param name="shiftAmount">The amount to shift each element in the tensor.</param>
+            public void operator >>=(int shiftAmount) => ShiftRightArithmetic<TScalar>(tensor, shiftAmount, tensor);
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
index 01514214009f5a..0a6f6dbd2df8a3 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
@@ -1846,6 +1846,21 @@ public static void Invoke(ReadOnlySpan<T> x, int shiftAmount, Span<T> destinatio
             }
         }
 
+        public readonly struct ShiftRightArithmetic<T>
+            : IBinaryOperation_Tensor_Scalar<T, int, T>
+            where T : IShiftOperators<T, int, T>
+        {
+            public static void Invoke(ref readonly T x, int shiftAmount, ref T destination)
+            {
+                destination = x >> shiftAmount;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            {
+                TensorPrimitives.ShiftRightArithmetic(x, shiftAmount, destination);
+            }
+        }
+
         public readonly struct Sigmoid<T>
         : IUnaryOperation_Tensor<T, T>
         where T : IExponentialFunctions<T>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs
index 22d5ea4c268679..c79c8b05102102 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs
@@ -22,21 +22,6 @@ public static void ShiftLeft<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> dest
             where T : IShiftOperators<T, int, T> =>
             InvokeSpanIntoSpan(x, new ShiftLeftOperator<T>(shiftAmount), destination);
 
-        /// <summary>Computes the element-wise arithmetic (signed) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</param>
-        /// <exception cref="ArgumentException">Destination is too short.</exception>
-        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
-        /// <remarks>
-        /// <para>
-        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &gt;&gt; <paramref name="shiftAmount"/></c>.
-        /// </para>
-        /// </remarks>
-        public static void ShiftRightArithmetic<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
-            where T : IShiftOperators<T, int, T> =>
-            InvokeSpanIntoSpan(x, new ShiftRightArithmeticOperator<T>(shiftAmount), destination);
-
         /// <summary>Computes the element-wise logical (unsigned) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
         /// <param name="destination">The destination tensor, represented as a span.</param>
@@ -65,19 +50,6 @@ private readonly struct ShiftLeftOperator<T>(int amount) : IStatefulUnaryOperato
             public Vector512<T> Invoke(Vector512<T> x) => x << _amount;
         }
 
-        /// <summary>T &gt;&gt; amount</summary>
-        private readonly struct ShiftRightArithmeticOperator<T>(int amount) : IStatefulUnaryOperator<T> where T : IShiftOperators<T, int, T>
-        {
-            private readonly int _amount = amount;
-
-            public static bool Vectorizable => true;
-
-            public T Invoke(T x) => x >> _amount;
-            public Vector128<T> Invoke(Vector128<T> x) => x >> _amount;
-            public Vector256<T> Invoke(Vector256<T> x) => x >> _amount;
-            public Vector512<T> Invoke(Vector512<T> x) => x >> _amount;
-        }
-
         /// <summary>T &gt;&gt;&gt; amount</summary>
         private readonly struct ShiftRightLogicalOperator<T>(int amount) : IStatefulUnaryOperator<T> where T : IShiftOperators<T, int, T>
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightArithmetic.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightArithmetic.cs
new file mode 100644
index 00000000000000..26c5bbe388e6cd
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightArithmetic.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.Intrinsics;
+
+namespace System.Numerics.Tensors
+{
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Computes the element-wise arithmetic (signed) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &gt;&gt; <paramref name="shiftAmount"/></c>.
+        /// </para>
+        /// </remarks>
+        public static void ShiftRightArithmetic<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            where T : IShiftOperators<T, int, T> =>
+            InvokeSpanIntoSpan(x, new ShiftRightArithmeticOperator<T>(shiftAmount), destination);
+
+        /// <summary>T &gt;&gt; amount</summary>
+        private readonly struct ShiftRightArithmeticOperator<T>(int amount) : IStatefulUnaryOperator<T> where T : IShiftOperators<T, int, T>
+        {
+            private readonly int _amount = amount;
+
+            public static bool Vectorizable => true;
+
+            public T Invoke(T x) => x >> _amount;
+            public Vector128<T> Invoke(Vector128<T> x) => x >> _amount;
+            public Vector256<T> Invoke(Vector256<T> x) => x >> _amount;
+            public Vector512<T> Invoke(Vector512<T> x) => x >> _amount;
+        }
+    }
+}

From 21ca60d338b5bbd0b2ed35c15aac14001a966bb0 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Wed, 23 Jul 2025 10:30:32 -0700
Subject: [PATCH 14/20] Adding the extensions for operator >>> and operator
 >>>=

---
 .../ref/System.Numerics.Tensors.netcore.cs    |  7 ++
 .../src/System.Numerics.Tensors.csproj        |  2 +
 .../netcore/Tensor.op_UnsignedRightShift.cs   | 82 +++++++++++++++++++
 .../Tensors/netcore/TensorOperation.cs        | 15 ++++
 .../netcore/TensorPrimitives.ShiftLeft.cs     | 28 -------
 .../TensorPrimitives.ShiftRightLogical.cs     | 38 +++++++++
 6 files changed, 144 insertions(+), 28 deletions(-)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnsignedRightShift.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightLogical.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index f05246328e292d..0f524c5821c117 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -527,6 +527,8 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         public static ref readonly TensorSpan<T> ShiftLeft<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination) where T : IShiftOperators<T, int, T> { throw null; }
         public static Tensor<T> ShiftRightArithmetic<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount) where T : IShiftOperators<T, int, T> { throw null; }
         public static ref readonly TensorSpan<T> ShiftRightArithmetic<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination) where T : IShiftOperators<T, int, T> { throw null; }
+        public static Tensor<T> ShiftRightLogical<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount) where T : IShiftOperators<T, int, T> { throw null; }
+        public static ref readonly TensorSpan<T> ShiftRightLogical<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination) where T : IShiftOperators<T, int, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sigmoid<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IExponentialFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Sigmoid<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IExponentialFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sinh<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IHyperbolicFunctions<T> { throw null; }
@@ -724,30 +726,35 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         {
             public static Tensor<TScalar> operator <<(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
             public static Tensor<TScalar> operator >>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+            public static Tensor<TScalar> operator >>>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar>)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public static Tensor<TScalar> operator <<(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
             public static Tensor<TScalar> operator >>(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+            public static Tensor<TScalar> operator >>>(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
         }
         extension<TScalar>(Tensor<TScalar> tensor)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public void operator <<=(int shiftAmount) { throw null; }
             public void operator >>=(int shiftAmount) { throw null; }
+            public void operator >>>=(int shiftAmount) { throw null; }
         }
         extension<TScalar>(TensorSpan<TScalar>)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public static Tensor<TScalar> operator <<(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
             public static Tensor<TScalar> operator >>(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+            public static Tensor<TScalar> operator >>>(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
         }
         extension<TScalar>(ref TensorSpan<TScalar> tensor)
             where TScalar : IShiftOperators<TScalar, int, TScalar>
         {
             public void operator <<=(int shiftAmount) { throw null; }
             public void operator >>=(int shiftAmount) { throw null; }
+            public void operator >>>=(int shiftAmount) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 1e91285f6e30a3..1346b4db90231e 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -51,6 +51,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Subtraction.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryNegation.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnaryPlus.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_UnsignedRightShift.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorDimensionSpan_1.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
@@ -162,6 +163,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ScaleB.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ShiftLeft.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ShiftRightArithmetic.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.ShiftRightLogical.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Sigmoid.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Sign.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Sin.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnsignedRightShift.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnsignedRightShift.cs
new file mode 100644
index 00000000000000..19147047592fe0
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_UnsignedRightShift.cs
@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs an element-wise logical right shift on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to logical right shift.</param>
+        /// <param name="shiftAmount">The amount to shift each element in <paramref name="x" />.</param>
+        /// <returns>A new tensor containing the result of <paramref name="x" /> &gt;&gt;&gt; <paramref name="shiftAmount" />.</returns>
+        public static Tensor<T> ShiftRightLogical<T>(in ReadOnlyTensorSpan<T> x, int shiftAmount)
+            where T : IShiftOperators<T, int, T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.ShiftRightLogical<T>, T, int, T>(x, shiftAmount, destination);
+            return destination;
+        }
+
+        /// <summary>Performs an element-wise logical right shift on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to logical right shift.</param>
+        /// <param name="shiftAmount">The amount to shift each element in <paramref name="x" />.</param>
+        /// <param name="destination">The destination where the result of <paramref name="x" /> &gt;&gt;&gt; <paramref name="shiftAmount" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> ShiftRightLogical<T>(scoped in ReadOnlyTensorSpan<T> x, int shiftAmount, in TensorSpan<T> destination)
+            where T : IShiftOperators<T, int, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.ShiftRightLogical<T>, T, int, T>(x, shiftAmount, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <summary>Performs an element-wise logical right shift on a tensor.</summary>
+            /// <param name="tensor">The tensor to logical right shift.</param>
+            /// <param name="shiftAmount">The amount to shift each element in <paramref name="tensor" />.</param>
+            /// <returns>A new tensor containing the result of <paramref name="tensor" /> &gt;&gt;&gt; <paramref name="shiftAmount" />.</returns>
+            public static Tensor<TScalar> operator >>>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) => ShiftRightLogical(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(Tensor<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShift{T}(in ReadOnlyTensorSpan{T}, int)" />
+            public static Tensor<TScalar> operator >>>(Tensor<TScalar> tensor, int shiftAmount) => ShiftRightLogical<TScalar>(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShiftAssignment{T}(ref TensorSpan{T}, int)" />
+            public void operator >>>=(int shiftAmount) => ShiftRightLogical<TScalar>(tensor, shiftAmount, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        extension<TScalar>(TensorSpan<TScalar>)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <inheritdoc cref="op_LeftShift{T}(in ReadOnlyTensorSpan{T}, int)" />
+            public static Tensor<TScalar> operator >>>(in TensorSpan<TScalar> tensor, int shiftAmount) => ShiftRightLogical<TScalar>(tensor, shiftAmount);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        {
+            /// <summary>Performs in-place element-wise logical right shift on a tensor.</summary>
+            /// <param name="shiftAmount">The amount to shift each element in the tensor.</param>
+            public void operator >>>=(int shiftAmount) => ShiftRightLogical<TScalar>(tensor, shiftAmount, tensor);
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
index 0a6f6dbd2df8a3..5df7d0a95d4af9 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
@@ -1861,6 +1861,21 @@ public static void Invoke(ReadOnlySpan<T> x, int shiftAmount, Span<T> destinatio
             }
         }
 
+        public readonly struct ShiftRightLogical<T>
+            : IBinaryOperation_Tensor_Scalar<T, int, T>
+            where T : IShiftOperators<T, int, T>
+        {
+            public static void Invoke(ref readonly T x, int shiftAmount, ref T destination)
+            {
+                destination = x >>> shiftAmount;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            {
+                TensorPrimitives.ShiftRightLogical(x, shiftAmount, destination);
+            }
+        }
+
         public readonly struct Sigmoid<T>
         : IUnaryOperation_Tensor<T, T>
         where T : IExponentialFunctions<T>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs
index c79c8b05102102..63b3ee4d101ee4 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftLeft.cs
@@ -22,21 +22,6 @@ public static void ShiftLeft<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> dest
             where T : IShiftOperators<T, int, T> =>
             InvokeSpanIntoSpan(x, new ShiftLeftOperator<T>(shiftAmount), destination);
 
-        /// <summary>Computes the element-wise logical (unsigned) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</param>
-        /// <exception cref="ArgumentException">Destination is too short.</exception>
-        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
-        /// <remarks>
-        /// <para>
-        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &gt;&gt;&gt; <paramref name="shiftAmount"/></c>.
-        /// </para>
-        /// </remarks>
-        public static void ShiftRightLogical<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
-            where T : IShiftOperators<T, int, T> =>
-            InvokeSpanIntoSpan(x, new ShiftRightLogicalOperator<T>(shiftAmount), destination);
-
         /// <summary>T &lt;&lt; amount</summary>
         private readonly struct ShiftLeftOperator<T>(int amount) : IStatefulUnaryOperator<T> where T : IShiftOperators<T, int, T>
         {
@@ -49,18 +34,5 @@ private readonly struct ShiftLeftOperator<T>(int amount) : IStatefulUnaryOperato
             public Vector256<T> Invoke(Vector256<T> x) => x << _amount;
             public Vector512<T> Invoke(Vector512<T> x) => x << _amount;
         }
-
-        /// <summary>T &gt;&gt;&gt; amount</summary>
-        private readonly struct ShiftRightLogicalOperator<T>(int amount) : IStatefulUnaryOperator<T> where T : IShiftOperators<T, int, T>
-        {
-            private readonly int _amount = amount;
-
-            public static bool Vectorizable => true;
-
-            public T Invoke(T x) => x >>> _amount;
-            public Vector128<T> Invoke(Vector128<T> x) => x >>> _amount;
-            public Vector256<T> Invoke(Vector256<T> x) => x >>> _amount;
-            public Vector512<T> Invoke(Vector512<T> x) => x >>> _amount;
-        }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightLogical.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightLogical.cs
new file mode 100644
index 00000000000000..0b720c8e9fbf92
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.ShiftRightLogical.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.Intrinsics;
+
+namespace System.Numerics.Tensors
+{
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Computes the element-wise logical (unsigned) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &gt;&gt;&gt; <paramref name="shiftAmount"/></c>.
+        /// </para>
+        /// </remarks>
+        public static void ShiftRightLogical<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            where T : IShiftOperators<T, int, T> =>
+            InvokeSpanIntoSpan(x, new ShiftRightLogicalOperator<T>(shiftAmount), destination);
+
+        /// <summary>T &gt;&gt;&gt; amount</summary>
+        private readonly struct ShiftRightLogicalOperator<T>(int amount) : IStatefulUnaryOperator<T> where T : IShiftOperators<T, int, T>
+        {
+            private readonly int _amount = amount;
+
+            public static bool Vectorizable => true;
+
+            public T Invoke(T x) => x >>> _amount;
+            public Vector128<T> Invoke(Vector128<T> x) => x >>> _amount;
+            public Vector256<T> Invoke(Vector256<T> x) => x >>> _amount;
+            public Vector512<T> Invoke(Vector512<T> x) => x >>> _amount;
+        }
+    }
+}

From c38c44b14ad5a18718b115c70e65c868576ce126 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Wed, 23 Jul 2025 10:57:23 -0700
Subject: [PATCH 15/20] Adding the extensions for operator ++

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 10 ++++
 .../src/System.Numerics.Tensors.csproj        |  1 +
 .../Tensors/netcore/Tensor.op_Increment.cs    | 52 +++++++++++++++++++
 .../Tensors/netcore/TensorOperation.cs        | 16 ++++++
 4 files changed, 79 insertions(+)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 0f524c5821c117..3a08b33c6f355e 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -385,6 +385,8 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Ieee754Remainder<T>(T x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<int> ILogB<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<int> ILogB<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<int> destination) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Increment<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IIncrementOperators<T> { throw null; }
+        public static ref readonly System.Numerics.Tensors.TensorSpan<T> Increment<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IIncrementOperators<T> { throw null; }
         public static nint IndexOfMaxMagnitude<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static nint IndexOfMax<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static nint IndexOfMinMagnitude<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
@@ -696,6 +698,14 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator /=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator /=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor) where TScalar : System.Numerics.IIncrementOperators<TScalar>
+        {
+            public void operator ++() { throw null; }
+        }
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor) where TScalar : System.Numerics.IIncrementOperators<TScalar>
+        {
+            public void operator ++() { throw null;  }
+        }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 1346b4db90231e..8d1c694659efa4 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -44,6 +44,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_ExclusiveOr.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Increment.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_LeftShift.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Multiply.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_OnesComplement.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs
new file mode 100644
index 00000000000000..6fb730c7d5b002
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs an increment on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to increment.</param>
+        /// <returns>A new tensor containing the result of ~<paramref name="x" />.</returns>
+        public static Tensor<T> Increment<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IIncrementOperators<T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Increment<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Performs an increment on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to increment.</param>
+        /// <param name="destination">The destination where the result of ~<paramref name="x" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Increment<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IIncrementOperators<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Increment<T>, T, T>(x, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IIncrementOperators<TScalar>
+        {
+            /// <inheritdoc cref="op_IncrementAssignment{T}(ref TensorSpan{T})" />
+            public void operator ++() => Increment<TScalar>(tensor, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IIncrementOperators<TScalar>
+        {
+            /// <summary>Performs in-place increment on a tensor.</summary>
+            public void operator ++() => Increment<TScalar>(tensor, tensor);
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
index 5df7d0a95d4af9..edf8100a35af42 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
@@ -1186,6 +1186,22 @@ public static void Invoke(ReadOnlySpan<T> x, Span<int> destination)
             }
         }
 
+        public readonly struct Increment<T>
+            : IUnaryOperation_Tensor<T, T>
+            where T : IIncrementOperators<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                T tmp = x;
+                destination = ++tmp;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Increment(x, destination);
+            }
+        }
+
         public readonly struct LeadingZeroCount<T>
         : IUnaryOperation_Tensor<T, T>
         where T : IBinaryInteger<T>

From 6ccf1768076319c6c4879cc251aad31cf98e0a79 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Wed, 23 Jul 2025 11:07:39 -0700
Subject: [PATCH 16/20] Adding the extensions for operator --

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 10 ++++
 .../src/System.Numerics.Tensors.csproj        |  1 +
 .../Tensors/netcore/Tensor.op_Decrement.cs    | 52 +++++++++++++++++++
 .../Tensors/netcore/TensorOperation.cs        | 16 ++++++
 4 files changed, 79 insertions(+)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 3a08b33c6f355e..54ebf754eedb19 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -315,6 +315,8 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static System.Numerics.Tensors.Tensor<T> CreateFromShape<T>(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateFromShapeUninitialized<T>(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateFromShapeUninitialized<T>(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Decrement<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IDecrementOperators<T> { throw null; }
+        public static ref readonly System.Numerics.Tensors.TensorSpan<T> Decrement<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IDecrementOperators<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> DegreesToRadians<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> DegreesToRadians<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static T Distance<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
@@ -673,6 +675,14 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator ^=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor) where TScalar : System.Numerics.IDecrementOperators<TScalar>
+        {
+            public void operator --() { throw null; }
+        }
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor) where TScalar : System.Numerics.IDecrementOperators<TScalar>
+        {
+            public void operator --() { throw null; }
+        }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index 8d1c694659efa4..24fcfcbaf6225b 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -42,6 +42,7 @@
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Addition.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseAnd.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_BitwiseOr.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Decrement.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Division.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_ExclusiveOr.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.op_Increment.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs
new file mode 100644
index 00000000000000..e1353be9719371
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs
@@ -0,0 +1,52 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    public static partial class Tensor
+    {
+        /// <summary>Performs an decrement on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to decrement.</param>
+        /// <returns>A new tensor containing the result of ~<paramref name="x" />.</returns>
+        public static Tensor<T> Decrement<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IDecrementOperators<T>
+        {
+            Tensor<T> destination = CreateFromShapeUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Decrement<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Performs an decrement on a tensor.</summary>
+        /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
+        /// <param name="x">The tensor to decrement.</param>
+        /// <param name="destination">The destination where the result of ~<paramref name="x" /> is written.</param>
+        /// <returns>A reference to <paramref name="destination" />.</returns>
+        /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
+        public static ref readonly TensorSpan<T> Decrement<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IDecrementOperators<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Decrement<T>, T, T>(x, destination);
+            return ref destination;
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(Tensor<TScalar> tensor)
+            where TScalar : IDecrementOperators<TScalar>
+        {
+            /// <inheritdoc cref="op_DecrementAssignment{T}(ref TensorSpan{T})" />
+            public void operator --() => Decrement<TScalar>(tensor, tensor);
+        }
+
+        /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
+        /// <param name="tensor">The tensor to operate on.</param>
+        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+            where TScalar : IDecrementOperators<TScalar>
+        {
+            /// <summary>Performs in-place decrement on a tensor.</summary>
+            public void operator --() => Decrement<TScalar>(tensor, tensor);
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
index edf8100a35af42..227a8d95db58ed 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
@@ -949,6 +949,22 @@ public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
             }
         }
 
+        public readonly struct Decrement<T>
+            : IUnaryOperation_Tensor<T, T>
+            where T : IDecrementOperators<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                T tmp = x;
+                destination = --tmp;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Decrement(x, destination);
+            }
+        }
+
         public readonly struct DegreesToRadians<T>
         : IUnaryOperation_Tensor<T, T>
         where T : ITrigonometricFunctions<T>

From f80fc86423ed21da8706f2fc7075f79f7c150a8d Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Wed, 23 Jul 2025 21:48:16 -0700
Subject: [PATCH 17/20] Ensure the extension member order in the ref matches
 the impl

---
 .../ref/System.Numerics.Tensors.netcore.cs    | 211 ++++++++++++------
 1 file changed, 139 insertions(+), 72 deletions(-)

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 54ebf754eedb19..ebe7a37a7de8ed 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -595,7 +595,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator +(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar> tensor)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IAdditionOperators<TScalar, TScalar, TScalar>, System.Numerics.IAdditiveIdentity<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator +(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
@@ -604,7 +604,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator +=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator +=(TScalar other) { throw null; }
         }
-        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IAdditionOperators<TScalar, TScalar, TScalar>, System.Numerics.IAdditiveIdentity<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
@@ -619,20 +619,8 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
-        }
-        extension<TScalar>(Tensor<TScalar>)
-            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
-        {
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar> tensor)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
@@ -640,23 +628,8 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
             public void operator &=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator &=(TScalar other) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator |(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator |(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
-            public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
-            public void operator |=(TScalar other) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
-            public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
-            public void operator ^=(TScalar other) { throw null; }
         }
-        extension<TScalar>(TensorSpan<TScalar>)
-            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
-        {
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
-        }
-        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
@@ -664,16 +637,31 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator &(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
             public void operator &=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator &=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator |=(TScalar other) { throw null; }
+        }
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator |(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
             public void operator |=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator |=(TScalar other) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
-            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
-            public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
-            public void operator ^=(TScalar other) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor) where TScalar : System.Numerics.IDecrementOperators<TScalar>
         {
@@ -690,7 +678,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator /(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator /(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar> tensor)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator /(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
@@ -699,7 +687,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator /=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator /=(TScalar other) { throw null; }
         }
-        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IDivisionOperators<TScalar, TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator /(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
@@ -708,13 +696,64 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator /=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator /=(TScalar other) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(System.Numerics.Tensors.Tensor<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
+            public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator ^=(TScalar other) { throw null; }
+        }
+
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(in System.Numerics.Tensors.TensorSpan<TScalar> left, TScalar right) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ^(TScalar left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
+            public void operator ^=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
+            public void operator ^=(TScalar other) { throw null; }
+        }
         extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor) where TScalar : System.Numerics.IIncrementOperators<TScalar>
         {
             public void operator ++() { throw null; }
         }
         extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor) where TScalar : System.Numerics.IIncrementOperators<TScalar>
         {
-            public void operator ++() { throw null;  }
+            public void operator ++() { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator <<(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator <<(System.Numerics.Tensors.Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public void operator <<=(int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static Tensor<TScalar> operator <<(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public void operator <<=(int shiftAmount) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
@@ -723,7 +762,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator *(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator *(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar> tensor)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
             where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator *(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
@@ -732,7 +771,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator *=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator *=(TScalar other) { throw null; }
         }
-        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.IMultiplyOperators<TScalar, TScalar, TScalar>, System.Numerics.IMultiplicativeIdentity<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator *(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
@@ -741,40 +780,45 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator *=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator *=(TScalar other) { throw null; }
         }
-        extension<TScalar>(ReadOnlyTensorSpan<TScalar>)
-            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
         {
-            public static Tensor<TScalar> operator <<(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
-            public static Tensor<TScalar> operator >>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
-            public static Tensor<TScalar> operator >>>(in ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar>)
-            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
         {
-            public static Tensor<TScalar> operator <<(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
-            public static Tensor<TScalar> operator >>(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
-            public static Tensor<TScalar> operator >>>(Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar> tensor)
-            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        extension<TScalar>(System.Numerics.Tensors.TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IBitwiseOperators<TScalar, TScalar, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator ~(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator >>(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator >>(System.Numerics.Tensors.Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
         {
-            public void operator <<=(int shiftAmount) { throw null; }
             public void operator >>=(int shiftAmount) { throw null; }
-            public void operator >>>=(int shiftAmount) { throw null; }
         }
-        extension<TScalar>(TensorSpan<TScalar>)
-            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        extension<TScalar>(System.Numerics.Tensors.TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
         {
-            public static Tensor<TScalar> operator <<(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
             public static Tensor<TScalar> operator >>(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
-            public static Tensor<TScalar> operator >>>(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
         }
-        extension<TScalar>(ref TensorSpan<TScalar> tensor)
-            where TScalar : IShiftOperators<TScalar, int, TScalar>
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
         {
-            public void operator <<=(int shiftAmount) { throw null; }
             public void operator >>=(int shiftAmount) { throw null; }
-            public void operator >>>=(int shiftAmount) { throw null; }
         }
         extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
             where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
@@ -783,7 +827,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> left, TScalar right) { throw null; }
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(TScalar left, in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> right) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar> tensor)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
             where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(System.Numerics.Tensors.Tensor<TScalar> left, System.Numerics.Tensors.Tensor<TScalar> right) { throw null; }
@@ -792,7 +836,7 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
             public void operator -=(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> other) { throw null; }
             public void operator -=(TScalar other) { throw null; }
         }
-        extension<TScalar>(ref TensorSpan<TScalar> tensor)
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
             where TScalar : System.Numerics.ISubtractionOperators<TScalar, TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.TensorSpan<TScalar> left, in System.Numerics.Tensors.TensorSpan<TScalar> right) { throw null; }
@@ -806,13 +850,12 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar>)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar>)
             where TScalar : System.Numerics.IUnaryNegationOperators<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
         }
-
-        extension<TScalar>(TensorSpan<TScalar>)
+        extension<TScalar>(System.Numerics.Tensors.TensorSpan<TScalar>)
             where TScalar : System.Numerics.IUnaryNegationOperators<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.Tensor<TScalar> operator -(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
@@ -822,17 +865,41 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         {
             public static System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> operator +(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor) { throw null; }
         }
-        extension<TScalar>(Tensor<TScalar>)
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar>)
             where TScalar : System.Numerics.IUnaryPlusOperators<TScalar, TScalar>
         {
-            public static System.Numerics.Tensors.Tensor<TScalar> operator +(in System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
+            public static System.Numerics.Tensors.Tensor<TScalar> operator +(System.Numerics.Tensors.Tensor<TScalar> tensor) { throw null; }
         }
-
-        extension<TScalar>(TensorSpan<TScalar>)
+        extension<TScalar>(System.Numerics.Tensors.TensorSpan<TScalar>)
             where TScalar : System.Numerics.IUnaryPlusOperators<TScalar, TScalar>
         {
             public static System.Numerics.Tensors.TensorSpan<TScalar> operator +(in System.Numerics.Tensors.TensorSpan<TScalar> tensor) { throw null; }
         }
+        extension<TScalar>(System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator >>>(in System.Numerics.Tensors.ReadOnlyTensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static System.Numerics.Tensors.Tensor<TScalar> operator >>>(System.Numerics.Tensors.Tensor<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.Tensor<TScalar> tensor)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public void operator >>>=(int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(System.Numerics.Tensors.TensorSpan<TScalar>)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public static Tensor<TScalar> operator >>>(in TensorSpan<TScalar> tensor, int shiftAmount) { throw null; }
+        }
+        extension<TScalar>(ref System.Numerics.Tensors.TensorSpan<TScalar> tensor)
+            where TScalar : System.Numerics.IShiftOperators<TScalar, int, TScalar>
+        {
+            public void operator >>>=(int shiftAmount) { throw null; }
+        }
     }
     public readonly ref partial struct TensorDimensionSpan<T>
     {

From 82baad563ad9a65ceacbc62ee5328370bb8646c6 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Wed, 23 Jul 2025 23:08:03 -0700
Subject: [PATCH 18/20] Update CompatibilitySuppressions for a fixed parameter
 name in an experimental API

---
 .../src/CompatibilitySuppressions.xml              | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml b/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
index a4ce8a42bcd7e0..b9631acb2d7041 100644
--- a/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
+++ b/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
@@ -841,6 +841,13 @@
     <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
     <IsBaselineSuppression>true</IsBaselineSuppression>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.OnesComplement``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0017</DiagnosticId>
     <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
@@ -1016,6 +1023,13 @@
     <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
     <IsBaselineSuppression>true</IsBaselineSuppression>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.OnesComplement``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0017</DiagnosticId>
     <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>

From ce60d191e30158eafab9630d0cd68fc4242c6532 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Thu, 24 Jul 2025 14:56:23 -0700
Subject: [PATCH 19/20] Change TrimAnalysisVisitor.VisitParameterReference to
 skip parameters that are not on methods so the analyzer doesn't throw

---
 .../DynamicallyAccessedMembersAnalyzer.cs      | 18 ++++--------------
 .../TrimAnalysis/TrimAnalysisVisitor.cs        | 12 +++++++++++-
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs b/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs
index 5f63510347c8c7..7391b1809abc69 100644
--- a/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs
+++ b/src/tools/illink/src/ILLink.RoslynAnalyzer/DynamicallyAccessedMembersAnalyzer.cs
@@ -106,21 +106,11 @@ public override void Initialize(AnalysisContext context)
 
                 context.RegisterOperationBlockAction(context =>
                 {
-                    try
+                    foreach (var operationBlock in context.OperationBlocks)
                     {
-                        foreach (var operationBlock in context.OperationBlocks)
-                        {
-                            TrimDataFlowAnalysis trimDataFlowAnalysis = new(context, dataFlowAnalyzerContext, operationBlock);
-                            trimDataFlowAnalysis.InterproceduralAnalyze();
-                            trimDataFlowAnalysis.ReportDiagnostics(context.ReportDiagnostic);
-                        }
-                    }
-                    catch (InvalidCastException)
-                    {
-                        // Newer language features may produce NonErrorNamedTypeSymbol
-                        // which will fail to cast to a given target type. Catch and
-                        // ignore the failure in this scenario since it otherwise blocks
-                        // the analyzer
+                        TrimDataFlowAnalysis trimDataFlowAnalysis = new(context, dataFlowAnalyzerContext, operationBlock);
+                        trimDataFlowAnalysis.InterproceduralAnalyze();
+                        trimDataFlowAnalysis.ReportDiagnostics(context.ReportDiagnostic);
                     }
                 });
 
diff --git a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/TrimAnalysisVisitor.cs b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/TrimAnalysisVisitor.cs
index fe26d2a7593ff8..96a04fd4ef63e0 100644
--- a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/TrimAnalysisVisitor.cs
+++ b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/TrimAnalysisVisitor.cs
@@ -134,8 +134,18 @@ public override MultiValue VisitConversion(IConversionOperation operation, State
 
         public override MultiValue VisitParameterReference(IParameterReferenceOperation paramRef, StateValue state)
         {
+            IParameterSymbol parameter = paramRef.Parameter;
+
+            if (parameter.ContainingSymbol is not IMethodSymbol)
+            {
+                // TODO: Extension members allows parameters to be on types, rather than methods.
+                // For example: `extension<T>(ref T value) { }` will enumerate `value` where
+                // the containing symbol is a `NonErrorNamedTypeSymbol`
+                return TopValue;
+            }
+
             // Reading from a parameter always returns the same annotated value. We don't track modifications.
-            return GetParameterTargetValue(paramRef.Parameter);
+            return GetParameterTargetValue(parameter);
         }
 
         public override MultiValue VisitInstanceReference(IInstanceReferenceOperation instanceRef, StateValue state)

From 52ca7ac61847a755e4375582e2df2d9be3cf7a00 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Sun, 3 Aug 2025 06:53:47 -0700
Subject: [PATCH 20/20] Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 .../System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs  | 4 ++--
 .../System/Numerics/Tensors/netcore/Tensor.op_Division.cs   | 6 +++---
 .../System/Numerics/Tensors/netcore/Tensor.op_Increment.cs  | 4 ++--
 .../Numerics/Tensors/netcore/Tensor.op_Subtraction.cs       | 6 +++---
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs
index e1353be9719371..dbeace8824cc05 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Decrement.cs
@@ -8,7 +8,7 @@ public static partial class Tensor
         /// <summary>Performs an decrement on a tensor.</summary>
         /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
         /// <param name="x">The tensor to decrement.</param>
-        /// <returns>A new tensor containing the result of ~<paramref name="x" />.</returns>
+        /// <returns>A new tensor containing the result of --<paramref name="x" />.</returns>
         public static Tensor<T> Decrement<T>(in ReadOnlyTensorSpan<T> x)
             where T : IDecrementOperators<T>
         {
@@ -20,7 +20,7 @@ public static Tensor<T> Decrement<T>(in ReadOnlyTensorSpan<T> x)
         /// <summary>Performs an decrement on a tensor.</summary>
         /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
         /// <param name="x">The tensor to decrement.</param>
-        /// <param name="destination">The destination where the result of ~<paramref name="x" /> is written.</param>
+        /// <param name="destination">The destination where the result of --<paramref name="x" /> is written.</param>
         /// <returns>A reference to <paramref name="destination" />.</returns>
         /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
         public static ref readonly TensorSpan<T> Decrement<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs
index c94881f48091a1..7dc50d5959f349 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Division.cs
@@ -110,7 +110,7 @@ public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensor
             /// <param name="left">The scalar dividend.</param>
             /// <param name="right">The tensor divisor.</param>
             /// <returns>A new tensor containing the result of <paramref name="left" /> / <paramref name="right" />.</returns>
-            public static Tensor<TScalar> operator /(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Divide(right, left);
+            public static Tensor<TScalar> operator /(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Divide(left, right);
         }
 
         /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
@@ -124,7 +124,7 @@ public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensor
             public static Tensor<TScalar> operator /(Tensor<TScalar> left, TScalar right) => Divide(left, right);
 
             /// <inheritdoc cref="op_Division{T}(T, in ReadOnlyTensorSpan{T})" />
-            public static Tensor<TScalar> operator /(TScalar left, Tensor<TScalar> right) => Divide(right, left);
+            public static Tensor<TScalar> operator /(TScalar left, Tensor<TScalar> right) => Divide(left, right);
 
             /// <inheritdoc cref="op_DivisionAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
             public void operator /=(in ReadOnlyTensorSpan<TScalar> other) => Divide(tensor, other, tensor);
@@ -145,7 +145,7 @@ public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensor
             public static Tensor<TScalar> operator /(in TensorSpan<TScalar> left, TScalar right) => Divide(left, right);
 
             /// <inheritdoc cref="op_Division{T}(T, in ReadOnlyTensorSpan{T})" />
-            public static Tensor<TScalar> operator /(TScalar left, in TensorSpan<TScalar> right) => Divide(right, left);
+            public static Tensor<TScalar> operator /(TScalar left, in TensorSpan<TScalar> right) => Divide(left, right);
 
             /// <summary>Performs in-place element-wise division between two tensors.</summary>
             /// <param name="other">The tensor divisor.</param>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs
index 6fb730c7d5b002..5773aa51e86351 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Increment.cs
@@ -8,7 +8,7 @@ public static partial class Tensor
         /// <summary>Performs an increment on a tensor.</summary>
         /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
         /// <param name="x">The tensor to increment.</param>
-        /// <returns>A new tensor containing the result of ~<paramref name="x" />.</returns>
+        /// <returns>A new tensor containing the result of ++<paramref name="x" />.</returns>
         public static Tensor<T> Increment<T>(in ReadOnlyTensorSpan<T> x)
             where T : IIncrementOperators<T>
         {
@@ -20,7 +20,7 @@ public static Tensor<T> Increment<T>(in ReadOnlyTensorSpan<T> x)
         /// <summary>Performs an increment on a tensor.</summary>
         /// <typeparam name="T">The type of the elements in the tensor.</typeparam>
         /// <param name="x">The tensor to increment.</param>
-        /// <param name="destination">The destination where the result of ~<paramref name="x" /> is written.</param>
+        /// <param name="destination">The destination where the result of ++<paramref name="x" /> is written.</param>
         /// <returns>A reference to <paramref name="destination" />.</returns>
         /// <exception cref="ArgumentException">The shapes of <paramref name="x" /> and <paramref name="destination" /> are not compatible.</exception>
         public static ref readonly TensorSpan<T> Increment<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs
index 0a601528529052..dd8ea6c028e0b9 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.op_Subtraction.cs
@@ -111,7 +111,7 @@ public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTens
             /// <param name="left">The scalar from which to subtract <paramref name="right" />.</param>
             /// <param name="right">The tensor to subtract from <paramref name="left" />.</param>
             /// <returns>A new tensor containing the result of <paramref name="left" /> - <paramref name="right" />.</returns>
-            public static Tensor<TScalar> operator -(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Subtract(right, left);
+            public static Tensor<TScalar> operator -(TScalar left, in ReadOnlyTensorSpan<TScalar> right) => Subtract(left, right);
         }
 
         /// <typeparam name="TScalar">The type of the elements in the tensor.</typeparam>
@@ -125,7 +125,7 @@ public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTens
             public static Tensor<TScalar> operator -(Tensor<TScalar> left, TScalar right) => Subtract(left, right);
 
             /// <inheritdoc cref="op_Subtraction{T}(T, in ReadOnlyTensorSpan{T})" />
-            public static Tensor<TScalar> operator -(TScalar left, Tensor<TScalar> right) => Subtract(right, left);
+            public static Tensor<TScalar> operator -(TScalar left, Tensor<TScalar> right) => Subtract(left, right);
 
             /// <inheritdoc cref="op_SubtractionAssignment{T}(ref TensorSpan{T}, in ReadOnlyTensorSpan{T})" />
             public void operator -=(in ReadOnlyTensorSpan<TScalar> other) => Subtract(tensor, other, tensor);
@@ -146,7 +146,7 @@ public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTens
             public static Tensor<TScalar> operator -(in TensorSpan<TScalar> left, TScalar right) => Subtract(left, right);
 
             /// <inheritdoc cref="op_Subtraction{T}(T, in ReadOnlyTensorSpan{T})" />
-            public static Tensor<TScalar> operator -(TScalar left, in TensorSpan<TScalar> right) => Subtract(right, left);
+            public static Tensor<TScalar> operator -(TScalar left, in TensorSpan<TScalar> right) => Subtract(left, right);
 
             /// <summary>Performs in-place element-wise subtraction between two tensors.</summary>
             /// <param name="other">The tensor to subtract from the tensor being operated on.</param>