create fast path

Author: SakiTakamachi

ext/bcmath/libbcmath/src/private.h

@@ -75,8 +75,8 @@
  */
 #define BC_VECTOR_NO_OVERFLOW_ADD_COUNT (~((BC_VECTOR) 0) / (BC_VECTOR_BOUNDARY_NUM * BC_VECTOR_BOUNDARY_NUM))
 
-static const BC_VECTOR BC_POW_10_LUT[9] = {
-	1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000
+static const BC_VECTOR BC_POW_10_LUT[11] = {
+	1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000
 };
 
 

ext/bcmath/libbcmath/src/sqrt.c

@@ -32,10 +32,22 @@
 #include "bcmath.h"
 #include <stdbool.h>
 #include <stddef.h>
+#include "private.h"
 
 /* Take the square root NUM and return it in NUM with SCALE digits
    after the decimal place. */
 
+static inline BC_VECTOR bc_sqrt_get_pow_10(size_t exponent)
+{
+	BC_VECTOR value = 1;
+	while (exponent >= 10) {
+		value *= BC_POW_10_LUT[10];
+		exponent -= 10;
+	}
+	value *= BC_POW_10_LUT[exponent];
+	return value;
+}
+
 bool bc_sqrt(bc_num *num, size_t scale)
 {
 	/* Initial checks. */
@@ -59,55 +71,108 @@ bool bc_sqrt(bc_num *num, size_t scale)
 	}
 
 	/* Initialize the variables. */
-	size_t cscale;
-	bc_num guess;
 	size_t rscale = MAX(scale, (*num)->n_scale);
 
-	/* Calculate the initial guess. */
-	if (num_cmp_one == BCMATH_RIGHT_GREATER) {
-		/* The number is between 0 and 1.  Guess should start at 1. */
-		guess = bc_copy_num(BCG(_one_));
-		cscale = (*num)->n_scale;
-	} else {
-		/* The number is greater than 1.  Guess should start at 10^(exp/2). */
-		/* If just divide size_t by 2 it will not overflow. */
-		size_t exponent_for_initial_guess = (size_t) (*num)->n_len >> 1;
-
-		/* 10^n is a 1 followed by n zeros. */
-		guess = bc_new_num(exponent_for_initial_guess + 1, 0);
-		guess->n_value[0] = 1;
-		cscale = 3;
-	}
+	/* Find the square root using Newton's algorithm. */
+	if ((*num)->n_len + (rscale + 1) * 2 < sizeof(LONG_MIN_DIGITS) - 1) {
+		/* fast path */
 
-	bc_num guess1 = NULL;
-	bc_num point5 = bc_new_num (1, 1);
-	point5->n_value[1] = 5;
-	bc_num diff = NULL;
+		/* Calculate the initial guess. */
+		BC_VECTOR guess_vector = 1;
+		if (num_cmp_one != BCMATH_RIGHT_GREATER) {
+			guess_vector *= bc_sqrt_get_pow_10(((*num)->n_len + rscale + 1) >> 1);
+		}
 
-	/* Find the square root using Newton's algorithm. */
-	bool done = false;
-	while (!done) {
-		bc_free_num (&guess1);
-		guess1 = bc_copy_num(guess);
-		bc_divide(*num, guess, &guess, cscale);
-		bc_add_ex(guess, guess1, &guess, 0);
-		bc_multiply_ex(guess, point5, &guess, cscale);
-		bc_sub_ex(guess, guess1, &diff, cscale + 1);
-		if (bc_is_near_zero(diff, cscale)) {
-			if (cscale < rscale + 1) {
-				cscale = MIN (cscale * 3, rscale + 1);
-			} else {
+		BC_VECTOR n_vector = 0;
+		size_t i = 0;
+		for (; i < (*num)->n_len + (*num)->n_scale; i++) {
+			n_vector = n_vector * BASE + (*num)->n_value[i];
+		}
+		n_vector *= bc_sqrt_get_pow_10((rscale + 1) * 2 - (*num)->n_scale);
+
+		BC_VECTOR guess1_vector;
+		bool done = false;
+		while (!done) {
+			guess1_vector = guess_vector;
+			guess_vector = n_vector / guess_vector;
+			guess_vector += guess1_vector;
+			guess_vector /= 2;
+			size_t diff = guess1_vector > guess_vector ? guess1_vector - guess_vector : guess_vector - guess1_vector;
+			if (diff <= 1) {
 				done = true;
 			}
 		}
+
+		size_t full_len = 0;
+		BC_VECTOR tmp_guess_vector = guess_vector;
+		do {
+			tmp_guess_vector /= BASE;
+			full_len++;
+		} while (tmp_guess_vector > 0);
+
+		size_t ret_ren = full_len > rscale + 1 ? full_len - (rscale + 1) : 1; /* for int zero */
+		bc_num ret = bc_new_num_nonzeroed(ret_ren, rscale);
+		char *rptr = ret->n_value;
+		char *rend = rptr + ret_ren + rscale - 1;
+
+		guess_vector /= BASE;
+		while (rend >= rptr) {
+			*rend-- = guess_vector % BASE;
+			guess_vector /= BASE;
+		}
+		bc_free_num(num);
+		*num = ret;
+	} else {
+		/* standard path */
+
+		bc_num guess;
+		size_t cscale;
+		/* Calculate the initial guess. */
+		if (num_cmp_one == BCMATH_RIGHT_GREATER) {
+			/* The number is between 0 and 1.  Guess should start at 1. */
+			guess = bc_copy_num(BCG(_one_));
+			cscale = (*num)->n_scale;
+		} else {
+			/* The number is greater than 1.  Guess should start at 10^(exp/2). */
+			/* If just divide size_t by 2 it will not overflow. */
+			size_t exponent_for_initial_guess = (size_t) (*num)->n_len >> 1;
+
+			/* 10^n is a 1 followed by n zeros. */
+			guess = bc_new_num(exponent_for_initial_guess + 1, 0);
+			guess->n_value[0] = 1;
+			cscale = 3;
+		}
+
+		bc_num guess1 = NULL;
+		bc_num point5 = bc_new_num (1, 1);
+		point5->n_value[1] = 5;
+		bc_num diff = NULL;
+
+		bool done = false;
+		while (!done) {
+			bc_free_num (&guess1);
+			guess1 = bc_copy_num(guess);
+			bc_divide(*num, guess, &guess, cscale);
+			bc_add_ex(guess, guess1, &guess, 0);
+			bc_multiply_ex(guess, point5, &guess, cscale);
+			bc_sub_ex(guess, guess1, &diff, cscale + 1);
+			if (bc_is_near_zero(diff, cscale)) {
+				if (cscale < rscale + 1) {
+					cscale = MIN (cscale * 3, rscale + 1);
+				} else {
+					done = true;
+				}
+			}
+		}
+
+		/* Assign the number and clean up. */
+		bc_free_num (num);
+		bc_divide(guess, BCG(_one_), num, rscale);
+		bc_free_num (&guess);
+		bc_free_num (&guess1);
+		bc_free_num (&point5);
+		bc_free_num (&diff);
 	}
 
-	/* Assign the number and clean up. */
-	bc_free_num (num);
-	bc_divide(guess, BCG(_one_), num, rscale);
-	bc_free_num (&guess);
-	bc_free_num (&guess1);
-	bc_free_num (&point5);
-	bc_free_num (&diff);
 	return true;
 }