more binary search tests, return to old version in sieve classes

Author: TilmanNeumann

src/main/java/de/tilman_neumann/jml/BinarySearch.java

@@ -27,7 +27,7 @@ public class BinarySearch {
 	/**
 	 * Find the insert position for x into array given that array is sorted bottom-up.
 	 * 
-	 * More precisely:
+	 * This version defines the insert position unambiguously, no matter if some entries in the array occur multiple times, as
 	 * If array[maxIndex-1] >  x, return the index of the first entry of array[0].. array[maxIndex-1] greater than x.
 	 * If array[maxIndex-1] <= x, return maxIndex.
 	 * 
@@ -36,7 +36,7 @@ public class BinarySearch {
 	 * @param x
 	 * @return the insert position
 	 */
-	public int getInsertPosition_v1(int[] array, int maxIndex, int x) {
+	public int getPreciseInsertPosition(int[] array, int maxIndex, int x) {
 		if (maxIndex<=0 || array[maxIndex-1] <= x) return maxIndex;
 		int left = 0;
 		int right = maxIndex-1;
@@ -57,31 +57,11 @@ public int getInsertPosition_v1(int[] array, int maxIndex, int x) {
 		}
 		return left;
 	}
-	
-	/**
-	 * Find the insert position for x into array given that array is sorted bottom-up.
-	 * 
-	 * More precisely:
-	 * If array[maxIndex-1] >  x, return the index of the first entry of array[0].. array[maxIndex-1] greater than x.
-	 * If array[maxIndex-1] <= x, return maxIndex.
-	 * 
-	 * Faster version using Arrays.binarySearch().
-	 * 
-	 * @param array
-	 * @param maxIndex the maximum index to consider, exclusive (may be smaller than the array size)
-	 * @param x
-	 * @return the insert position
-	 */
-	public int getInsertPosition/*_v2*/(int[] array, int maxIndex, int x) {
-		// see @returns in Arrays.binarySearch() javadoc
-		int i = Arrays.binarySearch(array, 0, maxIndex, x);
-		return i >= 0 ? i + 1 : -i - 1;
-	}
 
 	/**
 	 * Find the insert position for x into array given that array is sorted bottom-up.
 	 * 
-	 * More precisely:
+	 * This version defines the insert position unambiguously, no matter if some entries in the array occur multiple times, as
 	 * If array[maxIndex-1] >  x, return the index of the first entry of array[0].. array[maxIndex-1] greater than x.
 	 * If array[maxIndex-1] <= x, return maxIndex.
 	 * 
@@ -90,7 +70,7 @@ public int getInsertPosition_v1(int[] array, int maxIndex, int x) {
 	 * @param x
 	 * @return the insert position
 	 */
-	public int getInsertPosition_v1(byte[] array, int maxIndex, byte x) {
+	public int getPreciseInsertPosition(byte[] array, int maxIndex, byte x) {
 		if (maxIndex<=0 || array[maxIndex-1] <= x) return maxIndex;
 		int left = 0;
 		int right = maxIndex-1;
@@ -111,22 +91,34 @@ public int getInsertPosition_v1(byte[] array, int maxIndex, byte x) {
 		}
 		return left;
 	}
-	
+
 	/**
 	 * Find the insert position for x into array given that array is sorted bottom-up.
 	 * 
-	 * More precisely:
-	 * If array[maxIndex-1] >  x, return the index of the first entry of array[0].. array[maxIndex-1] greater than x.
-	 * If array[maxIndex-1] <= x, return maxIndex.
-	 * 
-	 * Faster version using Arrays.binarySearch().
+	 * This version is faster than getPreciseInsertPosition(), but "If the range contains multiple elements with the specified value, there is no guarantee which one will be found."
 	 * 
 	 * @param array
 	 * @param maxIndex the maximum index to consider, exclusive (may be smaller than the array size)
 	 * @param x
 	 * @return the insert position
 	 */
-	public int getInsertPosition/*_v2*/(byte[] array, int maxIndex, byte x) {
+	public int getInsertPosition(int[] array, int maxIndex, int x) {
+		// see @returns in Arrays.binarySearch() javadoc
+		int i = Arrays.binarySearch(array, 0, maxIndex, x);
+		return i >= 0 ? i + 1 : -i - 1;
+	}
+	
+	/**
+	 * Find the insert position for x into array given that array is sorted bottom-up.
+	 * 
+	 * This version is faster than getPreciseInsertPosition(), but "If the range contains multiple elements with the specified value, there is no guarantee which one will be found."
+	 * 
+	 * @param array
+	 * @param maxIndex the maximum index to consider, but "If the range contains multiple elements with the specified value, there is no guarantee which one will be found."
+	 * @param x
+	 * @return the insert position
+	 */
+	public int getInsertPosition(byte[] array, int maxIndex, byte x) {
 		// see @returns in Arrays.binarySearch() javadoc
 		int i = Arrays.binarySearch(array, 0, maxIndex, x);
 		return i >= 0 ? i + 1 : -i - 1;

src/main/java/de/tilman_neumann/jml/factor/siqs/sieve/Sieve03h.java

@@ -201,7 +201,8 @@ public void initializeForAParameter(int d, BigInteger daParam, SolutionArrays so
 		int logP = logPMax;
 		int lastBound = filteredBaseSize;
 		for (int i=logPBoundCount-1; i>0; i--) {
-			lastBound = logPBounds[i] = binarySearch.getInsertPosition(logPArray, lastBound, (byte) --logP);
+			// here we want the precise insert position because logPArray contains many elements many times
+			lastBound = logPBounds[i] = binarySearch.getPreciseInsertPosition(logPArray, lastBound, (byte) --logP);
 			if (DEBUG) LOG.debug("logPBound[" + i + "] = " + logPBounds[i] + ", logP[" + logPBounds[i] + "] = " + logPArray[logPBounds[i]] + ", logP[" + (logPBounds[i]-1) + "] = " + logPArray[logPBounds[i]-1]);
 		}
 		logPBounds[0] = p1Index;
@@ -245,6 +246,7 @@ public SieveResult sieve() {
 		for (int lpbc=logPBoundCount-1; lpbc>=0; lpbc--, bigLogP--) {
 			int logPBound = logPBounds[lpbc];
 			for (; i>=logPBound; i--) {
+				if (DEBUG) Ensure.ensureEquals(logPArray[i], bigLogP);
 				// x1 == x2 happens only if p divides k -> for large primes p > k there are always 2 distinct solutions.
 				// x1, x2 may exceed sieveArraySize, but we allocated the arrays somewhat bigger to save the size checks.
 				sieveArray[x1Array[i]] += bigLogP;
@@ -322,6 +324,7 @@ public SieveResult sieve() {
 		for (int lpbc=logPBoundCount-1; lpbc>=0; lpbc--, bigLogP--) {
 			int logPBound = logPBounds[lpbc];
 			for (; i>=logPBound; i--) {
+				if (DEBUG) Ensure.ensureEquals(logPArray[i], bigLogP);
 				final int p = pArray[i];
 				sieveArray[p-x1Array[i]] += bigLogP;
 				sieveArray[p-x2Array[i]] += bigLogP;

src/main/java/de/tilman_neumann/jml/factor/siqs/sieve/Sieve03hU.java

@@ -17,6 +17,7 @@
 import static de.tilman_neumann.jml.factor.base.GlobalFactoringOptions.*;
 
 import java.math.BigInteger;
+import java.util.Arrays;
 
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
@@ -202,7 +203,8 @@ public void initializeForAParameter(int d, BigInteger daParam, SolutionArrays so
 		int logP = logPMax;
 		int lastBound = filteredBaseSize;
 		for (int i=logPBoundCount-1; i>0; i--) {
-			lastBound = logPBounds[i] = binarySearch.getInsertPosition(logPArray, lastBound, (byte) --logP);
+			// here we want the precise insert position because logPArray contains many elements many times
+			lastBound = logPBounds[i] = binarySearch.getPreciseInsertPosition(logPArray, lastBound, (byte) --logP);
 			if (DEBUG) LOG.debug("logPBound[" + i + "] = " + logPBounds[i] + ", logP[" + logPBounds[i] + "] = " + logPArray[logPBounds[i]] + ", logP[" + (logPBounds[i]-1) + "] = " + logPArray[logPBounds[i]-1]);
 		}
 		logPBounds[0] = p1Index;
@@ -247,6 +249,7 @@ public SieveResult sieve() {
 		for (int lpbc=logPBoundCount-1; lpbc>=0; lpbc--, bigLogP--) {
 			int logPBound = logPBounds[lpbc];
 			for (; i>=logPBound; i--) {
+				if (DEBUG) Ensure.ensureEquals(logPArray[i], bigLogP);
 				// x1 == x2 happens only if p divides k -> for large primes p > k there are always 2 distinct solutions.
 				// x1, x2 may exceed sieveArraySize, but we allocated the arrays somewhat bigger to save the size checks.
 				x1Addr = sieveArrayAddress + x1Array[i];
@@ -365,6 +368,7 @@ public SieveResult sieve() {
 		for (int lpbc=logPBoundCount-1; lpbc>=0; lpbc--, bigLogP--) {
 			int logPBound = logPBounds[lpbc];
 			for (; i>=logPBound; i--) {
+				if (DEBUG) Ensure.ensureEquals(logPArray[i], bigLogP);
 				final int p = pArray[i];
 				x1Addr = sieveArrayAddress + p - x1Array[i];
 				UNSAFE.putByte(x1Addr, (byte) (UNSAFE.getByte(x1Addr) + bigLogP));

src/test/java/de/tilman_neumann/jml/BinarySearchTest.java

@@ -1,6 +1,6 @@
 /*
  * java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
- * Copyright (C) 2018-2024 Tilman Neumann - [email protected]
+ * Copyright (C) 2018-2025 Tilman Neumann - [email protected]
  *
  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
@@ -14,6 +14,7 @@
 package de.tilman_neumann.jml;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 
 import java.util.Arrays;
 
@@ -38,6 +39,27 @@ public void setup() {
 		ConfigUtil.initProject();
 	}
 
+	@Test
+	public void testGetPreciseInsertPosition() {
+		int[] array = new int[] {1, 2, 3, 7, 10, 10, 11};
+		assertCorrectPreciseInsertPosition(array, 4, 3, 3);
+		assertCorrectPreciseInsertPosition(array, 4, 20, 4); // insert index can not exceed maxIndex
+		assertCorrectPreciseInsertPosition(array, 7, 10, 6);
+		assertCorrectPreciseInsertPosition(array, 7, 11, 7);
+		assertCorrectPreciseInsertPosition(array, 7, 20, 7);
+	}
+	
+	@Test
+	public void testGetPreciseInsertPositionWithMultipleEntries() {
+		// each entry occurs 10 times
+		int[] array = new int[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
+		assertCorrectPreciseInsertPosition(array, 70, 5, 50);
+		assertCorrectPreciseInsertPosition(array, 59, 4, 40);
+		assertCorrectPreciseInsertPosition(array, 55, 3, 30);
+		assertCorrectPreciseInsertPosition(array, 42, 2, 20);
+		assertCorrectPreciseInsertPosition(array, 15, 1, 10);
+	}
+
 	@Test
 	public void testGetInsertPosition() {
 		int[] array = new int[] {1, 2, 3, 7, 10, 10, 11};
@@ -48,9 +70,32 @@ public void testGetInsertPosition() {
 		assertCorrectInsertPosition(array, 7, 20, 7);
 	}
 
+	@Test
+	public void testGetAmbigousInsertPositionWithMultipleEntries() {
+		// each entry occurs 10 times
+		int[] array = new int[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
+		assertWrongInsertPosition(array, 70, 5, 50);
+		assertWrongInsertPosition(array, 59, 4, 40);
+		assertWrongInsertPosition(array, 55, 3, 30);
+		assertWrongInsertPosition(array, 42, 2, 20);
+		assertWrongInsertPosition(array, 15, 1, 10);
+	}
+
+	private static void assertCorrectPreciseInsertPosition(int[] array, int maxIndex, int x, int expectedInsertIndex) {
+		int index = bs.getPreciseInsertPosition(array, maxIndex, x);
+		LOG.info("precise insert index of '" + x + "' in " + Arrays.toString(array) + " (restricted to maxIndex=" + maxIndex + ") = " + index);
+		assertEquals(expectedInsertIndex, index);
+	}
+
 	private static void assertCorrectInsertPosition(int[] array, int maxIndex, int x, int expectedInsertIndex) {
 		int index = bs.getInsertPosition(array, maxIndex, x);
 		LOG.info("insert index of '" + x + "' in " + Arrays.toString(array) + " (restricted to maxIndex=" + maxIndex + ") = " + index);
 		assertEquals(expectedInsertIndex, index);
 	}
+
+	private static void assertWrongInsertPosition(int[] array, int maxIndex, int x, int expectedInsertIndex) {
+		int index = bs.getInsertPosition(array, maxIndex, x);
+		LOG.info("insert index of '" + x + "' in " + Arrays.toString(array) + " (restricted to maxIndex=" + maxIndex + ") = " + index);
+		assertNotEquals(expectedInsertIndex, index);
+	}
 }