Small optimizations

PerfectNumbers.Core/FactorEntry.cs

@@ -1,8 +1,19 @@
 namespace PerfectNumbers.Core
 {
-    public readonly struct FactorEntry(ulong value, int exponent)
+    public readonly struct FactorEntry
-    {
+	{
-        public readonly ulong Value = value;
+		public readonly ulong Value;
-        public readonly int Exponent = exponent;
+		public readonly int Exponent = 1;
-    }
+
+		public FactorEntry(ulong value, int exponent)
+		{
+			Value = value;
+			Exponent = exponent;
+		}
+
+		public FactorEntry(ulong value)
+		{
+			Value = value;
+		}
+	}
 }

PerfectNumbers.Core/PartialFactorResult.cs

@@ -5,11 +5,11 @@ namespace PerfectNumbers.Core
 {
     public sealed class PartialFactorResult
     {
-        [ThreadStatic]
+		[ThreadStatic]
-        private static PartialFactorResult? s_poolHead;
+		private static PartialFactorResult? s_poolHead;
 
         public FactorEntry[]? Factors;
-        private PartialFactorResult? _next;
+		private PartialFactorResult? _next;
         public ulong Cofactor;
         public bool FullyFactored;
         public int Count;
@@ -38,8 +38,8 @@ namespace PerfectNumbers.Core
             return instance;
         }
 
-        public static readonly PartialFactorResult Empty = new PartialFactorResult
+        public static readonly PartialFactorResult Empty = new()
-        {
+		{
             Cofactor = 1UL,
             FullyFactored = true,
         };
@@ -50,13 +50,13 @@ namespace PerfectNumbers.Core
             if (source is null || Count == 0)
             {
                 FactorEntry[] local = ArrayPool<FactorEntry>.Shared.Rent(1);
-                local[0] = new FactorEntry(prime, 1);
+                local[0] = new FactorEntry(prime);
                 return Rent(local, 1UL, true, 1);
             }
 
             FactorEntry[] extended = ArrayPool<FactorEntry>.Shared.Rent(Count + 1);
             Array.Copy(source, 0, extended, 0, Count);
-            extended[Count] = new FactorEntry(prime, 1);
+            extended[Count] = new FactorEntry(prime);
             Span<FactorEntry> span = extended.AsSpan(0, Count + 1);
             span.Sort(static (a, b) => a.Value.CompareTo(b.Value));
             return Rent(extended, 1UL, true, Count + 1);

PerfectNumbers.Core/PrimeOrderCalculator.Wide.cs

@@ -1062,15 +1062,20 @@ internal static partial class PrimeOrderCalculator
 
     private readonly struct FactorEntry128
     {
-        public FactorEntry128(UInt128 value, int exponent)
+		public FactorEntry128(UInt128 value)
-        {
+		{
-            Value = value;
+			Value = value;
-            Exponent = exponent;
+		}
-        }
 
-        public UInt128 Value { get; }
+		public FactorEntry128(UInt128 value, int exponent)
+		{
+			Value = value;
+			Exponent = exponent;
+		}
 
-        public int Exponent { get; }
+        public readonly UInt128 Value;
+
+		public readonly int Exponent = 1;
     }
 
     private readonly struct PartialFactorResult128
@@ -1083,13 +1088,13 @@ internal static partial class PrimeOrderCalculator
             Count = count;
         }
 
-        public FactorEntry128[]? Factors { get; }
+		public readonly FactorEntry128[]? Factors;
 
-        public UInt128 Cofactor { get; }
+		public readonly UInt128 Cofactor;
 
-        public bool FullyFactored { get; }
+		public readonly bool FullyFactored;
 
-        public int Count { get; }
+		public readonly int Count;
 
         public static PartialFactorResult128 Empty => new(null, UInt128.One, true, 0);
 
@@ -1097,14 +1102,13 @@ internal static partial class PrimeOrderCalculator
         {
             if (Factors is null)
             {
-                FactorEntry128[] local = new FactorEntry128[1];
+                FactorEntry128[] local = [new FactorEntry128(prime)];
-                local[0] = new FactorEntry128(prime, 1);
+				return new PartialFactorResult128(local, UInt128.One, true, 1);
-                return new PartialFactorResult128(local, UInt128.One, true, 1);
             }
 
             FactorEntry128[] extended = new FactorEntry128[Count + 1];
             Array.Copy(Factors, extended, Count);
-            extended[Count] = new FactorEntry128(prime, 1);
+            extended[Count] = new FactorEntry128(prime);
             return new PartialFactorResult128(extended, UInt128.One, true, Count + 1);
         }
     }

PerfectNumbers.Core/PrimeOrderCalculator.cs

@@ -248,7 +248,7 @@ internal static partial class PrimeOrderCalculator
             // bool isPrime = PrimeTester.IsPrimeInternal(factors.Cofactor, CancellationToken.None);
             if (!factors.FullyFactored && factors.Cofactor > 1UL && isPrime)
             {
-                buffer[length] = new FactorEntry(factors.Cofactor, 1);
+                buffer[length] = new FactorEntry(factors.Cofactor);
                 length++;
             }