Use Scalar operators in the primitive overloads for clarity and maintainability

ds5678 · ds5678 · commit ff6ffd7fe698 · 2025-04-04T12:52:07.000-07:00
diff --git 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);

Original file line number	Diff line number	Diff line change
`@@ -15,43 +15,43 @@ public partial class Tensor`
`15`	`15`	`public static Tensor operator +(Tensor left, int right)`
`16`	`16`	`{`
`17`	`17`	`using Scalar scalar = right;`
`18`		`- return left.add(scalar);`
	`18`	`+ return left + scalar;`
`19`	`19`	`}`
`20`	`20`	`public static Tensor operator +(Tensor left, long right)`
`21`	`21`	`{`
`22`	`22`	`using Scalar scalar = right;`
`23`		`- return left.add(scalar);`
	`23`	`+ return left + scalar;`
`24`	`24`	`}`
`25`	`25`	`public static Tensor operator +(Tensor left, float right)`
`26`	`26`	`{`
`27`	`27`	`using Scalar scalar = right;`
`28`		`- return left.add(scalar);`
	`28`	`+ return left + scalar;`
`29`	`29`	`}`
`30`	`30`	`public static Tensor operator +(Tensor left, double right)`
`31`	`31`	`{`
`32`	`32`	`using Scalar scalar = right;`
`33`		`- return left.add(scalar);`
	`33`	`+ return left + scalar;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public static Tensor operator +(int left, Tensor right)`
`37`	`37`	`{`
`38`	`38`	`using Scalar scalar = left;`
`39`		`- return right.add(scalar);`
	`39`	`+ return scalar + right;`
`40`	`40`	`}`
`41`	`41`	`public static Tensor operator +(long left, Tensor right)`
`42`	`42`	`{`
`43`	`43`	`using Scalar scalar = left;`
`44`		`- return right.add(scalar);`
	`44`	`+ return scalar + right;`
`45`	`45`	`}`
`46`	`46`	`public static Tensor operator +(float left, Tensor right)`
`47`	`47`	`{`
`48`	`48`	`using Scalar scalar = left;`
`49`		`- return right.add(scalar);`
	`49`	`+ return scalar + right;`
`50`	`50`	`}`
`51`	`51`	`public static Tensor operator +(double left, Tensor right)`
`52`	`52`	`{`
`53`	`53`	`using Scalar scalar = left;`
`54`		`- return right.add(scalar);`
	`54`	`+ return scalar + right;`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`public static Tensor operator *(Tensor left, Tensor right) => left.mul(right);`
`@@ -61,43 +61,43 @@ public partial class Tensor`
`61`	`61`	`public static Tensor operator *(Tensor left, int right)`
`62`	`62`	`{`
`63`	`63`	`using Scalar scalar = right;`
`64`		`- return left.mul(scalar);`
	`64`	`+ return left * scalar;`
`65`	`65`	`}`
`66`	`66`	`public static Tensor operator *(Tensor left, long right)`
`67`	`67`	`{`
`68`	`68`	`using Scalar scalar = right;`
`69`		`- return left.mul(scalar);`
	`69`	`+ return left * scalar;`
`70`	`70`	`}`
`71`	`71`	`public static Tensor operator *(Tensor left, float right)`
`72`	`72`	`{`
`73`	`73`	`using Scalar scalar = right;`
`74`		`- return left.mul(scalar);`
	`74`	`+ return left * scalar;`
`75`	`75`	`}`
`76`	`76`	`public static Tensor operator *(Tensor left, double right)`
`77`	`77`	`{`
`78`	`78`	`using Scalar scalar = right;`
`79`		`- return left.mul(scalar);`
	`79`	`+ return left * scalar;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`public static Tensor operator *(int left, Tensor right)`
`83`	`83`	`{`
`84`	`84`	`using Scalar scalar = left;`
`85`		`- return right.mul(scalar);`
	`85`	`+ return scalar * right;`
`86`	`86`	`}`
`87`	`87`	`public static Tensor operator *(long left, Tensor right)`
`88`	`88`	`{`
`89`	`89`	`using Scalar scalar = left;`
`90`		`- return right.mul(scalar);`
	`90`	`+ return scalar * right;`
`91`	`91`	`}`
`92`	`92`	`public static Tensor operator *(float left, Tensor right)`
`93`	`93`	`{`
`94`	`94`	`using Scalar scalar = left;`
`95`		`- return right.mul(scalar);`
	`95`	`+ return scalar * right;`
`96`	`96`	`}`
`97`	`97`	`public static Tensor operator *(double left, Tensor right)`
`98`	`98`	`{`
`99`	`99`	`using Scalar scalar = left;`
`100`		`- return right.mul(scalar);`
	`100`	`+ return scalar * right;`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`public static Tensor operator -(Tensor left, Tensor right) => left.sub(right);`
`@@ -107,43 +107,43 @@ public partial class Tensor`
`107`	`107`	`public static Tensor operator -(Tensor left, int right)`
`108`	`108`	`{`
`109`	`109`	`using Scalar scalar = right;`
`110`		`- return left.sub(scalar);`
	`110`	`+ return left - scalar;`
`111`	`111`	`}`
`112`	`112`	`public static Tensor operator -(Tensor left, long right)`
`113`	`113`	`{`
`114`	`114`	`using Scalar scalar = right;`
`115`		`- return left.sub(scalar);`
	`115`	`+ return left - scalar;`
`116`	`116`	`}`
`117`	`117`	`public static Tensor operator -(Tensor left, float right)`
`118`	`118`	`{`
`119`	`119`	`using Scalar scalar = right;`
`120`		`- return left.sub(scalar);`
	`120`	`+ return left - scalar;`
`121`	`121`	`}`
`122`	`122`	`public static Tensor operator -(Tensor left, double right)`
`123`	`123`	`{`
`124`	`124`	`using Scalar scalar = right;`
`125`		`- return left.sub(scalar);`
	`125`	`+ return left - scalar;`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`public static Tensor operator -(int left, Tensor right)`
`129`	`129`	`{`
`130`	`130`	`using Scalar scalar = left;`
`131`		`- return right.negative().add(scalar);`
	`131`	`+ return scalar - right;`
`132`	`132`	`}`
`133`	`133`	`public static Tensor operator -(long left, Tensor right)`
`134`	`134`	`{`
`135`	`135`	`using Scalar scalar = left;`
`136`		`- return right.negative().add(scalar);`
	`136`	`+ return scalar - right;`
`137`	`137`	`}`
`138`	`138`	`public static Tensor operator -(float left, Tensor right)`
`139`	`139`	`{`
`140`	`140`	`using Scalar scalar = left;`
`141`		`- return right.negative().add(scalar);`
	`141`	`+ return scalar - right;`
`142`	`142`	`}`
`143`	`143`	`public static Tensor operator -(double left, Tensor right)`
`144`	`144`	`{`
`145`	`145`	`using Scalar scalar = left;`
`146`		`- return right.negative().add(scalar);`
	`146`	`+ return scalar - right;`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`public static Tensor operator /(Tensor left, Tensor right) => left.div(right);`
`@@ -153,43 +153,43 @@ public partial class Tensor`
`153`	`153`	`public static Tensor operator /(Tensor left, int right)`
`154`	`154`	`{`
`155`	`155`	`using Scalar scalar = right;`
`156`		`- return left.div(scalar);`
	`156`	`+ return left / scalar;`
`157`	`157`	`}`
`158`	`158`	`public static Tensor operator /(Tensor left, long right)`
`159`	`159`	`{`
`160`	`160`	`using Scalar scalar = right;`
`161`		`- return left.div(scalar);`
	`161`	`+ return left / scalar;`
`162`	`162`	`}`
`163`	`163`	`public static Tensor operator /(Tensor left, float right)`
`164`	`164`	`{`
`165`	`165`	`using Scalar scalar = right;`
`166`		`- return left.div(scalar);`
	`166`	`+ return left / scalar;`
`167`	`167`	`}`
`168`	`168`	`public static Tensor operator /(Tensor left, double right)`
`169`	`169`	`{`
`170`	`170`	`using Scalar scalar = right;`
`171`		`- return left.div(scalar);`
	`171`	`+ return left / scalar;`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`public static Tensor operator /(int left, Tensor right)`
`175`	`175`	`{`
`176`	`176`	`using Scalar scalar = left;`
`177`		`- return right.reciprocal().mul(scalar);`
	`177`	`+ return scalar / right;`
`178`	`178`	`}`
`179`	`179`	`public static Tensor operator /(long left, Tensor right)`
`180`	`180`	`{`
`181`	`181`	`using Scalar scalar = left;`
`182`		`- return right.reciprocal().mul(scalar);`
	`182`	`+ return scalar / right;`
`183`	`183`	`}`
`184`	`184`	`public static Tensor operator /(float left, Tensor right)`
`185`	`185`	`{`
`186`	`186`	`using Scalar scalar = left;`
`187`		`- return right.reciprocal().mul(scalar);`
	`187`	`+ return scalar / right;`
`188`	`188`	`}`
`189`	`189`	`public static Tensor operator /(double left, Tensor right)`
`190`	`190`	`{`
`191`	`191`	`using Scalar scalar = left;`
`192`		`- return right.reciprocal().mul(scalar);`
	`192`	`+ return scalar / right;`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`public static Tensor operator %(Tensor left, Tensor right) => left.remainder(right);`
`@@ -198,22 +198,22 @@ public partial class Tensor`
`198`	`198`	`public static Tensor operator %(Tensor left, int right)`
`199`	`199`	`{`
`200`	`200`	`using Scalar scalar = right;`
`201`		`- return left.remainder(scalar);`
	`201`	`+ return left % scalar;`
`202`	`202`	`}`
`203`	`203`	`public static Tensor operator %(Tensor left, long right)`
`204`	`204`	`{`
`205`	`205`	`using Scalar scalar = right;`
`206`		`- return left.remainder(scalar);`
	`206`	`+ return left % scalar;`
`207`	`207`	`}`
`208`	`208`	`public static Tensor operator %(Tensor left, float right)`
`209`	`209`	`{`
`210`	`210`	`using Scalar scalar = right;`
`211`		`- return left.remainder(scalar);`
	`211`	`+ return left % scalar;`
`212`	`212`	`}`
`213`	`213`	`public static Tensor operator %(Tensor left, double right)`
`214`	`214`	`{`
`215`	`215`	`using Scalar scalar = right;`
`216`		`- return left.remainder(scalar);`
	`216`	`+ return left % scalar;`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`public static Tensor operator &(Tensor left, Tensor right) => left.bitwise_and(right);`