math.big: restore gdc_euclid, use it for smaller numbers, fix bench_euclid.v .

Author: spytheman

vlib/math/big/big_test.v

@@ -655,11 +655,14 @@ fn test_big_mod_pow() {
 	}
 }
 
-fn test_gcd() {
+fn test_gcd_vs_gcd_binary_vs_gcd_euclid() {
 	for t in gcd_test_data {
 		a := t.a.parse()
 		b := t.b.parse()
-		assert a.gcd(b) == t.expected.parse()
+		expected := t.expected.parse()
+		assert a.gcd(b) == expected
+		assert a.gcd_binary(b) == expected
+		assert a.gcd_euclid(b) == expected
 	}
 }
 

vlib/math/big/integer.v

@@ -1021,6 +1021,19 @@ fn bi_max(a Integer, b Integer) Integer {
 
 // gcd returns the greatest common divisor of the two integers `a` and `b`.
 pub fn (a Integer) gcd(b Integer) Integer {
+	// The cutoff is determined empirically, using vlib/v/tests/bench/math_big_gcd/bench_euclid.v .
+	if b.digits.len < 8 {
+		return a.gcd_euclid(b)
+	}
+	return a.gcd_binary(b)
+}
+
+// gcd_binary returns the greatest common divisor of the two integers `a` and `b`.
+// Note that gcd_binary is faster than gcd_euclid, for large integers (over 8 bytes long).
+// Inspired by the 2013-christmas-special by D. Lemire & R. Corderoy https://en.algorithmica.org/hpc/analyzing-performance/gcd/
+// For more information, refer to the Wikipedia article: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
+// Discussion and further information: https://lemire.me/blog/2013/12/26/fastest-way-to-compute-the-greatest-common-divisor/
+pub fn (a Integer) gcd_binary(b Integer) Integer {
 	if a.signum == 0 {
 		return b.abs()
 	}
@@ -1031,24 +1044,42 @@ pub fn (a Integer) gcd(b Integer) Integer {
 		return one_int
 	}
 
-	return gcd_binary(a.abs(), b.abs())
-}
-
-// Inspired by the 2013-christmas-special by D. Lemire & R. Corderoy https://en.algorithmica.org/hpc/analyzing-performance/gcd/
-// For more information, refer to the Wikipedia article: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
-// Discussion and further information: https://lemire.me/blog/2013/12/26/fastest-way-to-compute-the-greatest-common-divisor/
-fn gcd_binary(x Integer, y Integer) Integer {
-	mut a, az := x.rsh_to_set_bit()
-	mut b, bz := y.rsh_to_set_bit()
+	mut aa, az := a.abs().rsh_to_set_bit()
+	mut bb, bz := b.abs().rsh_to_set_bit()
 	shift := umin(az, bz)
 
-	for a.signum != 0 {
-		diff := b - a
-		b = bi_min(a, b)
-		a, _ = diff.abs().rsh_to_set_bit()
+	for aa.signum != 0 {
+		diff := bb - aa
+		bb = bi_min(aa, bb)
+		aa, _ = diff.abs().rsh_to_set_bit()
 	}
+	return bb.left_shift(shift)
+}
 
-	return b.left_shift(shift)
+// gcd_euclid returns the greatest common divisor of the two integers `a` and `b`.
+// Note that gcd_euclid is faster than gcd_binary, for very-small-integers up to 8-byte/u64.
+pub fn (a Integer) gcd_euclid(b Integer) Integer {
+	if a.signum == 0 {
+		return b.abs()
+	}
+	if b.signum == 0 {
+		return a.abs()
+	}
+	if a.signum < 0 {
+		return a.neg().gcd_euclid(b)
+	}
+	if b.signum < 0 {
+		return a.gcd_euclid(b.neg())
+	}
+	mut x := a
+	mut y := b
+	mut r := x % y
+	for r.signum != 0 {
+		x = y
+		y = r
+		r = x % y
+	}
+	return y
 }
 
 // mod_inverse calculates the multiplicative inverse of the integer `a` in the ring `ℤ/nℤ`.

vlib/v/tests/bench/math_big_gcd/bench_euclid.v

@@ -33,7 +33,8 @@ fn main() {
 	mut clocks := Clocks(map[string]benchmark.Benchmark{})
 
 	for algo in [
-		'euclid',
+		'gcd',
+		'gcd_euclid',
 		'gcd_binary',
 		//'u32binary',
 		//'u64binary'
@@ -105,10 +106,10 @@ fn main() {
 	println(clocks['euclid'].total_message('both algorithms '))
 
 	msg := [
-		'Seems to me as if euclid in big.Integer.gcd() performs better on ',
+		'Seems to me, that big.Integer.gcd_euclid in big.Integer.gcd() performs better on ',
 		'very-small-integers up to 8-byte/u64. The tests #-1..5 show this.',
-		'The gcd_binary-algo seems to be perform better, the larger the numbers/buffers get.',
-		'On my machine, i see consistent gains between ~10-30-percent with :',
+		'The big.Integer.gcd_binary algo seems to be perform better, the larger the numbers/buffers get.',
+		'On my machine, I see consistent gains between ~10-30-percent with :',
 		'\n',
 		'v -prod -cg -gc boehm bench_euclid.v',
 		'\n',
@@ -177,13 +178,20 @@ fn run_benchmark(data []DataI, heap bool, mut clocks Clocks) bool {
 		for cycles < rounds {
 			for set in testdata {
 				match algo {
-					'euclid' {
+					'gcd' {
 						if set.r != set.aa.gcd(set.bb) {
 							eprintln('${algo} failed ?')
 							clock.fail()
 							break
 						}
 					}
+					'gcd_euclid' {
+						if set.r != set.aa.gcd_euclid(set.bb) {
+							eprintln('${algo} failed ?')
+							clock.fail()
+							break
+						}
+					}
 					'gcd_binary' {
 						if set.r != set.aa.gcd_binary(set.bb) {
 							eprintln('${algo} failed ?')

vlib/v/tests/bench/math_big_gcd/prime/maker.v

@@ -120,7 +120,7 @@ pub fn random_list(cfg []string) []string {
 			}
 			mut num := ''
 			for prime_count != 0 {
-				num = primes[prime_size][rand.int_in_range(0, primes[prime_size].len - 1)]
+				num = primes[prime_size][rand.int_in_range(0, primes[prime_size].len - 1) or { 0 }]
 				if num in p_list {
 					continue
 				}
@@ -140,7 +140,7 @@ pub fn random_list(cfg []string) []string {
 	return p_list
 }
 
-pub fn random_set(cfg PrimeCfg) ?[]PrimeSet {
+pub fn random_set(cfg PrimeCfg) ![]PrimeSet {
 	p_lists := [
 		cfg.r.split('.'),
 		cfg.a.split('.'),