CLJCLR-173: Fix (rationalize 1) (Typo in clojure.lang.Number.rationalize.)

dmiller · dmiller · commit b6ffc3610036 · 2025-08-26T09:49:11.000-04:00
diff --git a/Clojure/Clojure/Lib/Numbers.cs b/Clojure/Clojure/Lib/Numbers.cs
@@ -162,10 +162,10 @@ interface Ops
         {
             Ops combine(Ops y);
             Ops opsWith(LongOps x);
-            Ops opsWith(ULongOps x); 
+            Ops opsWith(ULongOps x);
             Ops opsWith(DoubleOps x);
             Ops opsWith(RatioOps x);
-            Ops opsWith(ClrDecimalOps x); 
+            Ops opsWith(ClrDecimalOps x);
             Ops opsWith(BigIntOps x);
             Ops opsWith(BigDecimalOps x);
 
@@ -238,7 +238,7 @@ public object incP(object x)
             {
                 return inc(x);
             }
-            
+
             public object unchecked_inc(object x)
             {
                 return inc(x);
@@ -274,7 +274,7 @@ public object unchecked_dec(object x)
             public abstract bool equiv(object x, object y);
             public abstract bool lt(object x, object y);
             public abstract bool lte(object x, object y);
-            public abstract bool gte(object x, object y); 
+            public abstract bool gte(object x, object y);
             public abstract object negate(object x);
             public abstract object inc(object x);
             public abstract object dec(object x);
@@ -302,7 +302,7 @@ public object unchecked_dec(object x)
         public static bool isZero(ulong x) { return x == 0; }
 
 
-        public static bool isZero(decimal x) { return x == 0m;  }
+        public static bool isZero(decimal x) { return x == 0m; }
 
 
 
@@ -584,7 +584,7 @@ public static ulong minus(ulong x)
 
 
         public static double minusP(double x) { return -x; }
-        
+
 
         public static object minusP(long x)
         {
@@ -680,7 +680,7 @@ public static ulong minus(ulong x, ulong y)
 
         public static object minus(ulong x, long y) { return minus((Object)x, (Object)y); }
 
-        
+
 
         public static object minusP(object x, object y)
         {
@@ -1179,7 +1179,7 @@ public static double quotient(double n, double d)
 
 
         public static double quotient(long x, double y) { return quotient((double)x, y); }
-        
+
 
         public static object quotient(long x, Object y) { return quotient((Object)x, y); }
 
@@ -1227,7 +1227,7 @@ public static double remainder(double n, double d)
 
 
         public static object remainder(Object x, double y) { return remainder(x, (Object)y); }
-        
+
 
         public static double remainder(double x, long y) { return remainder(x, (double)y); }
 
@@ -1359,8 +1359,8 @@ public static object decP(decimal x)
 
 
 
-        public static double unchecked_inc(double x) { return inc(x); }       
-        
+        public static double unchecked_inc(double x) { return inc(x); }
+
 
 
         public static long unchecked_inc(long x) { return x + 1; }
@@ -1371,8 +1371,8 @@ public static object decP(decimal x)
 
 
 
-        public static decimal unchecked_inc(decimal x) { return inc(x); }  
-        
+        public static decimal unchecked_inc(decimal x) { return inc(x); }
+
 
 
         public static object unchecked_dec(object x) { return ops(x).unchecked_dec(x); }
@@ -1388,10 +1388,10 @@ public static object decP(decimal x)
 
 
         public static ulong unchecked_dec(ulong x) { return x - 1; }
-        
 
 
-        public static decimal unchecked_dec(decimal x) { return dec(x); }  
+
+        public static decimal unchecked_dec(decimal x) { return dec(x); }
 
         #endregion
 
@@ -1415,7 +1415,7 @@ public static int compare(object x, object y)
             else
                 return 0;
         }
-        
+
         #endregion
 
         #region equiv, lt, lte, gt, gte
@@ -1478,7 +1478,7 @@ public static int compare(object x, object y)
 
 
         public static bool lt(double x, double y) { return x < y; }
-      
+
 
         public static bool lt(long x, long y) { return x < y; }
 
@@ -1629,7 +1629,7 @@ public static int compare(object x, object y)
 
 
         public static bool gt(ulong x, long y) { return gt((Object)x, (Object)y); }
-        
+
 
 
         public static bool gte(object x, object y) { return ops(x).combine(ops(y)).gte(x, y); }
@@ -1897,7 +1897,7 @@ public static long min(long x, long y)
 
         public static ulong min(ulong x, ulong y)
         {
-            return Math.Min(x, y);      
+            return Math.Min(x, y);
         }
 
 
@@ -2217,7 +2217,7 @@ public static Ratio ToRatio(object x)
                 return r;
 
             BigDecimal bx = x as BigDecimal;
-            if ( bx != null )
+            if (bx != null)
             {
                 int exp = bx.Exponent;
                 if (exp >= 0)
@@ -2233,13 +2233,13 @@ public static Ratio ToRatio(object x)
         [WarnBoxedMath(false)]
         public static object rationalize(object x)
         {
-            if (x is float f)                              
+            if (x is float f)
                 return rationalize(BigDecimal.Create(f));
 
-            if (x is double d)                        
+            if (x is double d)
                 return rationalize(BigDecimal.Create(d));
 
-            BigDecimal bx = (BigDecimal)x;
+            BigDecimal bx = x as BigDecimal;
             if (bx != null)
             {
                 int exp = bx.Exponent;
@@ -2296,7 +2296,7 @@ public static int shiftLeftInt(int x, int n)
 
         public static object shiftLeft(object x, object n)
         {
-            return shiftLeft(bitOpsCast(x),bitOpsCast(n));
+            return shiftLeft(bitOpsCast(x), bitOpsCast(n));
         }
 
 
@@ -2458,7 +2458,7 @@ public bool isNeg(object x)
 
             public object add(object x, object y)
             {
-                 return num(Numbers.add( Util.ConvertToLong(x), Util.ConvertToLong(y)));
+                return num(Numbers.add(Util.ConvertToLong(x), Util.ConvertToLong(y)));
             }
 
             public object addP(object x, object y)
@@ -2517,7 +2517,7 @@ public object divide(object x, object y)
                 long n = Util.ConvertToLong(x);
                 long val = Util.ConvertToLong(y);
 
-                if ( n == long.MinValue || val == long.MinValue )
+                if (n == long.MinValue || val == long.MinValue)
                     return BIGINT_OPS.divide(x, y);
 
                 long gcd1 = gcd(n, val);
@@ -2565,7 +2565,7 @@ public bool gte(object x, object y)
             {
                 return Util.ConvertToLong(x) >= Util.ConvertToLong(y);
             }
-            	
+
             public object negate(object x)
             {
                 long val = Util.ConvertToLong(x);
@@ -2710,9 +2710,9 @@ public object addP(object x, object y)
             {
                 ulong ulx = Util.ConvertToULong(x);
                 ulong uly = Util.ConvertToULong(y);
-                if ( ulx > ulong.MaxValue - uly )
+                if (ulx > ulong.MaxValue - uly)
                     return BIGINT_OPS.add(x, y);
-                return num(ulx+uly);
+                return num(ulx + uly);
             }
 
             public object unchecked_add(object x, object y)
@@ -2765,7 +2765,7 @@ public object divide(object x, object y)
                 ulong d = val / gcd1;
                 if (d == 1)
                     return num(n);
- 
+
                 return new Ratio(BigInteger.Create(n), BigInteger.Create(d));
             }
 
@@ -3135,7 +3135,7 @@ public override bool equiv(object x, object y)
             {
                 Ratio rx = ToRatio(x);
                 Ratio ry = ToRatio(y);
-                
+
                 return rx.numerator.Equals(ry.numerator)
                     && rx.denominator.Equals(ry.denominator);
             }
@@ -3166,7 +3166,7 @@ public override bool gte(object x, object y)
 
             public override object negate(object x)
             {
-                Ratio rx = (Ratio)x;    
+                Ratio rx = (Ratio)x;
                 return new Ratio(-rx.numerator, rx.denominator);
             }
 
@@ -3338,7 +3338,7 @@ public object divide(object x, object y)
                 {
                     return BigDecimal.Create(dx).Divide(BigDecimal.Create(dy));
                 }
-          
+
             }
 
             public object quotient(object x, object y)
@@ -3384,20 +3384,20 @@ public object negate(object x)
             public object negateP(object x)
             {
                 decimal val = Util.ConvertToDecimal(x);
-                return -val; 
+                return -val;
             }
 
             public object unchecked_negate(object x)
             {
                 decimal val = Util.ConvertToDecimal(x);
-                return -val; 
+                return -val;
             }
 
 
             public object inc(object x)
             {
                 decimal val = Util.ConvertToDecimal(x);
-                return val + 1; 
+                return val + 1;
             }
 
             public object incP(object x)
@@ -3421,7 +3421,7 @@ public object unchecked_inc(object x)
             public object dec(object x)
             {
                 decimal val = Util.ConvertToDecimal(x);
-                return val - 1; 
+                return val - 1;
             }
 
             public object decP(object x)
@@ -3536,7 +3536,7 @@ public override object multiply(object x, object y)
 
             public override object divide(object x, object y)
             {
-                return BIDivide(ToBigInteger(x),ToBigInteger(y));
+                return BIDivide(ToBigInteger(x), ToBigInteger(y));
             }
 
             public override object quotient(object x, object y)
@@ -3759,13 +3759,13 @@ public override object abs(object x)
 
         #region Ops/BitOps dispatching
 
-        static readonly LongOps LONG_OPS = new LongOps();
-        static readonly ULongOps ULONG_OPS = new ULongOps();
-        static readonly DoubleOps DOUBLE_OPS = new DoubleOps();
-        static readonly RatioOps RATIO_OPS = new RatioOps();
-        static readonly ClrDecimalOps CLRDECIMAL_OPS = new ClrDecimalOps();
-        static readonly BigIntOps BIGINT_OPS = new BigIntOps();
-        static readonly BigDecimalOps BIGDECIMAL_OPS = new BigDecimalOps();
+        static readonly LongOps LONG_OPS = new();
+        static readonly ULongOps ULONG_OPS = new();
+        static readonly DoubleOps DOUBLE_OPS = new();
+        static readonly RatioOps RATIO_OPS = new();
+        static readonly ClrDecimalOps CLRDECIMAL_OPS = new();
+        static readonly BigIntOps BIGINT_OPS = new();
+        static readonly BigDecimalOps BIGDECIMAL_OPS = new();
 
         public enum Category { Integer, Floating, Decimal, Ratio }  // TODO
 
@@ -3812,14 +3812,14 @@ static Ops ops(Object x)
         [WarnBoxedMath(false)]
         public static int hasheqFrom(object x, Type xc)
         {
-            if (   xc == typeof(int)
+            if (xc == typeof(int)
                 || xc == typeof(short)
                 || xc == typeof(byte)
                 || xc == typeof(ulong)
                 || xc == typeof(uint)
                 || xc == typeof(ushort)
                 || xc == typeof(sbyte)
-                || (xc == typeof(BigInteger) && lte(x,Int64.MaxValue) && gte(x,Int64.MinValue)))
+                || (xc == typeof(BigInteger) && lte(x, Int64.MaxValue) && gte(x, Int64.MinValue)))
             {
                 long lpart = Util.ConvertToLong(x);
                 return Murmur3.HashLong(lpart);
@@ -3850,7 +3850,7 @@ public static int hasheqFrom(object x, Type xc)
                 }
             }
 
-            if ( xc == typeof(float) && x.Equals(-0.0f))
+            if (xc == typeof(float) && x.Equals(-0.0f))
             {
                 return 0; // match 0.0f
             }
@@ -3867,7 +3867,7 @@ public static int hasheq(object x)
             if (xc == typeof(long))
             {
                 //return (int)(lpart ^ (lpart >> 32));
-                return Murmur3.HashLong((long) x);
+                return Murmur3.HashLong((long)x);
             }
             if (xc == typeof(double))
             {
@@ -3908,7 +3908,7 @@ static long bitOpsCast(object x)
         }
 
         #endregion
-       
+
         #region Array c-tors
 
 
@@ -4522,7 +4522,7 @@ public static long and(long x, long y)
 
         public static long or(object x, object y)
         {
-            return or(bitOpsCast(x),bitOpsCast(y));
+            return or(bitOpsCast(x), bitOpsCast(y));
         }
 
 

Original file line number	Diff line number	Diff line change
`@@ -162,10 +162,10 @@ interface Ops`
`162`	`162`	`{`
`163`	`163`	`Ops combine(Ops y);`
`164`	`164`	`Ops opsWith(LongOps x);`
`165`		`- Ops opsWith(ULongOps x);`
	`165`	`+ Ops opsWith(ULongOps x);`
`166`	`166`	`Ops opsWith(DoubleOps x);`
`167`	`167`	`Ops opsWith(RatioOps x);`
`168`		`- Ops opsWith(ClrDecimalOps x);`
	`168`	`+ Ops opsWith(ClrDecimalOps x);`
`169`	`169`	`Ops opsWith(BigIntOps x);`
`170`	`170`	`Ops opsWith(BigDecimalOps x);`
`171`	`171`
`@@ -238,7 +238,7 @@ public object incP(object x)`
`238`	`238`	`{`
`239`	`239`	`return inc(x);`
`240`	`240`	`}`
`241`		`-`
	`241`	`+`
`242`	`242`	`public object unchecked_inc(object x)`
`243`	`243`	`{`
`244`	`244`	`return inc(x);`
`@@ -274,7 +274,7 @@ public object unchecked_dec(object x)`
`274`	`274`	`public abstract bool equiv(object x, object y);`
`275`	`275`	`public abstract bool lt(object x, object y);`
`276`	`276`	`public abstract bool lte(object x, object y);`
`277`		`- public abstract bool gte(object x, object y);`
	`277`	`+ public abstract bool gte(object x, object y);`
`278`	`278`	`public abstract object negate(object x);`
`279`	`279`	`public abstract object inc(object x);`
`280`	`280`	`public abstract object dec(object x);`
`@@ -302,7 +302,7 @@ public object unchecked_dec(object x)`
`302`	`302`	`public static bool isZero(ulong x) { return x == 0; }`
`303`	`303`
`304`	`304`
`305`		`- public static bool isZero(decimal x) { return x == 0m; }`
	`305`	`+ public static bool isZero(decimal x) { return x == 0m; }`
`306`	`306`
`307`	`307`
`308`	`308`
`@@ -584,7 +584,7 @@ public static ulong minus(ulong x)`
`584`	`584`
`585`	`585`
`586`	`586`	`public static double minusP(double x) { return -x; }`
`587`		`-`
	`587`	`+`
`588`	`588`
`589`	`589`	`public static object minusP(long x)`
`590`	`590`	`{`
`@@ -680,7 +680,7 @@ public static ulong minus(ulong x, ulong y)`
`680`	`680`
`681`	`681`	`public static object minus(ulong x, long y) { return minus((Object)x, (Object)y); }`
`682`	`682`
`683`		`-`
	`683`	`+`
`684`	`684`
`685`	`685`	`public static object minusP(object x, object y)`
`686`	`686`	`{`
`@@ -1179,7 +1179,7 @@ public static double quotient(double n, double d)`
`1179`	`1179`
`1180`	`1180`
`1181`	`1181`	`public static double quotient(long x, double y) { return quotient((double)x, y); }`
`1182`		`-`
	`1182`	`+`
`1183`	`1183`
`1184`	`1184`	`public static object quotient(long x, Object y) { return quotient((Object)x, y); }`
`1185`	`1185`
`@@ -1227,7 +1227,7 @@ public static double remainder(double n, double d)`
`1227`	`1227`
`1228`	`1228`
`1229`	`1229`	`public static object remainder(Object x, double y) { return remainder(x, (Object)y); }`
`1230`		`-`
	`1230`	`+`
`1231`	`1231`
`1232`	`1232`	`public static double remainder(double x, long y) { return remainder(x, (double)y); }`
`1233`	`1233`
`@@ -1359,8 +1359,8 @@ public static object decP(decimal x)`
`1359`	`1359`
`1360`	`1360`
`1361`	`1361`
`1362`		`- public static double unchecked_inc(double x) { return inc(x); }`
`1363`		`-`
	`1362`	`+ public static double unchecked_inc(double x) { return inc(x); }`
	`1363`	`+`
`1364`	`1364`
`1365`	`1365`
`1366`	`1366`	`public static long unchecked_inc(long x) { return x + 1; }`
`@@ -1371,8 +1371,8 @@ public static object decP(decimal x)`
`1371`	`1371`
`1372`	`1372`
`1373`	`1373`
`1374`		`- public static decimal unchecked_inc(decimal x) { return inc(x); }`
`1375`		`-`
	`1374`	`+ public static decimal unchecked_inc(decimal x) { return inc(x); }`
	`1375`	`+`
`1376`	`1376`
`1377`	`1377`
`1378`	`1378`	`public static object unchecked_dec(object x) { return ops(x).unchecked_dec(x); }`
`@@ -1388,10 +1388,10 @@ public static object decP(decimal x)`
`1388`	`1388`
`1389`	`1389`
`1390`	`1390`	`public static ulong unchecked_dec(ulong x) { return x - 1; }`
`1391`		`-`
`1392`	`1391`
`1393`	`1392`
`1394`		`- public static decimal unchecked_dec(decimal x) { return dec(x); }`
	`1393`	`+`
	`1394`	`+ public static decimal unchecked_dec(decimal x) { return dec(x); }`
`1395`	`1395`
`1396`	`1396`	`#endregion`
`1397`	`1397`
`@@ -1415,7 +1415,7 @@ public static int compare(object x, object y)`
`1415`	`1415`	`else`
`1416`	`1416`	`return 0;`
`1417`	`1417`	`}`
`1418`		`-`
	`1418`	`+`
`1419`	`1419`	`#endregion`
`1420`	`1420`
`1421`	`1421`	`#region equiv, lt, lte, gt, gte`
`@@ -1478,7 +1478,7 @@ public static int compare(object x, object y)`
`1478`	`1478`
`1479`	`1479`
`1480`	`1480`	`public static bool lt(double x, double y) { return x < y; }`
`1481`		`-`
	`1481`	`+`
`1482`	`1482`
`1483`	`1483`	`public static bool lt(long x, long y) { return x < y; }`
`1484`	`1484`
`@@ -1629,7 +1629,7 @@ public static int compare(object x, object y)`
`1629`	`1629`
`1630`	`1630`
`1631`	`1631`	`public static bool gt(ulong x, long y) { return gt((Object)x, (Object)y); }`
`1632`		`-`
	`1632`	`+`
`1633`	`1633`
`1634`	`1634`
`1635`	`1635`	`public static bool gte(object x, object y) { return ops(x).combine(ops(y)).gte(x, y); }`
`@@ -1897,7 +1897,7 @@ public static long min(long x, long y)`
`1897`	`1897`
`1898`	`1898`	`public static ulong min(ulong x, ulong y)`
`1899`	`1899`	`{`
`1900`		`- return Math.Min(x, y);`
	`1900`	`+ return Math.Min(x, y);`
`1901`	`1901`	`}`
`1902`	`1902`
`1903`	`1903`
`@@ -2217,7 +2217,7 @@ public static Ratio ToRatio(object x)`
`2217`	`2217`	`return r;`
`2218`	`2218`
`2219`	`2219`	`BigDecimal bx = x as BigDecimal;`
`2220`		`- if ( bx != null )`
	`2220`	`+ if (bx != null)`
`2221`	`2221`	`{`
`2222`	`2222`	`int exp = bx.Exponent;`
`2223`	`2223`	`if (exp >= 0)`
`@@ -2233,13 +2233,13 @@ public static Ratio ToRatio(object x)`
`2233`	`2233`	`[WarnBoxedMath(false)]`
`2234`	`2234`	`public static object rationalize(object x)`
`2235`	`2235`	`{`
`2236`		`- if (x is float f)`
	`2236`	`+ if (x is float f)`
`2237`	`2237`	`return rationalize(BigDecimal.Create(f));`
`2238`	`2238`
`2239`		`- if (x is double d)`
	`2239`	`+ if (x is double d)`
`2240`	`2240`	`return rationalize(BigDecimal.Create(d));`
`2241`	`2241`
`2242`		`- BigDecimal bx = (BigDecimal)x;`
	`2242`	`+ BigDecimal bx = x as BigDecimal;`
`2243`	`2243`	`if (bx != null)`
`2244`	`2244`	`{`
`2245`	`2245`	`int exp = bx.Exponent;`
`@@ -2296,7 +2296,7 @@ public static int shiftLeftInt(int x, int n)`
`2296`	`2296`
`2297`	`2297`	`public static object shiftLeft(object x, object n)`
`2298`	`2298`	`{`
`2299`		`- return shiftLeft(bitOpsCast(x),bitOpsCast(n));`
	`2299`	`+ return shiftLeft(bitOpsCast(x), bitOpsCast(n));`
`2300`	`2300`	`}`
`2301`	`2301`
`2302`	`2302`
`@@ -2458,7 +2458,7 @@ public bool isNeg(object x)`
`2458`	`2458`
`2459`	`2459`	`public object add(object x, object y)`
`2460`	`2460`	`{`
`2461`		`- return num(Numbers.add( Util.ConvertToLong(x), Util.ConvertToLong(y)));`
	`2461`	`+ return num(Numbers.add(Util.ConvertToLong(x), Util.ConvertToLong(y)));`
`2462`	`2462`	`}`
`2463`	`2463`
`2464`	`2464`	`public object addP(object x, object y)`
`@@ -2517,7 +2517,7 @@ public object divide(object x, object y)`
`2517`	`2517`	`long n = Util.ConvertToLong(x);`
`2518`	`2518`	`long val = Util.ConvertToLong(y);`
`2519`	`2519`
`2520`		`- if ( n == long.MinValue \|\| val == long.MinValue )`
	`2520`	`+ if (n == long.MinValue \|\| val == long.MinValue)`
`2521`	`2521`	`return BIGINT_OPS.divide(x, y);`
`2522`	`2522`
`2523`	`2523`	`long gcd1 = gcd(n, val);`
`@@ -2565,7 +2565,7 @@ public bool gte(object x, object y)`
`2565`	`2565`	`{`
`2566`	`2566`	`return Util.ConvertToLong(x) >= Util.ConvertToLong(y);`
`2567`	`2567`	`}`
`2568`		`-`
	`2568`	`+`
`2569`	`2569`	`public object negate(object x)`
`2570`	`2570`	`{`
`2571`	`2571`	`long val = Util.ConvertToLong(x);`
`@@ -2710,9 +2710,9 @@ public object addP(object x, object y)`
`2710`	`2710`	`{`
`2711`	`2711`	`ulong ulx = Util.ConvertToULong(x);`
`2712`	`2712`	`ulong uly = Util.ConvertToULong(y);`
`2713`		`- if ( ulx > ulong.MaxValue - uly )`
	`2713`	`+ if (ulx > ulong.MaxValue - uly)`
`2714`	`2714`	`return BIGINT_OPS.add(x, y);`
`2715`		`- return num(ulx+uly);`
	`2715`	`+ return num(ulx + uly);`
`2716`	`2716`	`}`
`2717`	`2717`
`2718`	`2718`	`public object unchecked_add(object x, object y)`
`@@ -2765,7 +2765,7 @@ public object divide(object x, object y)`
`2765`	`2765`	`ulong d = val / gcd1;`
`2766`	`2766`	`if (d == 1)`
`2767`	`2767`	`return num(n);`
`2768`		`-`
	`2768`	`+`
`2769`	`2769`	`return new Ratio(BigInteger.Create(n), BigInteger.Create(d));`
`2770`	`2770`	`}`
`2771`	`2771`
`@@ -3135,7 +3135,7 @@ public override bool equiv(object x, object y)`
`3135`	`3135`	`{`
`3136`	`3136`	`Ratio rx = ToRatio(x);`
`3137`	`3137`	`Ratio ry = ToRatio(y);`
`3138`		`-`
	`3138`	`+`
`3139`	`3139`	`return rx.numerator.Equals(ry.numerator)`
`3140`	`3140`	`&& rx.denominator.Equals(ry.denominator);`
`3141`	`3141`	`}`
`@@ -3166,7 +3166,7 @@ public override bool gte(object x, object y)`
`3166`	`3166`
`3167`	`3167`	`public override object negate(object x)`
`3168`	`3168`	`{`
`3169`		`- Ratio rx = (Ratio)x;`
	`3169`	`+ Ratio rx = (Ratio)x;`
`3170`	`3170`	`return new Ratio(-rx.numerator, rx.denominator);`
`3171`	`3171`	`}`
`3172`	`3172`
`@@ -3338,7 +3338,7 @@ public object divide(object x, object y)`
`3338`	`3338`	`{`
`3339`	`3339`	`return BigDecimal.Create(dx).Divide(BigDecimal.Create(dy));`
`3340`	`3340`	`}`
`3341`		`-`
	`3341`	`+`
`3342`	`3342`	`}`
`3343`	`3343`
`3344`	`3344`	`public object quotient(object x, object y)`
`@@ -3384,20 +3384,20 @@ public object negate(object x)`
`3384`	`3384`	`public object negateP(object x)`
`3385`	`3385`	`{`
`3386`	`3386`	`decimal val = Util.ConvertToDecimal(x);`
`3387`		`- return -val;`
	`3387`	`+ return -val;`
`3388`	`3388`	`}`
`3389`	`3389`
`3390`	`3390`	`public object unchecked_negate(object x)`
`3391`	`3391`	`{`
`3392`	`3392`	`decimal val = Util.ConvertToDecimal(x);`
`3393`		`- return -val;`
	`3393`	`+ return -val;`
`3394`	`3394`	`}`
`3395`	`3395`
`3396`	`3396`
`3397`	`3397`	`public object inc(object x)`
`3398`	`3398`	`{`
`3399`	`3399`	`decimal val = Util.ConvertToDecimal(x);`
`3400`		`- return val + 1;`
	`3400`	`+ return val + 1;`
`3401`	`3401`	`}`
`3402`	`3402`
`3403`	`3403`	`public object incP(object x)`
`@@ -3421,7 +3421,7 @@ public object unchecked_inc(object x)`
`3421`	`3421`	`public object dec(object x)`
`3422`	`3422`	`{`
`3423`	`3423`	`decimal val = Util.ConvertToDecimal(x);`
`3424`		`- return val - 1;`
	`3424`	`+ return val - 1;`
`3425`	`3425`	`}`
`3426`	`3426`
`3427`	`3427`	`public object decP(object x)`
`@@ -3536,7 +3536,7 @@ public override object multiply(object x, object y)`
`3536`	`3536`
`3537`	`3537`	`public override object divide(object x, object y)`
`3538`	`3538`	`{`
`3539`		`- return BIDivide(ToBigInteger(x),ToBigInteger(y));`
	`3539`	`+ return BIDivide(ToBigInteger(x), ToBigInteger(y));`
`3540`	`3540`	`}`
`3541`	`3541`
`3542`	`3542`	`public override object quotient(object x, object y)`
`@@ -3759,13 +3759,13 @@ public override object abs(object x)`
`3759`	`3759`
`3760`	`3760`	`#region Ops/BitOps dispatching`
`3761`	`3761`
`3762`		`- static readonly LongOps LONG_OPS = new LongOps();`
`3763`		`- static readonly ULongOps ULONG_OPS = new ULongOps();`
`3764`		`- static readonly DoubleOps DOUBLE_OPS = new DoubleOps();`
`3765`		`- static readonly RatioOps RATIO_OPS = new RatioOps();`
`3766`		`- static readonly ClrDecimalOps CLRDECIMAL_OPS = new ClrDecimalOps();`
`3767`		`- static readonly BigIntOps BIGINT_OPS = new BigIntOps();`
`3768`		`- static readonly BigDecimalOps BIGDECIMAL_OPS = new BigDecimalOps();`
	`3762`	`+ static readonly LongOps LONG_OPS = new();`
	`3763`	`+ static readonly ULongOps ULONG_OPS = new();`
	`3764`	`+ static readonly DoubleOps DOUBLE_OPS = new();`
	`3765`	`+ static readonly RatioOps RATIO_OPS = new();`
	`3766`	`+ static readonly ClrDecimalOps CLRDECIMAL_OPS = new();`
	`3767`	`+ static readonly BigIntOps BIGINT_OPS = new();`
	`3768`	`+ static readonly BigDecimalOps BIGDECIMAL_OPS = new();`
`3769`	`3769`
`3770`	`3770`	`public enum Category { Integer, Floating, Decimal, Ratio } // TODO`
`3771`	`3771`
`@@ -3812,14 +3812,14 @@ static Ops ops(Object x)`
`3812`	`3812`	`[WarnBoxedMath(false)]`
`3813`	`3813`	`public static int hasheqFrom(object x, Type xc)`
`3814`	`3814`	`{`
`3815`		`- if ( xc == typeof(int)`
	`3815`	`+ if (xc == typeof(int)`
`3816`	`3816`	`\|\| xc == typeof(short)`
`3817`	`3817`	`\|\| xc == typeof(byte)`
`3818`	`3818`	`\|\| xc == typeof(ulong)`
`3819`	`3819`	`\|\| xc == typeof(uint)`
`3820`	`3820`	`\|\| xc == typeof(ushort)`
`3821`	`3821`	`\|\| xc == typeof(sbyte)`
`3822`		`- \|\| (xc == typeof(BigInteger) && lte(x,Int64.MaxValue) && gte(x,Int64.MinValue)))`
	`3822`	`+ \|\| (xc == typeof(BigInteger) && lte(x, Int64.MaxValue) && gte(x, Int64.MinValue)))`
`3823`	`3823`	`{`
`3824`	`3824`	`long lpart = Util.ConvertToLong(x);`
`3825`	`3825`	`return Murmur3.HashLong(lpart);`
`@@ -3850,7 +3850,7 @@ public static int hasheqFrom(object x, Type xc)`
`3850`	`3850`	`}`
`3851`	`3851`	`}`
`3852`	`3852`
`3853`		`- if ( xc == typeof(float) && x.Equals(-0.0f))`
	`3853`	`+ if (xc == typeof(float) && x.Equals(-0.0f))`
`3854`	`3854`	`{`
`3855`	`3855`	`return 0; // match 0.0f`
`3856`	`3856`	`}`
`@@ -3867,7 +3867,7 @@ public static int hasheq(object x)`
`3867`	`3867`	`if (xc == typeof(long))`
`3868`	`3868`	`{`
`3869`	`3869`	`//return (int)(lpart ^ (lpart >> 32));`
`3870`		`- return Murmur3.HashLong((long) x);`
	`3870`	`+ return Murmur3.HashLong((long)x);`
`3871`	`3871`	`}`
`3872`	`3872`	`if (xc == typeof(double))`
`3873`	`3873`	`{`
`@@ -3908,7 +3908,7 @@ static long bitOpsCast(object x)`
`3908`	`3908`	`}`
`3909`	`3909`
`3910`	`3910`	`#endregion`
`3911`		`-`
	`3911`	`+`
`3912`	`3912`	`#region Array c-tors`
`3913`	`3913`
`3914`	`3914`
`@@ -4522,7 +4522,7 @@ public static long and(long x, long y)`
`4522`	`4522`
`4523`	`4523`	`public static long or(object x, object y)`
`4524`	`4524`	`{`
`4525`		`- return or(bitOpsCast(x),bitOpsCast(y));`
	`4525`	`+ return or(bitOpsCast(x), bitOpsCast(y));`
`4526`	`4526`	`}`
`4527`	`4527`
`4528`	`4528`