Investigation checkin.

Author: Oren (electricessence)

source/Open.Numeric.Primes.csproj

@@ -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,7 +4,7 @@ namespace Open.Numeric.Primes
 {
 	public static class Polynomial
 	{
-		const ulong MAX_ULONG_DIVISOR = 25043747693UL;
+		const ulong MAX_ULONG_DIVISOR = 4294967296UL;
 
 		internal static bool IsPrimeInternal(in ulong value)
 		{
@@ -25,6 +25,52 @@ internal static bool IsPrimeInternal(in ulong value)
 			return true;
 		}
 
+		const uint MAX_UINT_DIVISOR = 65536U;
+
+		internal static bool IsPrimeInternal(uint value)
+		{
+			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 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 +107,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 +125,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 +143,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

source/PrimalityBase.cs

@@ -95,6 +95,198 @@ public IEnumerable<T> Factors(T value, bool omitOneAndValue)
 		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 	}
 
+	public abstract class PrimalityU32Base : PrimalityBase<uint>
+	{
+		// ReSharper disable once OptionalParameterHierarchyMismatch
+		protected override IEnumerable<uint> ValidPrimeTests(uint staringAt = 2U)
+		{
+			var n = staringAt;
+			if (n > 2U)
+			{
+				if (n % 2U == 0)
+					n++;
+			}
+			else
+			{
+				yield return 2U;
+				n = 3U;
+			}
+
+			for (; n < uint.MaxValue - 1U; n += 2U)
+				yield return n;
+		}
+
+		/// <inheritdoc />
+		public override IEnumerator<uint> GetEnumerator()
+			=> StartingAt(2U).GetEnumerator();
+
+		/// <summary>
+		/// Returns an enumerable that will iterate every prime starting at the starting value.
+		/// </summary>
+		/// <param name="value">Allows for skipping ahead any integer before checking for inclusive and subsequent primes.  Passing a negative number here will produce a negative set of prime numbers.</param>
+		/// <returns>An enumerable that will iterate every prime starting at the starting value</returns>
+		[SuppressMessage("ReSharper", "SuspiciousTypeConversion.Global")]
+		public IEnumerable<int> StartingAt(int value)
+		{
+			var absStart = (uint)Math.Abs(value);
+			if (value < 0)
+			{
+				return StartingAt(absStart)
+					.TakeWhile(v => v < int.MaxValue)
+					.Select(v => -Convert.ToInt32(v));
+			}
+
+			return StartingAt(absStart)
+				.TakeWhile(v => v < int.MaxValue)
+				.Select(Convert.ToInt32);
+		}
+
+		/// <inheritdoc />
+		public override IEnumerable<KeyValuePair<uint, uint>> Indexed()
+		{
+			uint count = 0U;
+			foreach (var n in this)
+			{
+				count++;
+				yield return new KeyValuePair<uint, uint>(count, n);
+			}
+		}
+
+		/// <inheritdoc />
+		public override ParallelQuery<uint> InParallel(in uint staringAt, ushort? degreeOfParallelism = null)
+		{
+			var tests = ValidPrimeTests(staringAt)
+				.AsParallel().AsOrdered();
+
+			if (degreeOfParallelism.HasValue)
+				tests = tests.WithDegreeOfParallelism(degreeOfParallelism.Value);
+
+			return tests.Where(IsPrime);
+		}
+
+		/// <inheritdoc />
+		public override ParallelQuery<uint> InParallel(ushort? degreeOfParallelism = null)
+			=> InParallel(2U, degreeOfParallelism);
+
+		/// <inheritdoc />
+		public override IEnumerable<uint> Factors(uint value)
+		{
+			if (value != 0U)
+			{
+				yield return 1U;
+				if (value == 1U) yield break;
+				var last = 1U;
+
+				// For larger numbers, a quick prime check can prevent large iterations.
+				if (IsFactorable(value))
+				{
+					foreach (var p in this)
+					{
+						var stop = value / last; // The list of possibilities shrinks for each test.
+						if (p > stop) break; // Exceeded possibilities? 
+						while ((value % p) == 0U)
+						{
+							value /= p;
+							yield return p;
+							if (value == 1U) yield break;
+						}
+						last = p;
+					}
+				}
+			}
+
+			yield return value;
+		}
+
+		/// <summary>
+		/// Iterates the prime factors of the provided value.
+		/// First multiple is always 0, 1 or -1.
+		/// </summary>
+		/// <param name="value">The value to factorize.</param>
+		/// <returns>An enumerable that contains the prime factors of the provided value starting with 0, 1, or -1 for sign retention.</returns>
+		public IEnumerable<int> Factors(int value)
+		{
+			if (value != 0L)
+			{
+				yield return value < 0 ? -1 : 1;
+				if (value < 0) value = Math.Abs(value);
+				if (value == 1)
+					yield break;
+
+				var last = 1;
+
+				// For larger numbers, a quick prime check can prevent large iterations.
+				if (IsFactorable(value))
+				{
+					foreach (var p in StartingAt(2))
+					{
+						var stop = value / last; // The list of possibilities shrinks for each test.
+						if (p > stop) break; // Exceeded possibilities? 
+						while ((value % p) == 0)
+						{
+							value /= p;
+							yield return p;
+							if (value == 1) yield break;
+						}
+						last = p;
+					}
+				}
+			}
+			yield return value;
+		}
+
+		protected bool IsFactorable(int value)
+			=> !IsPrime(value);
+
+		/// <inheritdoc />
+		public override uint Next(in uint after)
+			=> StartingAt(after + 1).First();
+
+		/// <summary>
+		/// Finds the next prime number after the number given.
+		/// </summary>
+		/// <param name="after">The excluded lower boundary to start with.  If this number is negative, then the result will be the next greater magnitude value prime as negative number.</param>
+		/// <returns>The next prime after the number provided.</returns>
+		public int Next(in int after)
+			=> StartingAt(after + 1).First();
+
+		/// <inheritdoc />
+		public sealed override bool IsPrime(in 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 % 2U == 0 || value % 3U == 0)
+						return false;
+
+					return IsPrimeInternal(value);
+			}
+		}
+
+		/// <summary>
+		/// 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 bool IsPrime(int value)
+			=> IsPrime(Convert.ToUInt32(Math.Abs(value)));
+
+		/// <summary>
+		/// Should only check for primes that aren't divisible by 2 or 3.
+		/// </summary>
+		protected abstract bool IsPrimeInternal(uint value);
+	}
+
+
 	public abstract class PrimalityU64Base : PrimalityBase<ulong>
 	{
 		// ReSharper disable once OptionalParameterHierarchyMismatch

source/Primes.cs

@@ -13,6 +13,14 @@ namespace Open.Numeric.Primes
 	/// </summary>
 	public static class Number
 	{
+		/// <summary>
+		/// Validates if a number is prime.
+		/// </summary>
+		/// <param name="value">Value to verify.</param>
+		/// <returns>True if the provided value is a prime number</returns>
+		public static bool IsPrime(uint value)
+			=> Polynomial.IsPrimeInternal(value);
+
 		/// <summary>
 		/// Validates if a number is prime.
 		/// </summary>