Use bitwise opeartions

Author: 96Octavian

primalityTest/millerRabinMethod/MillerRabinMethod.cs

@@ -93,7 +93,7 @@ private static BigInteger RandomInRangeFromZeroToPositive(BigInteger max)
         /// Miller-Rabin primality test
         /// </summary>
         /// <remarks>
-        /// Test if <paramref name="number"/> could be prime using the Miller-Rabin Primality Test with <paramref name="rounds"/> rounds.
+        /// Test if <paramref name="number"/> could be prime using the Miller-Rabin primality test with <paramref name="rounds"/> rounds.
         /// A return value of false means <paramref name="number"/> is definitely composite, while true means it is probably prime.
         /// The higher <paramref name="rounds"/> is, the more accurate the test is.
         /// </remarks>
@@ -111,9 +111,9 @@ public static bool MillerRabin(BigInteger number, int rounds = 40)
             // Factor out the powers of 2 from {number - 1} and save the result
             BigInteger d = number - 1;
             int r = 0;
-            while (d % 2 == 0)
+            while (d.IsEven)
             {
-                d /= 2;
+                d >>= 1;
                 ++r;
             }
 
@@ -138,24 +138,26 @@ public static bool MillerRabin(BigInteger number, int rounds = 40)
             }
             return true;
         }
-    }
 
-    public static class MillerRabinMethod
-    {
-        static void Main(string[] args)
+
+        public static class MillerRabinMethod
         {
-            int count = 0;
-            int upper_bound = 1000;
-            Console.WriteLine($"Prime numbers lower than {upper_bound}:");
-            for (int i = 1; i < upper_bound; ++i)
+            static void Main(string[] args)
             {
-                if (PrimalityTest.MillerRabin(i))
+                int count = 0;
+                int upper_bound = 1000;
+                Console.WriteLine($"Prime numbers lower than {upper_bound}:");
+                for (int i = 1; i < upper_bound; ++i)
                 {
-                    Console.WriteLine($"\t{i}");
-                    ++count;
+                    if (PrimalityTest.MillerRabin(i))
+                    {
+                        Console.WriteLine($"\t{i}");
+                        ++count;
+                    }
                 }
+                Console.WriteLine($"Total: {count}");
             }
-            Console.WriteLine($"Total: {count}");
         }
     }
+
 }

primalityTest/millerRabinMethod/MillerRabinMethod.java

@@ -6,11 +6,9 @@ class MillerRabinMethod {
     /**
      *
      * Generate a random BigInteger between {@code min} and {@code max}, inclusive.
-     * Random BigInteger implementation from
-     * <a href="https://stackoverflow.com/a/48855115/12771343">this StackOverflow
-     * answer</a> Uses an offset on the
-     * {@link #RandomInRangeFromZeroToPositive(BigInteger)} function to return a
-     * random BigInteger in a range.
+     * Random BigInteger implementation from <a href="https://stackoverflow.com/a/48855115/12771343">this StackOverflow answer</a>
+     * Uses an offset on the {@link #RandomInRangeFromZeroToPositive(BigInteger)}
+     * function to return a random BigInteger in a range.
      *
      * @param min lower bound
      * @param max upper bound
@@ -36,9 +34,8 @@ public static BigInteger RandomInRange(BigInteger min, BigInteger max) {
     /**
      *
      * Generate a random BigInteger smaller or equal to {@code max}. Random
-     * BigInteger implementation from
-     * <a href="https://stackoverflow.com/a/48855115/12771343">this StackOverflow
-     * answer</a> Returns a random BigInteger lower than {@code max} derived from a
+     * BigInteger implementation from <a href="https://stackoverflow.com/a/48855115/12771343">this StackOverflow* answer</a>
+     * Returns a random BigInteger lower than {@code max} derived from a
      * random byte array" />
      *
      * @param max upper bound
@@ -86,10 +83,11 @@ private static BigInteger RandomInRangeFromZeroToPositive(BigInteger max) {
 
     /**
      *
-     * Miller-Rabin primality test Test if {@code number} could be prime using the
-     * Miller-Rabin Primality Test with {@code round} rounds. A return value of
-     * false means {@code number} is definitely composite, while true means it is
-     * probably prime. The higher {@code round} is, the more accurate the test is.
+     * Miller-Rabin primality test
+     * Test if {@code number} could be prime using the Miller-Rabin primality test
+     * with {@code round} rounds. A return value of false means {@code number} is
+     * definitely composite, while true means it is probably prime.
+     * The higher {@code round} is, the more accurate the test is.
      *
      * @param number the number to be tested for primality
      * @param rounds how many rounds to use in the test
@@ -106,8 +104,8 @@ public static Boolean MillerRabin(BigInteger number, int rounds) {
         // Factor out the powers of 2 from {number - 1} and save the result
         BigInteger d = number.subtract(BigInteger.valueOf(1));
         int r = 0;
-        while (d.mod(BigInteger.valueOf(2)).equals(BigInteger.valueOf(0))) {
-            d = d.divide(BigInteger.valueOf(2));
+        while ((d.getLowestSetBit() & 1) == 0) {
+            d = d.shiftLeft(1);
             ++r;
         }
 

primalityTest/millerRabinMethod/miller_rabin_method.py

@@ -24,10 +24,9 @@ def miller_rabin_method(number: int, rounds: int = 40) -> bool:
     # Factor out the powers of 2 from {number - 1} and save the result
     d = number - 1
     r = 0
-    while d % 2 == 0:
-        d /= 2
+    while not d & 1:
+        d = d >> 1
         r += 1
-    d = int(d)
 
     # Cycle at most {round} times
     for i in range(rounds + 1):