Release calc version 2.12.6.2

CHANGES

@@ -6,6 +6,9 @@ The following are the changes from calc version 2.12.6.1 to date:
     integers >= 1.  In the case of both rodseth_xhn(x, h, n) and gen_v1(h, n)
     h must be odd.
 
+    Fixed an C code intending issue that was reported by Thomas Walter
+    <th dot walter42 at gmx dot de> in zfunc.c.
+
 
 The following are the changes from calc version 2.12.6.0 to 2.12.6.0:
 

Makefile.ship

@@ -990,7 +990,7 @@ EXT=
 
 # The default calc versions
 #
-VERSION= 2.12.6.1
+VERSION= 2.12.6.2
 
 # Names of shared libraries with versions
 #

cal/lucas.cal

@@ -739,7 +739,7 @@ rodseth_xhn(x, h, n)
  * We can show that X > 2.  See the comments in the rodseth_xhn(x,h,n) above.
  *
  * Some values of X satisfy more often than others. For example a large sample
- * of odd h, h odd multiple of 3 and large n (some around 1e4, some near 1e6,
+ * of h*2^n-1, h odd multiple of 3, and large n (some around 1e4, some near 1e6,
  * others near 3e7) where the sample size was 66 973 365, here is the count of
  * the smallest value of X that satisfies conditions in Ref4, condition 1:
  *
@@ -805,82 +805,84 @@ rodseth_xhn(x, h, n)
  *
  * The above distribution was found to hold fairly well over many values of
  * odd h that are also a multiple of 3 and for many values of n where h < 2^n.
- * For example for in a sample size of 835823 numbers of the form h*2^n-1
- * where odd h >= 12996351 is a multiple of 3, n >= 12996351, these are the
- * smallest v(1) values that were found:
+ * For example for in a sample size of 1000000 numbers of the form h*2^n-1
+ * where h is an odd multiple of 3, 12996351 <= h <= 13002351,
+ * 4331116 <= n <= 4332116, these are the smallest v(1) values that were found:
  *
  *  smallest percentage
  *	v(1) used
  *  -------------------
- *	   3 40.000%
- *	   5 25.683%
- *	   9 11.693%
- *	  11 10.452%
- *	  15 4.806%
- *	  17 2.348%
- *	  21 1.656%
- *	  29 1.281%
- *	  27 0.6881%
- *	  35 0.4536%
- *	  39 0.3121%
- *	  41 0.1760%
- *	  31 0.1414%
- *	  45 0.1173%
- *	  51 0.05576%
- *	  55 0.03300%
- *	  49 0.03185%
- *	  59 0.02090%
- *	  69 0.00980%
- *	  65 0.009367%
- *	  71 0.007205%
- *	  57 0.006341%
- *	  85 0.004611%
- *	  81 0.004179%
- *	  95 0.002882%
- *	  99 0.001873%
- *	  77 0.001153%
- *	  53 0.0007205%
- *	  67 0.0005764%
- *	 125 0.0005764%
- *	 105 0.0005764%
- *	  87 0.0004323%
- *	 111 0.0004323%
- *	 101 0.0002882%
- *	  83 0.0001441%
- *	 127 0.0001196%
+ *         3 40.0000%
+ *         5 25.6833%
+ *         9 11.6924%
+ *        11 10.4528%
+ *        15 4.8048%
+ *        17 2.3458%
+ *        21 1.6568%
+ *        29 1.2814%
+ *        27 0.6906%
+ *        35 0.4529%
+ *        39 0.3140%
+ *        41 0.1737%
+ *        31 0.1413%
+ *        45 0.1173%
+ *        51 0.0526%
+ *        55 0.0350%
+ *        49 0.0332%
+ *        59 0.0218%
+ *        69 0.0099%
+ *        65 0.0085%
+ *        71 0.0073%
+ *        57 0.0062%
+ *        85 0.0048%
+ *        81 0.0044%
+ *        95 0.0028%
+ *        99 0.0017%
+ *        77 0.0009%
+ *        53 0.0008%
+ *        67 0.0004%
+ *       105 0.0004%
+ *       111 0.0004%
+ *       125 0.0004%
+ *        87 0.0003%
+ *       101 0.0002%
+ *        83 0.0001%
+ *       109 0.0001%
+ *       121 0.0001%
+ *       129 0.0001%
  *
  * When h * 2^n-1 is prime and h is an odd multiple of 3, a smallest v(1) that
  * is even is extremely rate.  Of the list of 127287 known primes of the form
  * h*2^n-1 when h was a multiple of 3, none has an smallest v(1) that was even.
  *
- * About 1 out of 835000 cases when h is a multiple of 3 use v(1) > 127 as the
+ * About 1 out of 1000000 cases when h is a multiple of 3 use v(1) > 127 as the
  * smallest value of v(1).
  *
  * Given this information, when odd h is a multiple of 3 we try, in order,
  * these sorted values of X:
  *
- *      3, 5, 9, 11, 15, 17, 21, 27, 29, 31, 35, 39, 41, 45, 49, 51, 53, 55,
- *	57, 59, 65, 67, 69, 71, 77, 81, 83, 85, 87, 95, 99, 101, 105, 111, 125
+ *  3, 5, 9, 11, 15, 17, 21, 27, 29, 31, 35, 39, 41, 45, 49, 51, 53, 55, 57, 59,
+ *  65, 67, 69, 71, 77, 81, 83, 85, 87, 95, 99, 101, 105, 109, 111, 121, 125
  *
  * And stop on the first value of X where:
  *
  *      jacobi(X-2, h*2^n-1) == 1
  *      jacobi(X+2, h*2^n-1) == -1
  *
- * If no value in that list works, we start simple search starting with X = 12/
+ * If no value in that list works, we start simple search starting with X = 129
  * and incrementing by 2 until a value of X is found.
  *
  * The x_tbl[] matrix contains those common values of X to try in order.
  * If all x_tbl_len fail to satisfy Ref4 condition 1, then we begin a
  * linear search at next_x until we find a proper X value.
  */
-x_tbl_len = 35;
+x_tbl_len = 38;
 mat x_tbl[x_tbl_len];
 x_tbl = {
-    3, 5, 9, 11, 15, 17, 21, 27, 29, 31, 35, 39, 41, 45, 49, 51, 53, 55,
-    57, 59, 65, 67, 69, 71, 77, 81, 83, 85, 87, 95, 99, 101, 105, 111, 125
+    3, 5, 9, 11, 15, 17, 21, 27, 29, 31, 35, 39, 41, 45, 49, 51, 53, 55, 57, 59,
+    65, 67, 69, 71, 77, 81, 83, 85, 87, 95, 99, 101, 105, 109, 111, 121, 125
 };
-next_x = 127;
+next_x = 129;
 
 /*
  * gen_v1 - compute the v(1) for a given h*2^n-1 if we can
@@ -1039,7 +1041,8 @@ next_x = 127;
  *	n	n as in h*2^n-1	(must be >= 1)
  *
  * output:
- *	returns v(1), or -1 is there is no quick way
+ *	returns v(1), or
+ *		-1 when h*2^n-1 is a multiple of 3
  */
 define
 gen_v1(h, n)
@@ -1066,6 +1069,14 @@ gen_v1(h, n)
 		quit "bad args: n must be an integer >= 1";
 	}
 
+	/*
+	 * pretest: Verify that h*2^n-1 is not a multiple of 3
+	 */
+	if (((h % 3 == 1) && (n % 2 == 0)) || ((h % 3 == 2) && (n % 2 == 1))) {
+		/* no need to test h*2^n-1, it is not prime */
+		return -1;
+	}
+
 	/*
 	 * check for Case 1:      (h mod 3 != 0)
 	 */

custom/Makefile

@@ -348,7 +348,7 @@ EXT=
 
 # The default calc versions
 #
-VERSION= 2.12.6.1
+VERSION= 2.12.6.2
 
 # Names of shared libraries with versions
 #

custom/Makefile.head

@@ -348,7 +348,7 @@ EXT=
 
 # The default calc versions
 #
-VERSION= 2.12.6.1
+VERSION= 2.12.6.2
 
 # Names of shared libraries with versions
 #

version.c

@@ -45,7 +45,7 @@ static char *program;
 #define MAJOR_VER	2	/* major library version */
 #define MINOR_VER	12	/* minor library version */
 #define MAJOR_PATCH	6	/* major software level under library version */
-#define MINOR_PATCH	1	/* minor software level or 0 if not patched */
+#define MINOR_PATCH	2	/* minor software level or 0 if not patched */
 
 
 /*

zfunc.c

@@ -1029,93 +1029,98 @@ zgcd(ZVALUE z1, ZVALUE z2, ZVALUE *res)
 				needw = FALSE;
 			}
 			g = *a0 * w;
-			if (h < BASEB) g &= (1 << h) - 1;
-			else g &= BASE1;
+			if (h < BASEB) {
+			    g &= (1 << h) - 1;
+			} else {
+			    g &= BASE1;
+			}
+		} else {
+			g = 1;
 		}
-		else g = 1;
-	   } else
+	    } else {
 		g = (HALF) *a0 * w;
-		a = a0;
-		b = b0;
-		i = n;
-		if (g > 1) {			/* a - g * b case */
-			f = 0;
-			while (i--) {
-				f = (FULL) *a - g * *b++ - f;
-				*a++ = (HALF) f;
-				f >>= BASEB;
-				f = -f & BASE1;
-			}
-			if (f) {
-				i = m - n;
-				while (i-- && f) {
-					f = *a - f;
-					*a++ = (HALF) f;
-					f >>= BASEB;
-					f = -f & BASE1;
-				}
-			}
-			while (m && !*a0) { /* Removing trailing zeros */
-				m--;
-				a0++;
-			}
-			if (f) {		/* a - g * b < 0 */
-				while (m > 1 && a0[m-1] == BASE1) m--;
-				*a0 = - *a0;
-				a = a0;
-				i = m;
-				while (--i) {
-					a++;
-					*a = ~*a;
-				}
-			}
-		} else {				/* abs(a - b) case */
-			while (i && *a++ == *b++) i--;
-			q = n - i;
-			if (m == n) {		/* a and b same length */
-				if (i) {	 /* a not equal to b */
-					while (m && a0[m-1] == b0[m-1]) m--;
-					if (a0[m-1] < b0[m-1]) {
-						/* Swapping since a < b */
-						a = a0;
-						a0 = b0;
-						b0 = a;
-						k = j;
-					}
-					a = a0 + q;
-					b = b0 + q;
-					i = m - q;
-					f = 0;
-					while (i--) {
-						f = (FULL) *a - *b++ - f;
-						*a++ = (HALF) f;
-						f >>= BASEB;
-						f = -f & BASE1;
-					}
-				}
-			} else {		/* a has more digits than b */
-				a = a0 + q;
-				b = b0 + q;
-				i = n - q;
-				f = 0;
-				while (i--) {
-					f = (FULL) *a - *b++ - f;
-					*a++ = (HALF) f;
-					f >>= BASEB;
-					f = -f & BASE1;
-				}
-				if (f) { while (!*a) *a++ = BASE1;
-					(*a)--;
-				}
-			}
-			a0 += q;
-			m -= q;
-			while (m && !*a0) { /* Removing trailing zeros */
-				m--;
-				a0++;
-			}
-		}
-		while (m && !a0[m-1]) m--;	/* Removing leading zeros */
+	    }
+	    a = a0;
+	    b = b0;
+	    i = n;
+	    if (g > 1) {			/* a - g * b case */
+		    f = 0;
+		    while (i--) {
+			    f = (FULL) *a - g * *b++ - f;
+			    *a++ = (HALF) f;
+			    f >>= BASEB;
+			    f = -f & BASE1;
+		    }
+		    if (f) {
+			    i = m - n;
+			    while (i-- && f) {
+				    f = *a - f;
+				    *a++ = (HALF) f;
+				    f >>= BASEB;
+				    f = -f & BASE1;
+			    }
+		    }
+		    while (m && !*a0) { /* Removing trailing zeros */
+			    m--;
+			    a0++;
+		    }
+		    if (f) {		/* a - g * b < 0 */
+			    while (m > 1 && a0[m-1] == BASE1) m--;
+			    *a0 = - *a0;
+			    a = a0;
+			    i = m;
+			    while (--i) {
+				    a++;
+				    *a = ~*a;
+			    }
+		    }
+	    } else {				/* abs(a - b) case */
+		    while (i && *a++ == *b++) i--;
+		    q = n - i;
+		    if (m == n) {		/* a and b same length */
+			    if (i) {	 /* a not equal to b */
+				    while (m && a0[m-1] == b0[m-1]) m--;
+				    if (a0[m-1] < b0[m-1]) {
+					    /* Swapping since a < b */
+					    a = a0;
+					    a0 = b0;
+					    b0 = a;
+					    k = j;
+				    }
+				    a = a0 + q;
+				    b = b0 + q;
+				    i = m - q;
+				    f = 0;
+				    while (i--) {
+					    f = (FULL) *a - *b++ - f;
+					    *a++ = (HALF) f;
+					    f >>= BASEB;
+					    f = -f & BASE1;
+				    }
+			    }
+		    } else {		/* a has more digits than b */
+			    a = a0 + q;
+			    b = b0 + q;
+			    i = n - q;
+			    f = 0;
+			    while (i--) {
+				    f = (FULL) *a - *b++ - f;
+				    *a++ = (HALF) f;
+				    f >>= BASEB;
+				    f = -f & BASE1;
+			    }
+			    if (f) { while (!*a) *a++ = BASE1;
+				    (*a)--;
+			    }
+		    }
+		    a0 += q;
+		    m -= q;
+		    while (m && !*a0) { /* Removing trailing zeros */
+			    m--;
+			    a0++;
+		    }
+	    }
+	    while (m && !a0[m-1]) m--;	/* Removing leading zeros */
 	}
 	if (m == 1) {				/* a has one digit */
 		v = *a0;