From 76db3b184f4882e26975ca2977753600119afaad Mon Sep 17 00:00:00 2001
From: ds5678 <49847914+ds5678@users.noreply.github.com>
Date: Thu, 9 Jan 2025 19:50:26 -0800
Subject: [PATCH 1/2] Dispose `Scalar`s implicitly created in `Tensor`
 operators

---
 src/TorchSharp/Tensor/Tensor.Operators.cs | 225 ++++++++++++++++++----
 1 file changed, 184 insertions(+), 41 deletions(-)

diff --git a/src/TorchSharp/Tensor/Tensor.Operators.cs b/src/TorchSharp/Tensor/Tensor.Operators.cs
index 31e8f7449..e74664cd7 100644
--- a/src/TorchSharp/Tensor/Tensor.Operators.cs
+++ b/src/TorchSharp/Tensor/Tensor.Operators.cs
@@ -12,66 +12,209 @@ public partial class Tensor
             public static Tensor operator +(Tensor left, Scalar right) => left.add(right);
             public static Tensor operator +(Scalar left, Tensor right) => right.add(left);
 
-            public static Tensor operator +(Tensor left, int right) => left.add(right);
-            public static Tensor operator +(Tensor left, long right) => left.add(right);
-            public static Tensor operator +(Tensor left, float right) => left.add(right);
-            public static Tensor operator +(Tensor left, double right) => left.add(right);
-
-            public static Tensor operator +(int left, Tensor right) => right.add(left);
-            public static Tensor operator +(long left, Tensor right) => right.add(left);
-            public static Tensor operator +(float left, Tensor right) => right.add(left);
-            public static Tensor operator +(double left, Tensor right) => right.add(left);
+            public static Tensor operator +(Tensor left, int right)
+            {
+                using Scalar scalar = right;
+                return left.add(scalar);
+            }
+            public static Tensor operator +(Tensor left, long right)
+            {
+                using Scalar scalar = right;
+                return left.add(scalar);
+            }
+            public static Tensor operator +(Tensor left, float right)
+            {
+                using Scalar scalar = right;
+                return left.add(scalar);
+            }
+            public static Tensor operator +(Tensor left, double right)
+            {
+                using Scalar scalar = right;
+                return left.add(scalar);
+            }
+
+            public static Tensor operator +(int left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.add(scalar);
+            }
+            public static Tensor operator +(long left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.add(scalar);
+            }
+            public static Tensor operator +(float left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.add(scalar);
+            }
+            public static Tensor operator +(double left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.add(scalar);
+            }
 
             public static Tensor operator *(Tensor left, Tensor right) => left.mul(right);
             public static Tensor operator *(Tensor left, Scalar right) => left.mul(right);
             public static Tensor operator *(Scalar left, Tensor right) => right.mul(left);
 
-            public static Tensor operator *(Tensor left, int right) => left.mul(right);
-            public static Tensor operator *(Tensor left, long right) => left.mul(right);
-            public static Tensor operator *(Tensor left, float right) => left.mul(right);
-            public static Tensor operator *(Tensor left, double right) => left.mul(right);
-
-            public static Tensor operator *(int left, Tensor right) => right.mul(left);
-            public static Tensor operator *(long left, Tensor right) => right.mul(left);
-            public static Tensor operator *(float left, Tensor right) => right.mul(left);
-            public static Tensor operator *(double left, Tensor right) => right.mul(left);
+            public static Tensor operator *(Tensor left, int right)
+            {
+                using Scalar scalar = right;
+                return left.mul(scalar);
+            }
+            public static Tensor operator *(Tensor left, long right)
+            {
+                using Scalar scalar = right;
+                return left.mul(scalar);
+            }
+            public static Tensor operator *(Tensor left, float right)
+            {
+                using Scalar scalar = right;
+                return left.mul(scalar);
+            }
+            public static Tensor operator *(Tensor left, double right)
+            {
+                using Scalar scalar = right;
+                return left.mul(scalar);
+            }
+
+            public static Tensor operator *(int left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.mul(scalar);
+            }
+            public static Tensor operator *(long left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.mul(scalar);
+            }
+            public static Tensor operator *(float left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.mul(scalar);
+            }
+            public static Tensor operator *(double left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.mul(scalar);
+            }
 
             public static Tensor operator -(Tensor left, Tensor right) => left.sub(right);
             public static Tensor operator -(Tensor left, Scalar right) => left.sub(right);
             public static Tensor operator -(Scalar left, Tensor right) => right.negative().add(left);
 
-            public static Tensor operator -(Tensor left, int right) => left.sub(right);
-            public static Tensor operator -(Tensor left, long right) => left.sub(right);
-            public static Tensor operator -(Tensor left, float right) => left.sub(right);
-            public static Tensor operator -(Tensor left, double right) => left.sub(right);
-
-            public static Tensor operator -(int left, Tensor right) => right.negative().add(left);
-            public static Tensor operator -(long left, Tensor right) => right.negative().add(left);
-            public static Tensor operator -(float left, Tensor right) => right.negative().add(left);
-            public static Tensor operator -(double left, Tensor right) => right.negative().add(left);
+            public static Tensor operator -(Tensor left, int right)
+            {
+                using Scalar scalar = right;
+                return left.sub(scalar);
+            }
+            public static Tensor operator -(Tensor left, long right)
+            {
+                using Scalar scalar = right;
+                return left.sub(scalar);
+            }
+            public static Tensor operator -(Tensor left, float right)
+            {
+                using Scalar scalar = right;
+                return left.sub(scalar);
+            }
+            public static Tensor operator -(Tensor left, double right)
+            {
+                using Scalar scalar = right;
+                return left.sub(scalar);
+            }
+
+            public static Tensor operator -(int left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.negative().add(scalar);
+            }
+            public static Tensor operator -(long left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.negative().add(scalar);
+            }
+            public static Tensor operator -(float left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.negative().add(scalar);
+            }
+            public static Tensor operator -(double left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.negative().add(scalar);
+            }
 
             public static Tensor operator /(Tensor left, Tensor right) => left.div(right);
             public static Tensor operator /(Tensor left, Scalar right) => left.div(right);
             public static Tensor operator /(Scalar left, Tensor right) => right.reciprocal().mul(left);
 
-            public static Tensor operator /(Tensor left, int right) => left.div(right);
-            public static Tensor operator /(Tensor left, long right) => left.div(right);
-            public static Tensor operator /(Tensor left, float right) => left.div(right);
-            public static Tensor operator /(Tensor left, double right) => left.div(right);
-
-            public static Tensor operator /(int left, Tensor right) => right.reciprocal().mul(left);
-            public static Tensor operator /(long left, Tensor right) => right.reciprocal().mul(left);
-            public static Tensor operator /(float left, Tensor right) => right.reciprocal().mul(left);
-            public static Tensor operator /(double left, Tensor right) => right.reciprocal().mul(left);
-
+            public static Tensor operator /(Tensor left, int right)
+            {
+                using Scalar scalar = right;
+                return left.div(scalar);
+            }
+            public static Tensor operator /(Tensor left, long right)
+            {
+                using Scalar scalar = right;
+                return left.div(scalar);
+            }
+            public static Tensor operator /(Tensor left, float right)
+            {
+                using Scalar scalar = right;
+                return left.div(scalar);
+            }
+            public static Tensor operator /(Tensor left, double right)
+            {
+                using Scalar scalar = right;
+                return left.div(scalar);
+            }
+
+            public static Tensor operator /(int left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.reciprocal().mul(scalar);
+            }
+            public static Tensor operator /(long left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.reciprocal().mul(scalar);
+            }
+            public static Tensor operator /(float left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.reciprocal().mul(scalar);
+            }
+            public static Tensor operator /(double left, Tensor right)
+            {
+                using Scalar scalar = left;
+                return right.reciprocal().mul(scalar);
+            }
 
             public static Tensor operator %(Tensor left, Tensor right) => left.remainder(right);
             public static Tensor operator %(Tensor left, Scalar right) => left.remainder(right);
 
-            public static Tensor operator %(Tensor left, int right) => left.remainder(right);
-            public static Tensor operator %(Tensor left, long right) => left.remainder(right);
-            public static Tensor operator %(Tensor left, float right) => left.remainder(right);
-            public static Tensor operator %(Tensor left, double right) => left.remainder(right);
+            public static Tensor operator %(Tensor left, int right)
+            {
+                using Scalar scalar = right;
+                return left.remainder(scalar);
+            }
+            public static Tensor operator %(Tensor left, long right)
+            {
+                using Scalar scalar = right;
+                return left.remainder(scalar);
+            }
+            public static Tensor operator %(Tensor left, float right)
+            {
+                using Scalar scalar = right;
+                return left.remainder(scalar);
+            }
+            public static Tensor operator %(Tensor left, double right)
+            {
+                using Scalar scalar = right;
+                return left.remainder(scalar);
+            }
 
             public static Tensor operator &(Tensor left, Tensor right) => left.bitwise_and(right);
 

From a714ab713f7f5c841c5f4e3f074c316a43105d8e Mon Sep 17 00:00:00 2001
From: ds5678 <49847914+ds5678@users.noreply.github.com>
Date: Thu, 9 Jan 2025 19:56:27 -0800
Subject: [PATCH 2/2] Use Scalar operators in the primitive overloads for
 clarity and maintainability

---
 src/TorchSharp/Tensor/Tensor.Operators.cs | 72 +++++++++++------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/TorchSharp/Tensor/Tensor.Operators.cs b/src/TorchSharp/Tensor/Tensor.Operators.cs
index e74664cd7..564d1da42 100644
--- a/src/TorchSharp/Tensor/Tensor.Operators.cs
+++ b/src/TorchSharp/Tensor/Tensor.Operators.cs
@@ -15,43 +15,43 @@ public partial class Tensor
             public static Tensor operator +(Tensor left, int right)
             {
                 using Scalar scalar = right;
-                return left.add(scalar);
+                return left + scalar;
             }
             public static Tensor operator +(Tensor left, long right)
             {
                 using Scalar scalar = right;
-                return left.add(scalar);
+                return left + scalar;
             }
             public static Tensor operator +(Tensor left, float right)
             {
                 using Scalar scalar = right;
-                return left.add(scalar);
+                return left + scalar;
             }
             public static Tensor operator +(Tensor left, double right)
             {
                 using Scalar scalar = right;
-                return left.add(scalar);
+                return left + scalar;
             }
 
             public static Tensor operator +(int left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.add(scalar);
+                return scalar + right;
             }
             public static Tensor operator +(long left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.add(scalar);
+                return scalar + right;
             }
             public static Tensor operator +(float left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.add(scalar);
+                return scalar + right;
             }
             public static Tensor operator +(double left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.add(scalar);
+                return scalar + right;
             }
 
             public static Tensor operator *(Tensor left, Tensor right) => left.mul(right);
@@ -61,43 +61,43 @@ public partial class Tensor
             public static Tensor operator *(Tensor left, int right)
             {
                 using Scalar scalar = right;
-                return left.mul(scalar);
+                return left * scalar;
             }
             public static Tensor operator *(Tensor left, long right)
             {
                 using Scalar scalar = right;
-                return left.mul(scalar);
+                return left * scalar;
             }
             public static Tensor operator *(Tensor left, float right)
             {
                 using Scalar scalar = right;
-                return left.mul(scalar);
+                return left * scalar;
             }
             public static Tensor operator *(Tensor left, double right)
             {
                 using Scalar scalar = right;
-                return left.mul(scalar);
+                return left * scalar;
             }
 
             public static Tensor operator *(int left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.mul(scalar);
+                return scalar * right;
             }
             public static Tensor operator *(long left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.mul(scalar);
+                return scalar * right;
             }
             public static Tensor operator *(float left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.mul(scalar);
+                return scalar * right;
             }
             public static Tensor operator *(double left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.mul(scalar);
+                return scalar * right;
             }
 
             public static Tensor operator -(Tensor left, Tensor right) => left.sub(right);
@@ -107,43 +107,43 @@ public partial class Tensor
             public static Tensor operator -(Tensor left, int right)
             {
                 using Scalar scalar = right;
-                return left.sub(scalar);
+                return left - scalar;
             }
             public static Tensor operator -(Tensor left, long right)
             {
                 using Scalar scalar = right;
-                return left.sub(scalar);
+                return left - scalar;
             }
             public static Tensor operator -(Tensor left, float right)
             {
                 using Scalar scalar = right;
-                return left.sub(scalar);
+                return left - scalar;
             }
             public static Tensor operator -(Tensor left, double right)
             {
                 using Scalar scalar = right;
-                return left.sub(scalar);
+                return left - scalar;
             }
 
             public static Tensor operator -(int left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.negative().add(scalar);
+                return scalar - right;
             }
             public static Tensor operator -(long left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.negative().add(scalar);
+                return scalar - right;
             }
             public static Tensor operator -(float left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.negative().add(scalar);
+                return scalar - right;
             }
             public static Tensor operator -(double left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.negative().add(scalar);
+                return scalar - right;
             }
 
             public static Tensor operator /(Tensor left, Tensor right) => left.div(right);
@@ -153,43 +153,43 @@ public partial class Tensor
             public static Tensor operator /(Tensor left, int right)
             {
                 using Scalar scalar = right;
-                return left.div(scalar);
+                return left / scalar;
             }
             public static Tensor operator /(Tensor left, long right)
             {
                 using Scalar scalar = right;
-                return left.div(scalar);
+                return left / scalar;
             }
             public static Tensor operator /(Tensor left, float right)
             {
                 using Scalar scalar = right;
-                return left.div(scalar);
+                return left / scalar;
             }
             public static Tensor operator /(Tensor left, double right)
             {
                 using Scalar scalar = right;
-                return left.div(scalar);
+                return left / scalar;
             }
 
             public static Tensor operator /(int left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.reciprocal().mul(scalar);
+                return scalar / right;
             }
             public static Tensor operator /(long left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.reciprocal().mul(scalar);
+                return scalar / right;
             }
             public static Tensor operator /(float left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.reciprocal().mul(scalar);
+                return scalar / right;
             }
             public static Tensor operator /(double left, Tensor right)
             {
                 using Scalar scalar = left;
-                return right.reciprocal().mul(scalar);
+                return scalar / right;
             }
 
             public static Tensor operator %(Tensor left, Tensor right) => left.remainder(right);
@@ -198,22 +198,22 @@ public partial class Tensor
             public static Tensor operator %(Tensor left, int right)
             {
                 using Scalar scalar = right;
-                return left.remainder(scalar);
+                return left % scalar;
             }
             public static Tensor operator %(Tensor left, long right)
             {
                 using Scalar scalar = right;
-                return left.remainder(scalar);
+                return left % scalar;
             }
             public static Tensor operator %(Tensor left, float right)
             {
                 using Scalar scalar = right;
-                return left.remainder(scalar);
+                return left % scalar;
             }
             public static Tensor operator %(Tensor left, double right)
             {
                 using Scalar scalar = right;
-                return left.remainder(scalar);
+                return left % scalar;
             }
 
             public static Tensor operator &(Tensor left, Tensor right) => left.bitwise_and(right);