Version 1.7.4

peteroupc · Aug 8, 2020 · 7fd42c3 · 7fd42c3
1 parent 086d3b4
commit 7fd42c3
Show file tree

Hide file tree

Showing 10 changed files with 148 additions and 42 deletions.
diff --git a/History.md b/History.md
@@ -1,5 +1,9 @@
 Release notes
 -------
+Version 1.7.4
+
+- A bug involving the Equals method was fixed
+
 Version 1.7.3
 
 - Fix bugs and regressions involving EInteger's Pow, Root, and new Gcd

diff --git a/Numbers.nuspec b/Numbers.nuspec
@@ -1,5 +1,9 @@
 <package
-><metadata><version>1.7.3</version><id>PeterO.Numbers</id><requireLicenseAcceptance>false</requireLicenseAcceptance><releaseNotes>Version 1.7.3
+><metadata><version>1.7.4</version><id>PeterO.Numbers</id><requireLicenseAcceptance>false</requireLicenseAcceptance><releaseNotes>Version 1.7.4
+
+- A bug involving the Equals method was fixed
+
+Version 1.7.3
 
 - Fix bugs and regressions involving EInteger&apos;s Pow, Root, and new Gcd
 

diff --git a/Numbers/Numbers.csproj b/Numbers/Numbers.csproj
@@ -1,9 +1,9 @@
-<Project Sdk='Microsoft.NET.Sdk'>
+<Project Sdk='Microsoft.NET.Sdk'>
 
   <PropertyGroup>
     <TargetFramework>netstandard1.0</TargetFramework>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <Version>1.7.3</Version>
+    <Version>1.7.4</Version>
     <Owners>Peter Occil</Owners>
     <Description>A C# library that supports arbitrary-precision binary and decimal floating-point numbers and rational numbers with arbitrary-precision components, and supports arithmetic with these numbers.</Description>
     <Copyright>Written by Peter O.  Any copyright is released to the Public Domain.</Copyright>
@@ -14,6 +14,10 @@
     <PackageLicenseExpression>CC0-1.0</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/peteroupc/Numbers</PackageProjectUrl>
     <PackageReleaseNotes>
+Version 1.7.4
+
+- A bug involving the Equals method was fixed
+
 Version 1.7.3
 
 - Fix bugs and regressions involving EInteger's Pow, Root, and new Gcd

diff --git a/Numbers/PeterO/Numbers/FastIntegerFixed.cs b/Numbers/PeterO/Numbers/FastIntegerFixed.cs
@@ -9,7 +9,7 @@
 
 namespace PeterO.Numbers {
   internal sealed class FastIntegerFixed : IComparable<FastIntegerFixed> {
-    [Flags]
+    // NOTE: Integer modes are mutually exclusive
     private enum IntegerMode : byte {
       SmallValue = 0,
       LargeValue = 2,
@@ -62,7 +62,7 @@ private enum IntegerMode : byte {
   } else if (i == 1) {
     cache[i - first] = One;
   } else {
- cache[i - first] = new FastIntegerFixed((byte)0, i, null);
+ cache[i - first] = new FastIntegerFixed(IntegerMode.SmallValue, i, null);
 }
 }
 return cache;
@@ -89,13 +89,12 @@ private enum IntegerMode : byte {
           return this.smallValue == fi.smallValue;
         case IntegerMode.LargeValue:
           return this.largeValue.Equals(fi.largeValue);
-        default:
-          return true;
+        default: return true;
       }
     }
 
     public override int GetHashCode() {
-      int hash = unchecked(31 + (int)this.integerMode);
+      int hash = this.integerMode.GetHashCode();
       switch (this.integerMode) {
         case IntegerMode.SmallValue:
           hash = unchecked((hash * 31) + this.smallValue);
@@ -110,7 +109,7 @@ private enum IntegerMode : byte {
     internal static FastIntegerFixed FromInt32(int intVal) {
 return (intVal >= CacheFirst && intVal <= CacheLast) ?
 Cache[intVal - CacheFirst] :
-      new FastIntegerFixed((byte)0, intVal, null);
+      new FastIntegerFixed(IntegerMode.SmallValue, intVal, null);
     }
 
     internal static FastIntegerFixed FromInt64(long longVal) {
@@ -128,7 +127,7 @@ private enum IntegerMode : byte {
     }
 
     internal int ToInt32() {
-      return (this.integerMode == 0) ?
+      return (this.integerMode == IntegerMode.SmallValue) ?
         this.smallValue : this.largeValue.ToInt32Unchecked();
     }
 
@@ -141,15 +140,16 @@ private enum IntegerMode : byte {
     }
 
     public FastInteger ToFastInteger() {
-      if (this.integerMode == 0) {
+      if (this.integerMode == IntegerMode.SmallValue) {
         return new FastInteger(this.smallValue);
       } else {
         return FastInteger.FromBig(this.largeValue);
       }
     }
 
     public FastIntegerFixed Increment() {
-      if (this.integerMode == 0 && this.smallValue != Int32.MaxValue) {
+      if (this.integerMode == IntegerMode.SmallValue && this.smallValue !=
+Int32.MaxValue) {
         return FromInt32(this.smallValue + 1);
       } else {
         return Add(this, FastIntegerFixed.One);
@@ -160,7 +160,7 @@ private enum IntegerMode : byte {
       if (value < 0) {
         throw new NotSupportedException();
       }
-      if (this.integerMode == 0 && this.smallValue >= 0) {
+      if (this.integerMode == IntegerMode.SmallValue && this.smallValue >= 0) {
         return this.smallValue % value;
       } else {
         EInteger retval = this.ToEInteger().Remainder(EInteger.FromInt32(
@@ -171,7 +171,8 @@ private enum IntegerMode : byte {
 
     public static FastIntegerFixed Add(FastIntegerFixed a,
       FastIntegerFixed b) {
-      if ((a.integerMode | b.integerMode) == 0) {
+      if (a.integerMode == IntegerMode.SmallValue &&
+           b.integerMode == IntegerMode.SmallValue) {
         if (a.smallValue == 0) {
           return b;
         }
@@ -195,7 +196,8 @@ private enum IntegerMode : byte {
     public static FastIntegerFixed Subtract(
       FastIntegerFixed a,
       FastIntegerFixed b) {
-      if (a.integerMode == 0 && b.integerMode == 0) {
+      if (a.integerMode == IntegerMode.SmallValue && b.integerMode ==
+IntegerMode.SmallValue) {
         if (b.smallValue == 0) {
           return a;
         }
@@ -213,7 +215,7 @@ private enum IntegerMode : byte {
 
     public FastIntegerFixed Add(int ib) {
       FastIntegerFixed a = this;
-      if (this.integerMode == 0) {
+      if (this.integerMode == IntegerMode.SmallValue) {
         if (ib == 0) {
           return this;
         }
@@ -237,7 +239,7 @@ private enum IntegerMode : byte {
       if (ib == 0) {
         return this;
       }
-      if (this.integerMode == 0) {
+      if (this.integerMode == IntegerMode.SmallValue) {
         if (
           (ib < 0 && Int32.MaxValue + ib >= this.smallValue) ||
           (ib > 0 && Int32.MinValue + ib <= this.smallValue)) {
@@ -260,7 +262,7 @@ private enum IntegerMode : byte {
 
     public FastIntegerFixed Add(
       EInteger b) {
-      if (this.integerMode == 0 && b.CanFitInInt32()) {
+      if (this.integerMode == IntegerMode.SmallValue && b.CanFitInInt32()) {
         return this.Add(b.ToInt32Unchecked());
       } else {
         return FastIntegerFixed.FromBig(
@@ -270,7 +272,7 @@ private enum IntegerMode : byte {
 
     public FastIntegerFixed Subtract(
       EInteger b) {
-      if (this.integerMode == 0 && b.CanFitInInt32()) {
+      if (this.integerMode == IntegerMode.SmallValue && b.CanFitInInt32()) {
         return this.Subtract(b.ToInt32Unchecked());
       } else {
         return FastIntegerFixed.FromBig(
@@ -305,7 +307,10 @@ private enum IntegerMode : byte {
             return FastIntegerFixed.FromInt32(-this.smallValue);
           }
         case IntegerMode.LargeValue:
-          return new FastIntegerFixed(IntegerMode.LargeValue, 0, this.largeValue.Negate());
+          return new FastIntegerFixed(
+            IntegerMode.LargeValue,
+            0,
+            this.largeValue.Negate());
         default: throw new InvalidOperationException();
       }
     }
@@ -336,7 +341,8 @@ private enum IntegerMode : byte {
           switch (val.integerMode) {
             case IntegerMode.SmallValue:
               int vsv = val.smallValue;
-              return (this.smallValue == vsv) ? 0 : (this.smallValue < vsv ? -1 :
+              return (this.smallValue == vsv) ? 0 : (this.smallValue < vsv ?
+-1 :
                   1);
             case IntegerMode.LargeValue:
               return -val.largeValue.CompareTo(this.smallValue);
@@ -372,7 +378,8 @@ private enum IntegerMode : byte {
     }
 
     internal bool CanFitInInt32() {
-      return this.integerMode == IntegerMode.SmallValue || this.largeValue.CanFitInInt32();
+      return this.integerMode == IntegerMode.SmallValue ||
+this.largeValue.CanFitInInt32();
     }
 
     /// <summary>This is an internal API.</summary>

diff --git a/Numbers20/Properties/AssemblyInfo.cs b/Numbers20/Properties/AssemblyInfo.cs
@@ -1,8 +1,8 @@
 using System.Reflection;
 [assembly: System.CLSCompliant(true)]
-[assembly: AssemblyInformationalVersion("1.7.3")]
-[assembly: AssemblyVersion("1.7.3.0")]
-[assembly: AssemblyFileVersion("1.7.3.0")]
+[assembly: AssemblyInformationalVersion("1.7.4")]
+[assembly: AssemblyVersion("1.7.4.0")]
+[assembly: AssemblyFileVersion("1.7.4.0")]
 [assembly: AssemblyProduct("Arbitrary-Precision Number Library")]
 [assembly: AssemblyTitle("Arbitrary-Precision Number Library")]
 [assembly: AssemblyDescription("A C# library that supports arbitrary-pre" +

diff --git a/Numbers40/Properties/AssemblyInfo.cs b/Numbers40/Properties/AssemblyInfo.cs
@@ -1,8 +1,8 @@
 using System.Reflection;
 [assembly: System.CLSCompliant(true)]
-[assembly: AssemblyInformationalVersion("1.7.3")]
-[assembly: AssemblyVersion("1.7.3.0")]
-[assembly: AssemblyFileVersion("1.7.3.0")]
+[assembly: AssemblyInformationalVersion("1.7.4")]
+[assembly: AssemblyVersion("1.7.4.0")]
+[assembly: AssemblyFileVersion("1.7.4.0")]
 [assembly: AssemblyProduct("Arbitrary-Precision Number Library")]
 [assembly: AssemblyTitle("Arbitrary-Precision Number Library")]
 [assembly: AssemblyDescription("A C# library that supports arbitrary-pre" +

diff --git a/Test/EFloatTest.cs b/Test/EFloatTest.cs
@@ -315,12 +315,24 @@ public class EFloatTest {
       Assert.IsFalse(EFloat.Zero.Equals(null));
       Assert.IsFalse(EFloat.One.Equals(EFloat.Zero));
       Assert.IsFalse(EFloat.Zero.Equals(EFloat.One));
-      Assert.AreEqual(
-        EFloat.FromString("0.009461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609"),
-        EFloat.FromString("0.009461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609"));
-      Assert.AreNotEqual(
-        EFloat.FromString("0.009461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609"),
-        EFloat.FromString("0.001809476049361792727571247490438259768858020288404502743164967883090669271207537395819291033916115474"));
+      {
+        object objectTemp =
+
+  EFloat.FromString("0.009461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609");
+        object objectTemp2 =
+
+  EFloat.FromString("0.009461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609");
+        Assert.AreEqual(objectTemp, objectTemp2);
+      }
+      {
+        object objectTemp =
+
+  EFloat.FromString("0.009461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609");
+        object objectTemp2 =
+
+  EFloat.FromString("0.001809476049361792727571247490438259768858020288404502743164967883090669271207537395819291033916115474");
+        Assert.AreNotEqual(objectTemp, objectTemp2);
+      }
       var r = new RandomGenerator();
       for (var i = 0; i < 500; ++i) {
         EFloat bigintA = RandomObjects.RandomEFloat(r);

diff --git a/Test/EIntegerTest.cs b/Test/EIntegerTest.cs
@@ -1117,12 +1117,24 @@ public class EIntegerTest {
       Assert.IsFalse(EInteger.Zero.Equals(null));
       Assert.IsFalse(EInteger.One.Equals(EInteger.Zero));
       Assert.IsFalse(EInteger.Zero.Equals(EInteger.One));
-      Assert.AreEqual(
-        EInteger.FromString("9461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609"),
-        EInteger.FromString("9461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609"));
-      Assert.AreNotEqual(
-        EInteger.FromString("9461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609"),
-        EInteger.FromString("1809476049361792727571247490438259768858020288404502743164967883090669271207537395819291033916115474"));
+      {
+        object objectTemp =
+
+  EInteger.FromString("9461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609");
+        object objectTemp2 =
+
+  EInteger.FromString("9461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609");
+        Assert.AreEqual(objectTemp, objectTemp2);
+      }
+      {
+        object objectTemp =
+
+  EInteger.FromString("9461540475412139260145553670698466186015902447450593622262751970123371581303298477485466592231565609");
+        object objectTemp2 =
+
+  EInteger.FromString("1809476049361792727571247490438259768858020288404502743164967883090669271207537395819291033916115474");
+        Assert.AreNotEqual(objectTemp, objectTemp2);
+      }
       TestCommon.AssertEqualsHashCode(
         EInteger.Zero,
         EInteger.FromString("-0"));

diff --git a/Test/RandomObjects.cs b/Test/RandomObjects.cs
@@ -12,7 +12,9 @@
 using PeterO.Numbers;
 
 namespace Test {
-  /// <summary>Description of RandomObjects.</summary>
+  /// <summary>Generates random objects of various kinds for purposes of
+  /// testing code that uses them. The methods will not necessarily
+  /// sample uniformly from all objects of a particular kind.</summary>
   public static class RandomObjects {
     private const int MaxExclusiveStringLength = 0x2000;
     private const int MaxExclusiveShortStringLength = 50;
@@ -314,6 +316,33 @@ public static class RandomObjects {
       return ed;
     }
 
+    private static EInteger BitHeavyEInteger(IRandomGenExtended rg, int count) {
+      var sb = new StringBuilder();
+      int[] oneChances = {
+        999, 1, 980, 20, 750, 250, 980,
+        20, 980, 20, 980, 20, 750, 250,
+      };
+      int oneChance = oneChances[rg.GetInt32(oneChances.Length)];
+      for (var i = 0; i < count; ++i) {
+        sb.Append((rg.GetInt32(1000) >= oneChance) ? '0' : '1');
+      }
+      return EInteger.FromRadixString(sb.ToString(), 2);
+    }
+
+    private static EInteger DigitHeavyEInteger(IRandomGenExtended rg, int
+count) {
+      var sb = new StringBuilder();
+      int[] oneChances = {
+        999, 1, 980, 20, 750, 250, 980,
+        20, 980, 20, 980, 20, 750, 250,
+      };
+      int oneChance = oneChances[rg.GetInt32(oneChances.Length)];
+      for (var i = 0; i < count; ++i) {
+        sb.Append((rg.GetInt32(1000) >= oneChance) ? '0' : '9');
+      }
+      return EInteger.FromRadixString(sb.ToString(), 10);
+    }
+
     public static EInteger RandomEInteger(IRandomGenExtended r) {
       if (r == null) {
         throw new ArgumentNullException(nameof(r));
@@ -326,6 +355,11 @@ public static class RandomObjects {
         count = (int)(((long)count * r.GetInt32(MaxNumberLength)) /
             MaxNumberLength);
         count = Math.Max(count, 1);
+        if (selection == 0 || selection == 1) {
+          return BitHeavyEInteger(r, count);
+        } else if ((selection == 2 || selection == 3) && count < 500) {
+          return DigitHeavyEInteger(r, count);
+        }
         byte[] bytes = RandomByteString(r, count);
         return EInteger.FromBytes(bytes, true);
       } else {
@@ -346,6 +380,32 @@ public static class RandomObjects {
       return EInteger.FromBytes(bytes, true);
     }
 
+    private static int IntInRange(IRandomGenExtended rg, int minInc, int
+maxExc) {
+       return minInc + rg.GetInt32(maxExc - minInc);
+    }
+
+    public static EFloat CloseToPowerOfTwo(IRandomGenExtended rg) {
+        if (rg == null) {
+          throw new ArgumentNullException(nameof(rg));
+        }
+        int pwr = (rg.GetInt32(100) < 80) ? IntInRange(rg, -20, 20) :
+          IntInRange(rg, -300, 300);
+        int pwr2 = pwr - (rg.GetInt32(100) < 80 ? IntInRange(rg, 51, 61) :
+          IntInRange(rg, 2, 300));
+        EFloat ef = null;
+        ef = (rg.GetInt32(2) == 0) ? EFloat.Create(1,
+          pwr).Add(EFloat.Create(1, pwr2)) : EFloat.Create(1,
+          pwr).Subtract(EFloat.Create(1, pwr2));
+        if (rg.GetInt32(10) == 0) {
+          pwr2 = pwr - (rg.GetInt32(100) < 80 ? IntInRange(rg, 51, 61) :
+            IntInRange(rg, 2, 300));
+          ef = (rg.GetInt32(2) == 0) ? ef.Add(EFloat.Create(1, pwr2)) :
+            ef.Subtract(EFloat.Create(1, pwr2));
+        }
+        return ef;
+    }
+
     public static EFloat RandomEFloat(IRandomGenExtended r) {
       if (r == null) {
         throw new ArgumentNullException(nameof(r));
@@ -362,6 +422,9 @@ public static class RandomObjects {
           return EFloat.NaN;
         }
       }
+      if (r.GetInt32(100) == 3) {
+        return CloseToPowerOfTwo(r);
+      }
       return EFloat.Create(
           RandomEInteger(r),
           (EInteger)(r.GetInt32(400) - 200));