Merge pull request #1 from Open-NET-Libraries/investigation

Updates to 2.0

Author: electricessence

README.md

@@ -3,3 +3,55 @@
 Methods and extensions for prime number detection and discovery.
 
 [![NuGet](https://img.shields.io/nuget/v/Open.Numeric.Primes.svg)](https://www.nuget.org/packages/Open.Numeric.Primes/)
+
+## Examples
+
+### Importing
+
+```cs
+using Open.Numeric.Primes;
+```
+
+### Primality Test
+
+```cs
+Number.IsPrime(8592868089022906369) // true
+```
+
+### Factors
+
+```cs
+Prime.Factors(12) // 2, 2, 3
+```
+
+### Common Factors
+
+```cs
+Prime.CommonFactors(84, 756, 108) // 2, 2, 3
+```
+
+### Greatest Factor
+
+```cs
+Prime.GreatestFactor(84, 756, 108) // 12
+```
+
+### Prime Discovery
+
+```cs
+// Will list the first 1000 primes.
+foreach(var prime in Prime.Numbers.Take(1000))
+{
+    Console.Write(prime);
+}
+```
+
+or
+
+```cs
+// Will list the first 1000 primes greater than (or equal to) 10,000.
+foreach(var prime in Prime.Numbers.StartingAt(10000).Take(100))
+{
+    Console.Write(prime);
+}
+```

source/Open.Numeric.Primes.csproj

@@ -11,12 +11,12 @@
 
 			Part of the "Open" set of libraries.
 		</Description>
-		<PackageTags>prime numbers;primes;prime factorization;prime detection;prime discovery</PackageTags>
+		<PackageTags>prime numbers;primes;prime factorization;prime detection;prime discovery;primality;primality test;factors;common factors;greatest factor;</PackageTags>
 		<Copyright>© electricessence (Oren F.) All rights reserved.</Copyright>
 		<PackageProjectUrl>https://github.com/Open-NET-Libraries/Open.Numeric.Primes/</PackageProjectUrl>
 		<RepositoryUrl>https://github.com/Open-NET-Libraries/Open.Numeric.Primes/</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
-		<Version>1.6.0</Version>
+		<Version>2.0.0</Version>
 		<PackageReleaseNotes></PackageReleaseNotes>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -39,6 +39,7 @@
 	<ItemGroup>
 		<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
 		<PackageReference Include="Open.Collections" Version="2.8.0" />
+		<PackageReference Include="System.Collections.Immutable" Version="1.7.1" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">

source/Optimized.cs

@@ -1,16 +1,17 @@
-using System.Linq;
+using System;
+using System.Linq;
 using System.Numerics;
 
 namespace Open.Numeric.Primes
 {
 	public class Optimized : PrimalityU64Base
 	{
+		const uint PERF_PIVOT = 805000000;
+
 		protected override bool IsPrimeInternal(in ulong value)
-		{
-			return value < 805000000
-				? Polynomial.IsPrimeInternal(in value)
+			=> value < PERF_PIVOT
+				? Polynomial.IsPrimeInternal(Convert.ToUInt32(value))
 				: MillerRabin.IsPrime(in value);
-		}
 
 		public readonly BigInt Big = new BigInt();
 
@@ -19,7 +20,10 @@ public class BigInt : PrimalityBigIntBase
 			protected override bool IsPrimeInternal(in BigInteger value)
 			{
 				if (value <= ulong.MaxValue)
+				{
+					if (value < PERF_PIVOT) Polynomial.IsPrimeInternal(Convert.ToUInt32(value));
 					return MillerRabin.IsPrime((ulong)value);
+				}
 
 				return MillerRabin.IsProbablePrime(in value) && Polynomial.IsPrime(in value, 6);
 

source/Polynomial.cs

@@ -4,11 +4,34 @@ namespace Open.Numeric.Primes
 {
 	public static class Polynomial
 	{
-		const ulong MAX_ULONG_DIVISOR = 25043747693UL;
+		const uint MAX_UINT_DIVISOR = 65536U;
 
-		internal static bool IsPrimeInternal(in ulong value)
+		internal static bool IsPrimeInternal(uint value)
 		{
-			ulong divisor = 6;
+			uint divisor = 6;
+			while (divisor * divisor - 2 * divisor + 1 <= value)
+			{
+				if (value % (divisor - 1) == 0)
+					return false;
+
+				if (value % (divisor + 1) == 0)
+					return false;
+
+				divisor += 6;
+
+				if (divisor > MAX_UINT_DIVISOR)
+					return IsPrimeInternal(value, divisor);
+			}
+			return true;
+		}
+
+		const ulong MAX_ULONG_DIVISOR = 4294967296UL;
+
+		internal static bool IsPrimeInternal(in ulong value, ulong divisor = 6)
+		{
+			if (divisor > MAX_ULONG_DIVISOR)
+				return IsPrime(value, divisor);
+
 			while (divisor * divisor - 2 * divisor + 1 <= value)
 			{
 				if (value % (divisor - 1) == 0)
@@ -22,9 +45,35 @@ internal static bool IsPrimeInternal(in ulong value)
 				if (divisor > MAX_ULONG_DIVISOR)
 					return IsPrime(value, divisor);
 			}
+
 			return true;
 		}
 
+		/// Returns true if the value provided is prime.
+		/// </summary>
+		/// <param name="value">The value to validate.</param>
+		/// <returns>True if the value provided is prime</returns>
+		public static bool IsPrime(uint value)
+		{
+			switch (value)
+			{
+				// 0 and 1 are not prime numbers
+				case 0U:
+				case 1U:
+					return false;
+				case 2U:
+				case 3U:
+					return true;
+
+				default:
+
+					if (value % 2 == 0 || value % 3 == 0)
+						return false;
+
+					return IsPrimeInternal(value);
+			}
+		}
+
 		/// <summary>
 		/// Returns true if the value provided is prime.
 		/// </summary>
@@ -61,7 +110,11 @@ public static bool IsBigPrime(in BigInteger value)
 			if (value.IsZero)
 				return false;
 
-			bool primeCheck(in BigInteger v)
+			return value.Sign == -1
+				? value != BigInteger.MinusOne && primeCheck(BigInteger.Abs(value))
+				: !value.IsOne && primeCheck(in value);
+
+			static bool primeCheck(in BigInteger v)
 			{
 				if (v == BIG.TWO || v == BIG.THREE)
 					return true;
@@ -75,10 +128,6 @@ bool primeCheck(in BigInteger v)
 				return v % 3 != 0
 					   && IsPrime(v, 6);
 			}
-
-			return value.Sign == -1
-				? value != BigInteger.MinusOne && primeCheck(BigInteger.Abs(value))
-				: !value.IsOne && primeCheck(in value);
 		}
 
 		internal static bool IsPrime(in BigInteger value, BigInteger divisor)
@@ -97,6 +146,13 @@ internal static bool IsPrime(in BigInteger value, BigInteger divisor)
 			return true;
 		}
 
+		public class U32 : PrimalityU32Base
+		{
+			// ReSharper disable once MemberHidesStaticFromOuterClass
+			protected override bool IsPrimeInternal(uint value)
+			=> Polynomial.IsPrimeInternal(value);
+		}
+
 		public class U64 : PrimalityU64Base
 		{
 			// ReSharper disable once MemberHidesStaticFromOuterClass