Declare TorchSharp.Scalar more explicitly.

masaru-kimura-hacarus · masaru-kimura-hacarus · commit 512a2ba90e04 · 2025-09-11T11:44:53.000+09:00
* Update src/TorchSharp/Tensor/Tensor.Operators.cs.
  + Declare TorchSharp.Scalar more explicitly.
    - Use prefix for left or right.
    - Call ToScalar explicitly.
diff --git a/src/TorchSharp/Tensor/Tensor.Operators.cs b/src/TorchSharp/Tensor/Tensor.Operators.cs
@@ -14,44 +14,44 @@ public partial class Tensor
 
             public static Tensor operator +(Tensor left, int right)
             {
-                using Scalar scalar = right;
-                return left + scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left + right_scalar;
             }
             public static Tensor operator +(Tensor left, long right)
             {
-                using Scalar scalar = right;
-                return left + scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left + right_scalar;
             }
             public static Tensor operator +(Tensor left, float right)
             {
-                using Scalar scalar = right;
-                return left + scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left + right_scalar;
             }
             public static Tensor operator +(Tensor left, double right)
             {
-                using Scalar scalar = right;
-                return left + scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left + right_scalar;
             }
 
             public static Tensor operator +(int left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar + right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar + right;
             }
             public static Tensor operator +(long left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar + right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar + right;
             }
             public static Tensor operator +(float left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar + right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar + right;
             }
             public static Tensor operator +(double left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar + right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar + right;
             }
 
             public static Tensor operator *(Tensor left, Tensor right) => left.mul(right);
@@ -60,44 +60,44 @@ public partial class Tensor
 
             public static Tensor operator *(Tensor left, int right)
             {
-                using Scalar scalar = right;
-                return left * scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left * right_scalar;
             }
             public static Tensor operator *(Tensor left, long right)
             {
-                using Scalar scalar = right;
-                return left * scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left * right_scalar;
             }
             public static Tensor operator *(Tensor left, float right)
             {
-                using Scalar scalar = right;
-                return left * scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left * right_scalar;
             }
             public static Tensor operator *(Tensor left, double right)
             {
-                using Scalar scalar = right;
-                return left * scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left * right_scalar;
             }
 
             public static Tensor operator *(int left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar * right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar * right;
             }
             public static Tensor operator *(long left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar * right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar * right;
             }
             public static Tensor operator *(float left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar * right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar * right;
             }
             public static Tensor operator *(double left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar * right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar * right;
             }
 
             public static Tensor operator -(Tensor left, Tensor right) => left.sub(right);
@@ -106,44 +106,44 @@ public partial class Tensor
 
             public static Tensor operator -(Tensor left, int right)
             {
-                using Scalar scalar = right;
-                return left - scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left - right_scalar;
             }
             public static Tensor operator -(Tensor left, long right)
             {
-                using Scalar scalar = right;
-                return left - scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left - right_scalar;
             }
             public static Tensor operator -(Tensor left, float right)
             {
-                using Scalar scalar = right;
-                return left - scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left - right_scalar;
             }
             public static Tensor operator -(Tensor left, double right)
             {
-                using Scalar scalar = right;
-                return left - scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left - right_scalar;
             }
 
             public static Tensor operator -(int left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar - right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar - right;
             }
             public static Tensor operator -(long left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar - right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar - right;
             }
             public static Tensor operator -(float left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar - right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar - right;
             }
             public static Tensor operator -(double left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar - right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar - right;
             }
 
             public static Tensor operator /(Tensor left, Tensor right) => left.div(right);
@@ -152,68 +152,68 @@ public partial class Tensor
 
             public static Tensor operator /(Tensor left, int right)
             {
-                using Scalar scalar = right;
-                return left / scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left / right_scalar;
             }
             public static Tensor operator /(Tensor left, long right)
             {
-                using Scalar scalar = right;
-                return left / scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left / right_scalar;
             }
             public static Tensor operator /(Tensor left, float right)
             {
-                using Scalar scalar = right;
-                return left / scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left / right_scalar;
             }
             public static Tensor operator /(Tensor left, double right)
             {
-                using Scalar scalar = right;
-                return left / scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left / right_scalar;
             }
 
             public static Tensor operator /(int left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar / right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar / right;
             }
             public static Tensor operator /(long left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar / right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar / right;
             }
             public static Tensor operator /(float left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar / right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar / right;
             }
             public static Tensor operator /(double left, Tensor right)
             {
-                using Scalar scalar = left;
-                return scalar / right;
+                using Scalar left_scalar = left.ToScalar();
+                return left_scalar / right;
             }
 
             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)
             {
-                using Scalar scalar = right;
-                return left % scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left % right_scalar;
             }
             public static Tensor operator %(Tensor left, long right)
             {
-                using Scalar scalar = right;
-                return left % scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left % right_scalar;
             }
             public static Tensor operator %(Tensor left, float right)
             {
-                using Scalar scalar = right;
-                return left % scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left % right_scalar;
             }
             public static Tensor operator %(Tensor left, double right)
             {
-                using Scalar scalar = right;
-                return left % scalar;
+                using Scalar right_scalar = right.ToScalar();
+                return left % right_scalar;
             }
 
             public static Tensor operator &(Tensor left, Tensor right) => left.bitwise_and(right);

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