mirror of
https://github.com/php/php-src.git
synced 2025-08-15 21:48:51 +02:00
BCmath extension code reformatting (#11896)
Re-formats the BCmath extension to have consistent formatting. Mostly, it adds the spaces in calculations to have them more readable. Also: - removes unused headers - removes few variables which are used only once in the code Co-authored-by: George Peter Banyard <girgias@php.net>
This commit is contained in:
Jorg Adam Sowa
GitHub
parent
bb092ab4c6
commit
e56ed6e1ab
21 changed files with 265 additions and 286 deletions
|
|
@ -39,34 +39,30 @@
|
|||
N1 is added to N2 and the result placed into RESULT. SCALE_MIN
|
||||
is the minimum scale for the result. */
|
||||
|
||||
void bc_add (bc_num n1, bc_num n2, bc_num *result, size_t scale_min)
|
||||
void bc_add(bc_num n1, bc_num n2, bc_num *result, size_t scale_min)
|
||||
{
|
||||
bc_num sum = NULL;
|
||||
int cmp_res;
|
||||
size_t res_scale;
|
||||
|
||||
if (n1->n_sign == n2->n_sign) {
|
||||
sum = _bc_do_add (n1, n2, scale_min);
|
||||
sum = _bc_do_add(n1, n2, scale_min);
|
||||
sum->n_sign = n1->n_sign;
|
||||
} else {
|
||||
/* subtraction must be done. */
|
||||
/* Compare magnitudes. */
|
||||
cmp_res = _bc_do_compare(n1, n2, false, false);
|
||||
switch (cmp_res) {
|
||||
switch (_bc_do_compare(n1, n2, false, false)) {
|
||||
case -1:
|
||||
/* n1 is less than n2, subtract n1 from n2. */
|
||||
sum = _bc_do_sub (n2, n1, scale_min);
|
||||
sum = _bc_do_sub(n2, n1, scale_min);
|
||||
sum->n_sign = n2->n_sign;
|
||||
break;
|
||||
case 0:
|
||||
/* They are equal! return zero with the correct scale! */
|
||||
res_scale = MAX (scale_min, MAX(n1->n_scale, n2->n_scale));
|
||||
sum = bc_new_num (1, res_scale);
|
||||
memset (sum->n_value, 0, res_scale+1);
|
||||
sum = bc_new_num (1, MAX(scale_min, MAX(n1->n_scale, n2->n_scale)));
|
||||
memset(sum->n_value, 0, sum->n_scale + 1);
|
||||
break;
|
||||
case 1:
|
||||
/* n2 is less than n1, subtract n2 from n1. */
|
||||
sum = _bc_do_sub (n1, n2, scale_min);
|
||||
sum = _bc_do_sub(n1, n2, scale_min);
|
||||
sum->n_sign = n1->n_sign;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ typedef struct bc_struct {
|
|||
#include "../../php_bcmath.h" /* Needed for BCG() macro */
|
||||
|
||||
/* The base used in storing the numbers in n_value above.
|
||||
Currently this MUST be 10. */
|
||||
Currently, this MUST be 10. */
|
||||
|
||||
#define BASE 10
|
||||
|
||||
|
|
|
|||
|
|
@ -30,9 +30,9 @@
|
|||
*************************************************************************/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include "bcmath.h"
|
||||
#include "private.h"
|
||||
#include <stddef.h>
|
||||
|
||||
|
||||
/* Compare two bc numbers. Return value is 0 if equal, -1 if N1 is less
|
||||
|
|
@ -46,9 +46,11 @@ int _bc_do_compare(bc_num n1, bc_num n2, bool use_sign, bool ignore_last)
|
|||
/* First, compare signs. */
|
||||
if (use_sign && n1->n_sign != n2->n_sign) {
|
||||
if (n1->n_sign == PLUS) {
|
||||
return (1); /* Positive N1 > Negative N2 */
|
||||
/* Positive N1 > Negative N2 */
|
||||
return (1);
|
||||
} else {
|
||||
return (-1); /* Negative N1 < Positive N1 */
|
||||
/* Negative N1 < Positive N1 */
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -107,7 +109,7 @@ int _bc_do_compare(bc_num n1, bc_num n2, bool use_sign, bool ignore_last)
|
|||
/* They are equal up to the last part of the equal part of the fraction. */
|
||||
if (n1->n_scale != n2->n_scale) {
|
||||
if (n1->n_scale > n2->n_scale) {
|
||||
for (count = n1->n_scale-n2->n_scale; count>0; count--) {
|
||||
for (count = n1->n_scale - n2->n_scale; count > 0; count--) {
|
||||
if (*n1ptr++ != 0) {
|
||||
/* Magnitude of n1 > n2. */
|
||||
if (!use_sign || n1->n_sign == PLUS) {
|
||||
|
|
@ -118,7 +120,7 @@ int _bc_do_compare(bc_num n1, bc_num n2, bool use_sign, bool ignore_last)
|
|||
}
|
||||
}
|
||||
} else {
|
||||
for (count = n2->n_scale-n1->n_scale; count>0; count--) {
|
||||
for (count = n2->n_scale - n1->n_scale; count > 0; count--) {
|
||||
if (*n2ptr++ != 0) {
|
||||
/* Magnitude of n1 < n2. */
|
||||
if (!use_sign || n1->n_sign == PLUS) {
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@
|
|||
|
||||
/* pn prints the number NUM in base 10. */
|
||||
|
||||
static void out_char (char c)
|
||||
static void out_char(char c)
|
||||
{
|
||||
putchar(c);
|
||||
}
|
||||
|
|
@ -45,16 +45,16 @@ static void out_char (char c)
|
|||
void pn(bc_num num)
|
||||
{
|
||||
bc_out_num(num, 10, out_char, 0);
|
||||
out_char ('\n');
|
||||
out_char('\n');
|
||||
}
|
||||
|
||||
|
||||
/* pv prints a character array as if it was a string of bcd digits. */
|
||||
void pv (char *name, unsigned char *num, size_t len)
|
||||
void pv(char *name, unsigned char *num, size_t len)
|
||||
{
|
||||
printf("%s=", name);
|
||||
for (size_t i = 0; i < len; i++){
|
||||
printf ("%c",BCD_CHAR(num[i]));
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
printf("%c", BCD_CHAR(num[i]));
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@
|
|||
#include "private.h"
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
#include "zend_alloc.h"
|
||||
|
||||
|
||||
|
|
@ -43,7 +44,7 @@
|
|||
|
||||
static void _one_mult(unsigned char *num, size_t size, int digit, unsigned char *result)
|
||||
{
|
||||
int carry, value;
|
||||
size_t carry, value;
|
||||
unsigned char *nptr, *rptr;
|
||||
|
||||
if (digit == 0) {
|
||||
|
|
@ -53,8 +54,8 @@ static void _one_mult(unsigned char *num, size_t size, int digit, unsigned char
|
|||
memcpy(result, num, size);
|
||||
} else {
|
||||
/* Initialize */
|
||||
nptr = (unsigned char *) (num+size-1);
|
||||
rptr = (unsigned char *) (result+size-1);
|
||||
nptr = (unsigned char *) (num + size - 1);
|
||||
rptr = (unsigned char *) (result + size - 1);
|
||||
carry = 0;
|
||||
|
||||
while (size-- > 0) {
|
||||
|
|
@ -84,8 +85,8 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
unsigned int len1, len2, scale2, qdigits, extra, count;
|
||||
unsigned int qdig, qguess, borrow, carry;
|
||||
unsigned char *mval;
|
||||
bool zero;
|
||||
unsigned int norm;
|
||||
bool zero;
|
||||
|
||||
/* Test for divide by zero. */
|
||||
if (bc_is_zero(n2)) {
|
||||
|
|
@ -93,40 +94,36 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
}
|
||||
|
||||
/* Test for divide by 1. If it is we must truncate. */
|
||||
if (n2->n_scale == 0) {
|
||||
if (n2->n_len == 1 && *n2->n_value == 1) {
|
||||
if (n2->n_scale == 0 && n2->n_len == 1 && *n2->n_value == 1) {
|
||||
qval = bc_new_num (n1->n_len, scale);
|
||||
qval->n_sign = (n1->n_sign == n2->n_sign ? PLUS : MINUS);
|
||||
memset (&qval->n_value[n1->n_len],0,scale);
|
||||
memcpy (qval->n_value, n1->n_value, n1->n_len + MIN(n1->n_scale,scale));
|
||||
memset(&qval->n_value[n1->n_len], 0, scale);
|
||||
memcpy(qval->n_value, n1->n_value, n1->n_len + MIN(n1->n_scale, scale));
|
||||
bc_free_num (quot);
|
||||
*quot = qval;
|
||||
}
|
||||
}
|
||||
|
||||
/* Set up the divide. Move the decimal point on n1 by n2's scale.
|
||||
Remember, zeros on the end of num2 are wasted effort for dividing. */
|
||||
scale2 = n2->n_scale;
|
||||
n2ptr = (unsigned char *) n2->n_value+n2->n_len+scale2-1;
|
||||
while ((scale2 > 0) && (*n2ptr-- == 0)) {
|
||||
n2ptr = (unsigned char *) n2->n_value + n2->n_len + scale2 - 1;
|
||||
while ((scale2 > 0) && (*n2ptr == 0)) {
|
||||
scale2--;
|
||||
n2ptr--;
|
||||
}
|
||||
|
||||
len1 = n1->n_len + scale2;
|
||||
scale1 = n1->n_scale - scale2;
|
||||
if (scale1 < scale) {
|
||||
extra = scale - scale1;
|
||||
} else {
|
||||
extra = 0;
|
||||
}
|
||||
num1 = (unsigned char *) safe_emalloc (1, n1->n_len+n1->n_scale, extra+2);
|
||||
memset (num1, 0, n1->n_len+n1->n_scale+extra+2);
|
||||
memcpy (num1+1, n1->n_value, n1->n_len+n1->n_scale);
|
||||
extra = MAX(scale - scale1, 0);
|
||||
|
||||
num1 = (unsigned char *) safe_emalloc(1, n1->n_len + n1->n_scale, extra + 2);
|
||||
memset(num1, 0, n1->n_len + n1->n_scale + extra + 2);
|
||||
memcpy(num1 + 1, n1->n_value, n1->n_len + n1->n_scale);
|
||||
|
||||
len2 = n2->n_len + scale2;
|
||||
num2 = (unsigned char *) safe_emalloc (1, len2, 1);
|
||||
memcpy (num2, n2->n_value, len2);
|
||||
*(num2+len2) = 0;
|
||||
num2 = (unsigned char *) safe_emalloc(1, len2, 1);
|
||||
memcpy(num2, n2->n_value, len2);
|
||||
*(num2 + len2) = 0;
|
||||
n2ptr = num2;
|
||||
while (*n2ptr == 0) {
|
||||
n2ptr++;
|
||||
|
|
@ -134,22 +131,22 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
}
|
||||
|
||||
/* Calculate the number of quotient digits. */
|
||||
if (len2 > len1+scale) {
|
||||
qdigits = scale+1;
|
||||
if (len2 > len1 + scale) {
|
||||
qdigits = scale + 1;
|
||||
zero = true;
|
||||
} else {
|
||||
zero = false;
|
||||
if (len2 > len1) {
|
||||
/* One for the zero integer part. */
|
||||
qdigits = scale+1;
|
||||
qdigits = scale + 1;
|
||||
} else {
|
||||
qdigits = len1-len2+scale+1;
|
||||
qdigits = len1 - len2 + scale + 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Allocate and zero the storage for the quotient. */
|
||||
qval = bc_new_num (qdigits-scale,scale);
|
||||
memset (qval->n_value, 0, qdigits);
|
||||
qval = bc_new_num (qdigits - scale, scale);
|
||||
memset(qval->n_value, 0, qdigits);
|
||||
|
||||
/* Allocate storage for the temporary storage mval. */
|
||||
mval = (unsigned char *) safe_emalloc(1, len2, 1);
|
||||
|
|
@ -157,38 +154,34 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
/* Now for the full divide algorithm. */
|
||||
if (!zero) {
|
||||
/* Normalize */
|
||||
norm = 10 / ((int)*n2ptr + 1);
|
||||
norm = 10 / ((int) *n2ptr + 1);
|
||||
if (norm != 1) {
|
||||
_one_mult (num1, len1+scale1+extra+1, norm, num1);
|
||||
_one_mult (n2ptr, len2, norm, n2ptr);
|
||||
_one_mult(num1, len1 + scale1 + extra + 1, norm, num1);
|
||||
_one_mult(n2ptr, len2, norm, n2ptr);
|
||||
}
|
||||
|
||||
/* Initialize divide loop. */
|
||||
qdig = 0;
|
||||
if (len2 > len1) {
|
||||
qptr = (unsigned char *) qval->n_value+len2-len1;
|
||||
qptr = (unsigned char *) qval->n_value + len2 - len1;
|
||||
} else {
|
||||
qptr = (unsigned char *) qval->n_value;
|
||||
}
|
||||
|
||||
/* Loop */
|
||||
while (qdig <= len1+scale-len2) {
|
||||
while (qdig <= len1 + scale - len2) {
|
||||
/* Calculate the quotient digit guess. */
|
||||
if (*n2ptr == num1[qdig]) {
|
||||
qguess = 9;
|
||||
} else {
|
||||
qguess = (num1[qdig]*10 + num1[qdig+1]) / *n2ptr;
|
||||
qguess = (num1[qdig] * 10 + num1[qdig + 1]) / *n2ptr;
|
||||
}
|
||||
|
||||
/* Test qguess. */
|
||||
if (
|
||||
n2ptr[1]*qguess > (num1[qdig]*10 + num1[qdig+1] - *n2ptr*qguess)*10 + num1[qdig+2]
|
||||
) {
|
||||
if (n2ptr[1] * qguess > (num1[qdig] * 10 + num1[qdig + 1] - *n2ptr * qguess) * 10 + num1[qdig + 2]) {
|
||||
qguess--;
|
||||
/* And again. */
|
||||
if (
|
||||
n2ptr[1]*qguess > (num1[qdig]*10 + num1[qdig+1] - *n2ptr*qguess)*10 + num1[qdig+2]
|
||||
) {
|
||||
if (n2ptr[1] * qguess > (num1[qdig] * 10 + num1[qdig + 1] - *n2ptr * qguess) * 10 + num1[qdig + 2]) {
|
||||
qguess--;
|
||||
}
|
||||
}
|
||||
|
|
@ -197,10 +190,10 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
borrow = 0;
|
||||
if (qguess != 0) {
|
||||
*mval = 0;
|
||||
_one_mult (n2ptr, len2, qguess, mval+1);
|
||||
ptr1 = (unsigned char *) num1+qdig+len2;
|
||||
ptr2 = (unsigned char *) mval+len2;
|
||||
for (count = 0; count < len2+1; count++) {
|
||||
_one_mult(n2ptr, len2, qguess, mval + 1);
|
||||
ptr1 = (unsigned char *) num1 + qdig + len2;
|
||||
ptr2 = (unsigned char *) mval + len2;
|
||||
for (count = 0; count < len2 + 1; count++) {
|
||||
val = (int) *ptr1 - (int) *ptr2-- - borrow;
|
||||
if (val < 0) {
|
||||
val += 10;
|
||||
|
|
@ -215,8 +208,8 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
/* Test for negative result. */
|
||||
if (borrow == 1) {
|
||||
qguess--;
|
||||
ptr1 = (unsigned char *) num1+qdig+len2;
|
||||
ptr2 = (unsigned char *) n2ptr+len2-1;
|
||||
ptr1 = (unsigned char *) num1 + qdig + len2;
|
||||
ptr2 = (unsigned char *) n2ptr + len2 - 1;
|
||||
carry = 0;
|
||||
for (count = 0; count < len2; count++) {
|
||||
val = (int) *ptr1 + (int) *ptr2-- + carry;
|
||||
|
|
@ -240,7 +233,7 @@ bool bc_divide(bc_num n1, bc_num n2, bc_num *quot, int scale)
|
|||
}
|
||||
|
||||
/* Clean up and return the number. */
|
||||
qval->n_sign = ( n1->n_sign == n2->n_sign ? PLUS : MINUS );
|
||||
qval->n_sign = (n1->n_sign == n2->n_sign ? PLUS : MINUS);
|
||||
if (bc_is_zero(qval)) {
|
||||
qval->n_sign = PLUS;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,16 +53,16 @@ bool bc_divmod(bc_num num1, bc_num num2, bc_num *quot, bc_num *rem, size_t scale
|
|||
}
|
||||
|
||||
/* Calculate final scale. */
|
||||
rscale = MAX (num1->n_scale, num2->n_scale+scale);
|
||||
rscale = MAX (num1->n_scale, num2->n_scale + scale);
|
||||
bc_init_num(&temp);
|
||||
|
||||
/* Calculate it. */
|
||||
bc_divide (num1, num2, &temp, 0);
|
||||
bc_divide(num1, num2, &temp, 0);
|
||||
if (quot) {
|
||||
quotient = bc_copy_num(temp);
|
||||
}
|
||||
bc_multiply (temp, num2, &temp, rscale);
|
||||
bc_sub (num1, temp, rem, rscale);
|
||||
bc_multiply(temp, num2, &temp, rscale);
|
||||
bc_sub(num1, temp, rem, rscale);
|
||||
bc_free_num (&temp);
|
||||
|
||||
if (quot) {
|
||||
|
|
|
|||
|
|
@ -69,12 +69,12 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, size_t scale_min)
|
|||
/* Add the fraction part. First copy the longer fraction.*/
|
||||
if (n1bytes != n2bytes) {
|
||||
if (n1bytes > n2bytes) {
|
||||
while (n1bytes>n2bytes) {
|
||||
while (n1bytes > n2bytes) {
|
||||
*sumptr-- = *n1ptr--;
|
||||
n1bytes--;
|
||||
}
|
||||
} else {
|
||||
while (n2bytes>n1bytes) {
|
||||
while (n2bytes > n1bytes) {
|
||||
*sumptr-- = *n2ptr--;
|
||||
n2bytes--;
|
||||
}
|
||||
|
|
@ -87,7 +87,7 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, size_t scale_min)
|
|||
carry = 0;
|
||||
while ((n1bytes > 0) && (n2bytes > 0)) {
|
||||
*sumptr = *n1ptr-- + *n2ptr-- + carry;
|
||||
if (*sumptr > (BASE-1)) {
|
||||
if (*sumptr > (BASE - 1)) {
|
||||
carry = 1;
|
||||
*sumptr -= BASE;
|
||||
} else {
|
||||
|
|
@ -105,7 +105,7 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, size_t scale_min)
|
|||
}
|
||||
while (n1bytes-- > 0) {
|
||||
*sumptr = *n1ptr-- + carry;
|
||||
if (*sumptr > (BASE-1)) {
|
||||
if (*sumptr > (BASE - 1)) {
|
||||
carry = true;
|
||||
*sumptr -= BASE;
|
||||
} else {
|
||||
|
|
@ -120,7 +120,7 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, size_t scale_min)
|
|||
}
|
||||
|
||||
/* Adjust sum and return. */
|
||||
_bc_rm_leading_zeros (sum);
|
||||
_bc_rm_leading_zeros(sum);
|
||||
return sum;
|
||||
}
|
||||
|
||||
|
|
@ -132,10 +132,11 @@ bc_num _bc_do_add(bc_num n1, bc_num n2, size_t scale_min)
|
|||
bc_num _bc_do_sub(bc_num n1, bc_num n2, size_t scale_min)
|
||||
{
|
||||
bc_num diff;
|
||||
int diff_scale, diff_len;
|
||||
size_t diff_scale, diff_len;
|
||||
size_t min_scale, min_len;
|
||||
size_t borrow, count;
|
||||
int val;
|
||||
char *n1ptr, *n2ptr, *diffptr;
|
||||
int borrow, count, val;
|
||||
|
||||
/* Allocate temporary storage. */
|
||||
diff_len = MAX(n1->n_len, n2->n_len);
|
||||
|
|
@ -153,9 +154,9 @@ bc_num _bc_do_sub(bc_num n1, bc_num n2, size_t scale_min)
|
|||
}
|
||||
|
||||
/* Initialize the subtract. */
|
||||
n1ptr = (char *) (n1->n_value + n1->n_len + n1->n_scale -1);
|
||||
n2ptr = (char *) (n2->n_value + n2->n_len + n2->n_scale -1);
|
||||
diffptr = (char *) (diff->n_value + diff_len + diff_scale -1);
|
||||
n1ptr = (char *) (n1->n_value + n1->n_len + n1->n_scale - 1);
|
||||
n2ptr = (char *) (n2->n_value + n2->n_len + n2->n_scale - 1);
|
||||
diffptr = (char *) (diff->n_value + diff_len + diff_scale - 1);
|
||||
|
||||
/* Subtract the numbers. */
|
||||
borrow = 0;
|
||||
|
|
@ -169,7 +170,7 @@ bc_num _bc_do_sub(bc_num n1, bc_num n2, size_t scale_min)
|
|||
} else {
|
||||
/* n2 has the longer scale */
|
||||
for (count = n2->n_scale - min_scale; count > 0; count--) {
|
||||
val = - *n2ptr-- - borrow;
|
||||
val = -*n2ptr-- - borrow;
|
||||
if (val < 0) {
|
||||
val += BASE;
|
||||
borrow = 1;
|
||||
|
|
@ -192,7 +193,7 @@ bc_num _bc_do_sub(bc_num n1, bc_num n2, size_t scale_min)
|
|||
*diffptr-- = val;
|
||||
}
|
||||
|
||||
/* If n1 has more digits then n2, we now do that subtract. */
|
||||
/* If n1 has more digits than n2, we now do that subtract. */
|
||||
if (diff_len != min_len) {
|
||||
for (count = diff_len - min_len; count > 0; count--) {
|
||||
val = *n1ptr-- - borrow;
|
||||
|
|
@ -207,6 +208,6 @@ bc_num _bc_do_sub(bc_num n1, bc_num n2, size_t scale_min)
|
|||
}
|
||||
|
||||
/* Clean up and return. */
|
||||
_bc_rm_leading_zeros (diff);
|
||||
_bc_rm_leading_zeros(diff);
|
||||
return diff;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,22 +32,22 @@
|
|||
#include "bcmath.h"
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
#include "zend_alloc.h"
|
||||
|
||||
/* new_num allocates a number and sets fields to known values. */
|
||||
bc_num _bc_new_num_ex(size_t length, size_t scale, bool persistent)
|
||||
{
|
||||
bc_num temp;
|
||||
/* PHP Change: malloc() -> pemalloc(), removed free_list code */
|
||||
temp = (bc_num) safe_pemalloc (1, sizeof(bc_struct)+length, scale, persistent);
|
||||
bc_num temp = (bc_num) safe_pemalloc(1, sizeof(bc_struct) + length, scale, persistent);
|
||||
temp->n_sign = PLUS;
|
||||
temp->n_len = length;
|
||||
temp->n_scale = scale;
|
||||
temp->n_refs = 1;
|
||||
/* PHP Change: malloc() -> pemalloc() */
|
||||
temp->n_ptr = (char *) safe_pemalloc (1, length, scale, persistent);
|
||||
temp->n_ptr = (char *) safe_pemalloc(1, length, scale, persistent);
|
||||
temp->n_value = temp->n_ptr;
|
||||
memset (temp->n_ptr, 0, length+scale);
|
||||
memset(temp->n_ptr, 0, length + scale);
|
||||
return temp;
|
||||
}
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ void _bc_free_num_ex(bc_num *num, bool persistent)
|
|||
if ((*num)->n_refs == 0) {
|
||||
if ((*num)->n_ptr) {
|
||||
/* PHP Change: free() -> pefree(), removed free_list code */
|
||||
pefree ((*num)->n_ptr, persistent);
|
||||
pefree((*num)->n_ptr, persistent);
|
||||
}
|
||||
pefree(*num, persistent);
|
||||
}
|
||||
|
|
@ -75,10 +75,10 @@ void _bc_free_num_ex(bc_num *num, bool persistent)
|
|||
|
||||
void bc_init_numbers(void)
|
||||
{
|
||||
BCG(_zero_) = _bc_new_num_ex (1,0,1);
|
||||
BCG(_one_) = _bc_new_num_ex (1,0,1);
|
||||
BCG(_zero_) = _bc_new_num_ex(1, 0, 1);
|
||||
BCG(_one_) = _bc_new_num_ex(1, 0, 1);
|
||||
BCG(_one_)->n_value[0] = 1;
|
||||
BCG(_two_) = _bc_new_num_ex (1,0,1);
|
||||
BCG(_two_) = _bc_new_num_ex(1, 0, 1);
|
||||
BCG(_two_)->n_value[0] = 2;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -55,7 +55,8 @@ void bc_int2num(bc_num *num, int val)
|
|||
while (val != 0) {
|
||||
*bptr++ = val % BASE;
|
||||
val = val / BASE;
|
||||
ix++; /* Count the digits. */
|
||||
/* Count the digits. */
|
||||
ix++;
|
||||
}
|
||||
|
||||
/* Make the number. */
|
||||
|
|
|
|||
|
|
@ -30,8 +30,8 @@
|
|||
*************************************************************************/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include "bcmath.h"
|
||||
#include <stddef.h>
|
||||
|
||||
/* In some places we need to check if the number NUM is almost zero.
|
||||
Specifically, all but the last digit is 0 and the last digit is 1.
|
||||
|
|
@ -53,9 +53,5 @@ bool bc_is_near_zero(bc_num num, size_t scale)
|
|||
count--;
|
||||
}
|
||||
|
||||
if (count != 0 && (count != 1 || *--nptr != 1)) {
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
return count == 0 || (count == 1 && *--nptr == 1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,16 +39,13 @@
|
|||
|
||||
long bc_num2long(bc_num num)
|
||||
{
|
||||
long val;
|
||||
char *nptr;
|
||||
|
||||
/* Extract the int value, ignore the fraction. */
|
||||
val = 0;
|
||||
nptr = num->n_value;
|
||||
long val = 0;
|
||||
const char *nptr = num->n_value;
|
||||
for (size_t index = num->n_len; index > 0; index--) {
|
||||
char n = *nptr++;
|
||||
|
||||
if (val > LONG_MAX/BASE) {
|
||||
if (val > LONG_MAX / BASE) {
|
||||
return 0;
|
||||
}
|
||||
val *= BASE;
|
||||
|
|
|
|||
|
|
@ -38,8 +38,8 @@ zend_string *bc_num2str_ex(bc_num num, size_t scale)
|
|||
{
|
||||
zend_string *str;
|
||||
char *sptr;
|
||||
char *nptr;
|
||||
int index, signch;
|
||||
size_t index;
|
||||
bool signch;
|
||||
|
||||
/* Number of sign chars. */
|
||||
signch = num->n_sign != PLUS && !bc_is_zero_for_scale(num, MIN(num->n_scale, scale));
|
||||
|
|
@ -55,18 +55,18 @@ zend_string *bc_num2str_ex(bc_num num, size_t scale)
|
|||
if (signch) *sptr++ = '-';
|
||||
|
||||
/* Load the whole number. */
|
||||
nptr = num->n_value;
|
||||
for (index=num->n_len; index>0; index--) {
|
||||
const char *nptr = num->n_value;
|
||||
for (index = num->n_len; index > 0; index--) {
|
||||
*sptr++ = BCD_CHAR(*nptr++);
|
||||
}
|
||||
|
||||
/* Now the fraction. */
|
||||
if (scale > 0) {
|
||||
*sptr++ = '.';
|
||||
for (index=0; index<scale && index<num->n_scale; index++) {
|
||||
for (index = 0; index < scale && index < num->n_scale; index++) {
|
||||
*sptr++ = BCD_CHAR(*nptr++);
|
||||
}
|
||||
for (index = num->n_scale; index<scale; index++) {
|
||||
for (index = num->n_scale; index < scale; index++) {
|
||||
*sptr++ = BCD_CHAR(0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@
|
|||
|
||||
#include "bcmath.h"
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include "zend_alloc.h"
|
||||
|
||||
|
||||
|
|
@ -52,27 +53,27 @@ static const char ref_str[] = "0123456789ABCDEF";
|
|||
non-zero, we must output one space before the number. OUT_CHAR
|
||||
is the actual routine for writing the characters. */
|
||||
|
||||
void bc_out_long (long val, size_t size, bool space, void (*out_char)(char) )
|
||||
void bc_out_long(long val, size_t size, bool space, void (*out_char)(char))
|
||||
{
|
||||
char digits[40];
|
||||
size_t len, ix;
|
||||
|
||||
if (space) (*out_char) (' ');
|
||||
if (space) (*out_char)(' ');
|
||||
snprintf(digits, sizeof(digits), "%ld", val);
|
||||
len = strlen(digits);
|
||||
while (size > len) {
|
||||
(*out_char) ('0');
|
||||
(*out_char)('0');
|
||||
size--;
|
||||
}
|
||||
for (ix=0; ix < len; ix++) {
|
||||
(*out_char) (digits[ix]);
|
||||
for (ix = 0; ix < len; ix++) {
|
||||
(*out_char)(digits[ix]);
|
||||
}
|
||||
}
|
||||
|
||||
/* Output of a bcd number. NUM is written in base O_BASE using OUT_CHAR
|
||||
as the routine to do the actual output of the characters. */
|
||||
|
||||
void bc_out_num (bc_num num, int o_base, void (*out_char)(char), bool leading_zero)
|
||||
void bc_out_num(bc_num num, int o_base, void (*out_char)(char), bool leading_zero)
|
||||
{
|
||||
char *nptr;
|
||||
int index, fdigit;
|
||||
|
|
@ -81,64 +82,64 @@ void bc_out_num (bc_num num, int o_base, void (*out_char)(char), bool leading_ze
|
|||
bc_num int_part, frac_part, base, cur_dig, t_num, max_o_digit;
|
||||
|
||||
/* The negative sign if needed. */
|
||||
if (num->n_sign == MINUS) (*out_char) ('-');
|
||||
if (num->n_sign == MINUS) (*out_char)('-');
|
||||
|
||||
/* Output the number. */
|
||||
if (bc_is_zero (num)) {
|
||||
(*out_char) ('0');
|
||||
if (bc_is_zero(num)) {
|
||||
(*out_char)('0');
|
||||
} else {
|
||||
if (o_base == 10) {
|
||||
/* The number is in base 10, do it the fast way. */
|
||||
nptr = num->n_value;
|
||||
if (num->n_len > 1 || *nptr != 0) {
|
||||
for (index=num->n_len; index>0; index--) {
|
||||
(*out_char) (BCD_CHAR(*nptr++));
|
||||
for (index = num->n_len; index > 0; index--) {
|
||||
(*out_char)(BCD_CHAR(*nptr++));
|
||||
}
|
||||
} else {
|
||||
nptr++;
|
||||
}
|
||||
|
||||
if (leading_zero && bc_is_zero(num)) {
|
||||
(*out_char) ('0');
|
||||
(*out_char)('0');
|
||||
}
|
||||
|
||||
/* Now the fraction. */
|
||||
if (num->n_scale > 0) {
|
||||
(*out_char) ('.');
|
||||
for (index=0; index<num->n_scale; index++) {
|
||||
(*out_char) (BCD_CHAR(*nptr++));
|
||||
(*out_char)('.');
|
||||
for (index = 0; index < num->n_scale; index++) {
|
||||
(*out_char)(BCD_CHAR(*nptr++));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* special case ... */
|
||||
if (leading_zero && bc_is_zero (num)) {
|
||||
(*out_char) ('0');
|
||||
if (leading_zero && bc_is_zero(num)) {
|
||||
(*out_char)('0');
|
||||
}
|
||||
|
||||
/* The number is some other base. */
|
||||
digits = NULL;
|
||||
bc_init_num (&int_part);
|
||||
bc_divide (num, BCG(_one_), &int_part, 0);
|
||||
bc_init_num (&frac_part);
|
||||
bc_init_num (&cur_dig);
|
||||
bc_init_num (&base);
|
||||
bc_sub (num, int_part, &frac_part, 0);
|
||||
bc_init_num(&int_part);
|
||||
bc_divide(num, BCG(_one_), &int_part, 0);
|
||||
bc_init_num(&frac_part);
|
||||
bc_init_num(&cur_dig);
|
||||
bc_init_num(&base);
|
||||
bc_sub(num, int_part, &frac_part, 0);
|
||||
/* Make the INT_PART and FRAC_PART positive. */
|
||||
int_part->n_sign = PLUS;
|
||||
frac_part->n_sign = PLUS;
|
||||
bc_int2num (&base, o_base);
|
||||
bc_init_num (&max_o_digit);
|
||||
bc_int2num (&max_o_digit, o_base-1);
|
||||
bc_int2num(&base, o_base);
|
||||
bc_init_num(&max_o_digit);
|
||||
bc_int2num(&max_o_digit, o_base - 1);
|
||||
|
||||
/* Get the digits of the integer part and push them on a stack. */
|
||||
while (!bc_is_zero(int_part)) {
|
||||
bc_modulo (int_part, base, &cur_dig, 0);
|
||||
bc_modulo(int_part, base, &cur_dig, 0);
|
||||
/* PHP Change: malloc() -> emalloc() */
|
||||
temp = (stk_rec *) emalloc (sizeof(stk_rec));
|
||||
temp->digit = bc_num2long (cur_dig);
|
||||
temp = (stk_rec *) emalloc(sizeof(stk_rec));
|
||||
temp->digit = bc_num2long(cur_dig);
|
||||
temp->next = digits;
|
||||
digits = temp;
|
||||
bc_divide (int_part, base, &int_part, 0);
|
||||
bc_divide(int_part, base, &int_part, 0);
|
||||
}
|
||||
|
||||
/* Print the digits on the stack. */
|
||||
|
|
@ -148,9 +149,9 @@ void bc_out_num (bc_num num, int o_base, void (*out_char)(char), bool leading_ze
|
|||
temp = digits;
|
||||
digits = digits->next;
|
||||
if (o_base <= 16) {
|
||||
(*out_char) (ref_str[ (int) temp->digit]);
|
||||
(*out_char)(ref_str[(int) temp->digit]);
|
||||
} else {
|
||||
bc_out_long (temp->digit, max_o_digit->n_len, 1, out_char);
|
||||
bc_out_long(temp->digit, max_o_digit->n_len, 1, out_char);
|
||||
}
|
||||
efree(temp);
|
||||
}
|
||||
|
|
@ -158,21 +159,21 @@ void bc_out_num (bc_num num, int o_base, void (*out_char)(char), bool leading_ze
|
|||
|
||||
/* Get and print the digits of the fraction part. */
|
||||
if (num->n_scale > 0) {
|
||||
(*out_char) ('.');
|
||||
(*out_char)('.');
|
||||
pre_space = false;
|
||||
t_num = bc_copy_num (BCG(_one_));
|
||||
t_num = bc_copy_num(BCG(_one_));
|
||||
while (t_num->n_len <= num->n_scale) {
|
||||
bc_multiply (frac_part, base, &frac_part, num->n_scale);
|
||||
fdigit = bc_num2long (frac_part);
|
||||
bc_int2num (&int_part, fdigit);
|
||||
bc_sub (frac_part, int_part, &frac_part, 0);
|
||||
bc_multiply(frac_part, base, &frac_part, num->n_scale);
|
||||
fdigit = bc_num2long(frac_part);
|
||||
bc_int2num(&int_part, fdigit);
|
||||
bc_sub(frac_part, int_part, &frac_part, 0);
|
||||
if (o_base <= 16) {
|
||||
(*out_char) (ref_str[fdigit]);
|
||||
(*out_char)(ref_str[fdigit]);
|
||||
} else {
|
||||
bc_out_long (fdigit, max_o_digit->n_len, pre_space, out_char);
|
||||
bc_out_long(fdigit, max_o_digit->n_len, pre_space, out_char);
|
||||
pre_space = true;
|
||||
}
|
||||
bc_multiply (t_num, base, &t_num, 0);
|
||||
bc_multiply(t_num, base, &t_num, 0);
|
||||
}
|
||||
bc_free_num (&t_num);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ void bc_raise(bc_num num1, long exponent, bc_num *result, size_t scale)
|
|||
/* Special case if exponent is a zero. */
|
||||
if (exponent == 0) {
|
||||
bc_free_num (result);
|
||||
*result = bc_copy_num (BCG(_one_));
|
||||
*result = bc_copy_num(BCG(_one_));
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -61,35 +61,35 @@ void bc_raise(bc_num num1, long exponent, bc_num *result, size_t scale)
|
|||
rscale = scale;
|
||||
} else {
|
||||
is_neg = false;
|
||||
rscale = MIN (num1->n_scale*exponent, MAX(scale, num1->n_scale));
|
||||
rscale = MIN (num1->n_scale * exponent, MAX(scale, num1->n_scale));
|
||||
}
|
||||
|
||||
/* Set initial value of temp. */
|
||||
power = bc_copy_num (num1);
|
||||
power = bc_copy_num(num1);
|
||||
pwrscale = num1->n_scale;
|
||||
while ((exponent & 1) == 0) {
|
||||
pwrscale = 2*pwrscale;
|
||||
bc_multiply (power, power, &power, pwrscale);
|
||||
pwrscale = 2 * pwrscale;
|
||||
bc_multiply(power, power, &power, pwrscale);
|
||||
exponent = exponent >> 1;
|
||||
}
|
||||
temp = bc_copy_num (power);
|
||||
temp = bc_copy_num(power);
|
||||
calcscale = pwrscale;
|
||||
exponent = exponent >> 1;
|
||||
|
||||
/* Do the calculation. */
|
||||
while (exponent > 0) {
|
||||
pwrscale = 2*pwrscale;
|
||||
bc_multiply (power, power, &power, pwrscale);
|
||||
pwrscale = 2 * pwrscale;
|
||||
bc_multiply(power, power, &power, pwrscale);
|
||||
if ((exponent & 1) == 1) {
|
||||
calcscale = pwrscale + calcscale;
|
||||
bc_multiply (temp, power, &temp, calcscale);
|
||||
bc_multiply(temp, power, &temp, calcscale);
|
||||
}
|
||||
exponent = exponent >> 1;
|
||||
}
|
||||
|
||||
/* Assign the value. */
|
||||
if (is_neg) {
|
||||
bc_divide (BCG(_one_), temp, result, rscale);
|
||||
bc_divide(BCG(_one_), temp, result, rscale);
|
||||
bc_free_num (&temp);
|
||||
} else {
|
||||
bc_free_num (result);
|
||||
|
|
|
|||
|
|
@ -59,26 +59,26 @@ raise_mod_status bc_raisemod(bc_num base, bc_num expo, bc_num mod, bc_num *resul
|
|||
}
|
||||
|
||||
/* Set initial values. */
|
||||
power = bc_copy_num (base);
|
||||
exponent = bc_copy_num (expo);
|
||||
modulus = bc_copy_num (mod);
|
||||
temp = bc_copy_num (BCG(_one_));
|
||||
power = bc_copy_num(base);
|
||||
exponent = bc_copy_num(expo);
|
||||
modulus = bc_copy_num(mod);
|
||||
temp = bc_copy_num(BCG(_one_));
|
||||
bc_init_num(&parity);
|
||||
|
||||
/* Do the calculation. */
|
||||
rscale = MAX(scale, power->n_scale);
|
||||
if ( !bc_compare(modulus, BCG(_one_)) ) {
|
||||
if (!bc_compare(modulus, BCG(_one_))) {
|
||||
bc_free_num (&temp);
|
||||
temp = bc_new_num (1, scale);
|
||||
} else {
|
||||
while ( !bc_is_zero(exponent) ) {
|
||||
(void) bc_divmod (exponent, BCG(_two_), &exponent, &parity, 0);
|
||||
if ( !bc_is_zero(parity) ) {
|
||||
bc_multiply (temp, power, &temp, rscale);
|
||||
(void) bc_modulo (temp, modulus, &temp, scale);
|
||||
while (!bc_is_zero(exponent)) {
|
||||
(void) bc_divmod(exponent, BCG(_two_), &exponent, &parity, 0);
|
||||
if (!bc_is_zero(parity)) {
|
||||
bc_multiply(temp, power, &temp, rscale);
|
||||
(void) bc_modulo(temp, modulus, &temp, scale);
|
||||
}
|
||||
bc_multiply (power, power, &power, rscale);
|
||||
(void) bc_modulo (power, modulus, &power, scale);
|
||||
bc_multiply(power, power, &power, rscale);
|
||||
(void) bc_modulo(power, modulus, &power, scale);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -50,9 +50,7 @@ int mul_base_digits = MUL_BASE_DIGITS;
|
|||
|
||||
static bc_num new_sub_num(size_t length, size_t scale, char *value)
|
||||
{
|
||||
bc_num temp;
|
||||
|
||||
temp = (bc_num) emalloc (sizeof(bc_struct));
|
||||
bc_num temp = (bc_num) emalloc(sizeof(bc_struct));
|
||||
|
||||
temp->n_sign = PLUS;
|
||||
temp->n_len = length;
|
||||
|
|
@ -67,21 +65,20 @@ static void _bc_simp_mul(bc_num n1, size_t n1len, bc_num n2, int n2len, bc_num *
|
|||
{
|
||||
char *n1ptr, *n2ptr, *pvptr;
|
||||
char *n1end, *n2end; /* To the end of n1 and n2. */
|
||||
int indx, sum, prodlen;
|
||||
int sum = 0;
|
||||
|
||||
prodlen = n1len+n2len+1;
|
||||
int prodlen = n1len + n2len + 1;
|
||||
|
||||
*prod = bc_new_num (prodlen, 0);
|
||||
|
||||
n1end = (char *) (n1->n_value + n1len - 1);
|
||||
n2end = (char *) (n2->n_value + n2len - 1);
|
||||
pvptr = (char *) ((*prod)->n_value + prodlen - 1);
|
||||
sum = 0;
|
||||
|
||||
/* Here is the loop... */
|
||||
for (indx = 0; indx < prodlen-1; indx++) {
|
||||
n1ptr = (char *) (n1end - MAX(0, indx-n2len+1));
|
||||
n2ptr = (char *) (n2end - MIN(indx, n2len-1));
|
||||
for (int index = 0; index < prodlen - 1; index++) {
|
||||
n1ptr = (char *) (n1end - MAX(0, index - n2len + 1));
|
||||
n2ptr = (char *) (n2end - MIN(index, n2len - 1));
|
||||
while ((n1ptr >= n1->n_value) && (n2ptr <= n2end)) {
|
||||
sum += *n1ptr * *n2ptr;
|
||||
n1ptr--;
|
||||
|
|
@ -98,7 +95,7 @@ static void _bc_simp_mul(bc_num n1, size_t n1len, bc_num n2, int n2len, bc_num *
|
|||
multiply algorithm. Note: if sub is called, accum must
|
||||
be larger that what is being subtracted. Also, accum and val
|
||||
must have n_scale = 0. (e.g. they must look like integers. *) */
|
||||
static void _bc_shift_addsub (bc_num accum, bc_num val, int shift, bool sub)
|
||||
static void _bc_shift_addsub(bc_num accum, bc_num val, int shift, bool sub)
|
||||
{
|
||||
signed char *accp, *valp;
|
||||
unsigned int carry = 0;
|
||||
|
|
@ -107,11 +104,11 @@ static void _bc_shift_addsub (bc_num accum, bc_num val, int shift, bool sub)
|
|||
if (val->n_value[0] == 0) {
|
||||
count--;
|
||||
}
|
||||
assert(accum->n_len+accum->n_scale >= shift+count);
|
||||
assert(accum->n_len + accum->n_scale >= shift + count);
|
||||
|
||||
/* Set up pointers and others */
|
||||
accp = (signed char *)(accum->n_value + accum->n_len + accum->n_scale - shift - 1);
|
||||
valp = (signed char *)(val->n_value + val->n_len - 1);
|
||||
accp = (signed char *) (accum->n_value + accum->n_len + accum->n_scale - shift - 1);
|
||||
valp = (signed char *) (val->n_value + val->n_len - 1);
|
||||
|
||||
if (sub) {
|
||||
/* Subtraction, carry is really borrow. */
|
||||
|
|
@ -137,7 +134,7 @@ static void _bc_shift_addsub (bc_num accum, bc_num val, int shift, bool sub)
|
|||
/* Addition */
|
||||
while (count--) {
|
||||
*accp += *valp-- + carry;
|
||||
if (*accp > (BASE-1)) {
|
||||
if (*accp > (BASE - 1)) {
|
||||
carry = 1;
|
||||
*accp-- -= BASE;
|
||||
} else {
|
||||
|
|
@ -147,7 +144,7 @@ static void _bc_shift_addsub (bc_num accum, bc_num val, int shift, bool sub)
|
|||
}
|
||||
while (carry) {
|
||||
*accp += carry;
|
||||
if (*accp > (BASE-1)) {
|
||||
if (*accp > (BASE - 1)) {
|
||||
*accp-- -= BASE;
|
||||
} else {
|
||||
carry = 0;
|
||||
|
|
@ -168,40 +165,40 @@ static void _bc_rec_mul(bc_num u, size_t ulen, bc_num v, size_t vlen, bc_num *pr
|
|||
{
|
||||
bc_num u0, u1, v0, v1;
|
||||
bc_num m1, m2, m3, d1, d2;
|
||||
int n, prodlen, m1zero;
|
||||
int d1len, d2len;
|
||||
size_t n;
|
||||
bool m1zero;
|
||||
|
||||
/* Base case? */
|
||||
if ((ulen+vlen) < mul_base_digits
|
||||
if ((ulen + vlen) < mul_base_digits
|
||||
|| ulen < MUL_SMALL_DIGITS
|
||||
|| vlen < MUL_SMALL_DIGITS
|
||||
) {
|
||||
_bc_simp_mul (u, ulen, v, vlen, prod);
|
||||
_bc_simp_mul(u, ulen, v, vlen, prod);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Calculate n -- the u and v split point in digits. */
|
||||
n = (MAX(ulen, vlen)+1) / 2;
|
||||
n = (MAX(ulen, vlen) + 1) / 2;
|
||||
|
||||
/* Split u and v. */
|
||||
if (ulen < n) {
|
||||
u1 = bc_copy_num (BCG(_zero_));
|
||||
u0 = new_sub_num (ulen,0, u->n_value);
|
||||
u1 = bc_copy_num(BCG(_zero_));
|
||||
u0 = new_sub_num(ulen, 0, u->n_value);
|
||||
} else {
|
||||
u1 = new_sub_num (ulen-n, 0, u->n_value);
|
||||
u0 = new_sub_num (n, 0, u->n_value+ulen-n);
|
||||
u1 = new_sub_num(ulen - n, 0, u->n_value);
|
||||
u0 = new_sub_num(n, 0, u->n_value + ulen - n);
|
||||
}
|
||||
if (vlen < n) {
|
||||
v1 = bc_copy_num (BCG(_zero_));
|
||||
v0 = new_sub_num (vlen,0, v->n_value);
|
||||
v1 = bc_copy_num(BCG(_zero_));
|
||||
v0 = new_sub_num(vlen, 0, v->n_value);
|
||||
} else {
|
||||
v1 = new_sub_num (vlen-n, 0, v->n_value);
|
||||
v0 = new_sub_num (n, 0, v->n_value+vlen-n);
|
||||
v1 = new_sub_num(vlen - n, 0, v->n_value);
|
||||
v0 = new_sub_num(n, 0, v->n_value + vlen - n);
|
||||
}
|
||||
_bc_rm_leading_zeros (u1);
|
||||
_bc_rm_leading_zeros (u0);
|
||||
_bc_rm_leading_zeros (v1);
|
||||
_bc_rm_leading_zeros (v0);
|
||||
_bc_rm_leading_zeros(u1);
|
||||
_bc_rm_leading_zeros(u0);
|
||||
_bc_rm_leading_zeros(v1);
|
||||
_bc_rm_leading_zeros(v0);
|
||||
|
||||
m1zero = bc_is_zero(u1) || bc_is_zero(v1);
|
||||
|
||||
|
|
@ -209,42 +206,39 @@ static void _bc_rec_mul(bc_num u, size_t ulen, bc_num v, size_t vlen, bc_num *pr
|
|||
|
||||
bc_init_num(&d1);
|
||||
bc_init_num(&d2);
|
||||
bc_sub (u1, u0, &d1, 0);
|
||||
d1len = d1->n_len;
|
||||
bc_sub (v0, v1, &d2, 0);
|
||||
d2len = d2->n_len;
|
||||
bc_sub(u1, u0, &d1, 0);
|
||||
bc_sub(v0, v1, &d2, 0);
|
||||
|
||||
|
||||
/* Do recursive multiplies and shifted adds. */
|
||||
if (m1zero) {
|
||||
m1 = bc_copy_num (BCG(_zero_));
|
||||
m1 = bc_copy_num(BCG(_zero_));
|
||||
} else {
|
||||
_bc_rec_mul (u1, u1->n_len, v1, v1->n_len, &m1);
|
||||
_bc_rec_mul(u1, u1->n_len, v1, v1->n_len, &m1);
|
||||
}
|
||||
|
||||
if (bc_is_zero(d1) || bc_is_zero(d2)) {
|
||||
m2 = bc_copy_num (BCG(_zero_));
|
||||
m2 = bc_copy_num(BCG(_zero_));
|
||||
} else {
|
||||
_bc_rec_mul (d1, d1len, d2, d2len, &m2);
|
||||
_bc_rec_mul(d1, d1->n_len, d2, d2->n_len, &m2);
|
||||
}
|
||||
|
||||
if (bc_is_zero(u0) || bc_is_zero(v0)) {
|
||||
m3 = bc_copy_num (BCG(_zero_));
|
||||
m3 = bc_copy_num(BCG(_zero_));
|
||||
} else {
|
||||
_bc_rec_mul (u0, u0->n_len, v0, v0->n_len, &m3);
|
||||
_bc_rec_mul(u0, u0->n_len, v0, v0->n_len, &m3);
|
||||
}
|
||||
|
||||
/* Initialize product */
|
||||
prodlen = ulen+vlen+1;
|
||||
*prod = bc_new_num(prodlen, 0);
|
||||
*prod = bc_new_num(ulen + vlen + 1, 0);
|
||||
|
||||
if (!m1zero) {
|
||||
_bc_shift_addsub (*prod, m1, 2*n, 0);
|
||||
_bc_shift_addsub (*prod, m1, n, 0);
|
||||
_bc_shift_addsub(*prod, m1, 2 * n, false);
|
||||
_bc_shift_addsub(*prod, m1, n, false);
|
||||
}
|
||||
_bc_shift_addsub (*prod, m3, n, 0);
|
||||
_bc_shift_addsub (*prod, m3, 0, 0);
|
||||
_bc_shift_addsub (*prod, m2, n, d1->n_sign != d2->n_sign);
|
||||
_bc_shift_addsub(*prod, m3, n, false);
|
||||
_bc_shift_addsub(*prod, m3, 0, false);
|
||||
_bc_shift_addsub(*prod, m2, n, d1->n_sign != d2->n_sign);
|
||||
|
||||
/* Now clean up! */
|
||||
bc_free_num (&u1);
|
||||
|
|
@ -272,13 +266,13 @@ void bc_multiply(bc_num n1, bc_num n2, bc_num *prod, size_t scale)
|
|||
len1 = n1->n_len + n1->n_scale;
|
||||
len2 = n2->n_len + n2->n_scale;
|
||||
full_scale = n1->n_scale + n2->n_scale;
|
||||
prod_scale = MIN(full_scale,MAX(scale,MAX(n1->n_scale,n2->n_scale)));
|
||||
prod_scale = MIN(full_scale, MAX(scale, MAX(n1->n_scale, n2->n_scale)));
|
||||
|
||||
/* Do the multiply */
|
||||
_bc_rec_mul (n1, len1, n2, len2, &pval);
|
||||
_bc_rec_mul(n1, len1, n2, len2, &pval);
|
||||
|
||||
/* Assign to prod and clean up the number. */
|
||||
pval->n_sign = ( n1->n_sign == n2->n_sign ? PLUS : MINUS );
|
||||
pval->n_sign = (n1->n_sign == n2->n_sign ? PLUS : MINUS);
|
||||
pval->n_value = pval->n_ptr;
|
||||
pval->n_len = len2 + len1 + 1 - full_scale;
|
||||
pval->n_scale = prod_scale;
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@
|
|||
|
||||
void _bc_rm_leading_zeros(bc_num num)
|
||||
{
|
||||
/* We can move n_value to point to the first non zero digit! */
|
||||
/* We can move n_value to point to the first non-zero digit! */
|
||||
while (*num->n_value == 0 && num->n_len > 1) {
|
||||
num->n_value++;
|
||||
num->n_len--;
|
||||
|
|
|
|||
|
|
@ -30,8 +30,8 @@
|
|||
*************************************************************************/
|
||||
|
||||
#include "bcmath.h"
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
/* Take the square root NUM and return it in NUM with SCALE digits
|
||||
after the decimal place. */
|
||||
|
|
@ -39,20 +39,20 @@
|
|||
bool bc_sqrt(bc_num *num, size_t scale)
|
||||
{
|
||||
/* Initial checks. */
|
||||
int cmp_res = bc_compare (*num, BCG(_zero_));
|
||||
int cmp_res = bc_compare(*num, BCG(_zero_));
|
||||
if (cmp_res < 0) {
|
||||
return false; /* error */
|
||||
} else {
|
||||
if (cmp_res == 0) {
|
||||
bc_free_num (num);
|
||||
*num = bc_copy_num (BCG(_zero_));
|
||||
*num = bc_copy_num(BCG(_zero_));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
cmp_res = bc_compare (*num, BCG(_one_));
|
||||
cmp_res = bc_compare(*num, BCG(_one_));
|
||||
if (cmp_res == 0) {
|
||||
bc_free_num (num);
|
||||
*num = bc_copy_num (BCG(_one_));
|
||||
*num = bc_copy_num(BCG(_one_));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -64,22 +64,22 @@ bool bc_sqrt(bc_num *num, size_t scale)
|
|||
rscale = MAX (scale, (*num)->n_scale);
|
||||
bc_init_num(&guess1);
|
||||
bc_init_num(&diff);
|
||||
point5 = bc_new_num (1,1);
|
||||
point5 = bc_new_num (1, 1);
|
||||
point5->n_value[1] = 5;
|
||||
|
||||
|
||||
/* Calculate the initial guess. */
|
||||
if (cmp_res < 0) {
|
||||
/* The number is between 0 and 1. Guess should start at 1. */
|
||||
guess = bc_copy_num (BCG(_one_));
|
||||
guess = bc_copy_num(BCG(_one_));
|
||||
cscale = (*num)->n_scale;
|
||||
} else {
|
||||
/* The number is greater than 1. Guess should start at 10^(exp/2). */
|
||||
bc_init_num(&guess);
|
||||
bc_int2num (&guess,10);
|
||||
bc_int2num(&guess, 10);
|
||||
|
||||
bc_int2num (&guess1,(*num)->n_len);
|
||||
bc_multiply (guess1, point5, &guess1, 0);
|
||||
bc_int2num(&guess1, (*num)->n_len);
|
||||
bc_multiply(guess1, point5, &guess1, 0);
|
||||
guess1->n_scale = 0;
|
||||
bc_raise_bc_exponent(guess, guess1, &guess, 0);
|
||||
bc_free_num (&guess1);
|
||||
|
|
@ -90,14 +90,14 @@ bool bc_sqrt(bc_num *num, size_t scale)
|
|||
bool done = false;
|
||||
while (!done) {
|
||||
bc_free_num (&guess1);
|
||||
guess1 = bc_copy_num (guess);
|
||||
bc_divide (*num, guess, &guess, cscale);
|
||||
bc_add (guess, guess1, &guess, 0);
|
||||
bc_multiply (guess, point5, &guess, cscale);
|
||||
bc_sub (guess, guess1, &diff, cscale+1);
|
||||
if (bc_is_near_zero (diff, cscale)) {
|
||||
if (cscale < rscale+1) {
|
||||
cscale = MIN (cscale*3, rscale+1);
|
||||
guess1 = bc_copy_num(guess);
|
||||
bc_divide(*num, guess, &guess, cscale);
|
||||
bc_add(guess, guess1, &guess, 0);
|
||||
bc_multiply(guess, point5, &guess, cscale);
|
||||
bc_sub(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;
|
||||
}
|
||||
|
|
@ -106,7 +106,7 @@ bool bc_sqrt(bc_num *num, size_t scale)
|
|||
|
||||
/* Assign the number and clean up. */
|
||||
bc_free_num (num);
|
||||
bc_divide (guess,BCG(_one_),num,rscale);
|
||||
bc_divide(guess, BCG(_one_), num, rscale);
|
||||
bc_free_num (&guess);
|
||||
bc_free_num (&guess1);
|
||||
bc_free_num (&point5);
|
||||
|
|
|
|||
|
|
@ -35,22 +35,21 @@
|
|||
|
||||
/* Convert strings to bc numbers. Base 10 only.*/
|
||||
|
||||
bool bc_str2num (bc_num *num, char *str, size_t scale)
|
||||
bool bc_str2num(bc_num *num, char *str, size_t scale)
|
||||
{
|
||||
size_t digits, strscale;
|
||||
size_t digits = 0;
|
||||
size_t strscale = 0;
|
||||
char *ptr, *nptr;
|
||||
bool zero_int = false;
|
||||
size_t trailing_zeros = 0;
|
||||
bool zero_int = false;
|
||||
|
||||
/* Prepare num. */
|
||||
bc_free_num (num);
|
||||
|
||||
/* Check for valid number and count digits. */
|
||||
ptr = str;
|
||||
digits = 0;
|
||||
strscale = 0;
|
||||
|
||||
if ( (*ptr == '+') || (*ptr == '-')) {
|
||||
if ((*ptr == '+') || (*ptr == '-')) {
|
||||
/* Skip Sign */
|
||||
ptr++;
|
||||
}
|
||||
|
|
@ -79,11 +78,11 @@ bool bc_str2num (bc_num *num, char *str, size_t scale)
|
|||
}
|
||||
|
||||
if (trailing_zeros > 0) {
|
||||
/* Trailining zeros should not take part in the computation of the overall scale, as it is pointless. */
|
||||
/* Trailing zeros should not take part in the computation of the overall scale, as it is pointless. */
|
||||
strscale = strscale - trailing_zeros;
|
||||
}
|
||||
if ((*ptr != '\0') || (digits+strscale == 0)) {
|
||||
*num = bc_copy_num (BCG(_zero_));
|
||||
if ((*ptr != '\0') || (digits + strscale == 0)) {
|
||||
*num = bc_copy_num(BCG(_zero_));
|
||||
return *ptr == '\0';
|
||||
}
|
||||
|
||||
|
|
@ -113,7 +112,7 @@ bool bc_str2num (bc_num *num, char *str, size_t scale)
|
|||
*nptr++ = 0;
|
||||
digits = 0;
|
||||
}
|
||||
for (;digits > 0; digits--) {
|
||||
for (; digits > 0; digits--) {
|
||||
*nptr++ = CH_VAL(*ptr++);
|
||||
}
|
||||
|
||||
|
|
@ -121,12 +120,12 @@ bool bc_str2num (bc_num *num, char *str, size_t scale)
|
|||
if (strscale > 0) {
|
||||
/* skip the decimal point! */
|
||||
ptr++;
|
||||
for (;strscale > 0; strscale--) {
|
||||
for (; strscale > 0; strscale--) {
|
||||
*nptr++ = CH_VAL(*ptr++);
|
||||
}
|
||||
}
|
||||
|
||||
if (bc_is_zero (*num)) {
|
||||
if (bc_is_zero(*num)) {
|
||||
(*num)->n_sign = PLUS;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@
|
|||
#include "private.h"
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
|
||||
/* Here is the full subtract routine that takes care of negative numbers.
|
||||
N2 is subtracted from N1 and the result placed in RESULT. SCALE_MIN
|
||||
|
|
@ -41,31 +42,29 @@
|
|||
void bc_sub(bc_num n1, bc_num n2, bc_num *result, size_t scale_min)
|
||||
{
|
||||
bc_num diff = NULL;
|
||||
int cmp_res;
|
||||
|
||||
if (n1->n_sign != n2->n_sign) {
|
||||
diff = _bc_do_add (n1, n2, scale_min);
|
||||
diff = _bc_do_add(n1, n2, scale_min);
|
||||
diff->n_sign = n1->n_sign;
|
||||
} else {
|
||||
/* subtraction must be done. */
|
||||
/* Compare magnitudes. */
|
||||
cmp_res = _bc_do_compare(n1, n2, false, false);
|
||||
switch (cmp_res) {
|
||||
switch (_bc_do_compare(n1, n2, false, false)) {
|
||||
case -1:
|
||||
/* n1 is less than n2, subtract n1 from n2. */
|
||||
diff = _bc_do_sub (n2, n1, scale_min);
|
||||
diff = _bc_do_sub(n2, n1, scale_min);
|
||||
diff->n_sign = (n2->n_sign == PLUS ? MINUS : PLUS);
|
||||
break;
|
||||
case 0: {
|
||||
/* They are equal! return zero! */
|
||||
size_t res_scale = MAX (scale_min, MAX(n1->n_scale, n2->n_scale));
|
||||
diff = bc_new_num (1, res_scale);
|
||||
memset (diff->n_value, 0, res_scale+1);
|
||||
memset(diff->n_value, 0, res_scale + 1);
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
/* n2 is less than n1, subtract n2 from n1. */
|
||||
diff = _bc_do_sub (n1, n2, scale_min);
|
||||
diff = _bc_do_sub(n1, n2, scale_min);
|
||||
diff->n_sign = n1->n_sign;
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,12 +30,12 @@
|
|||
*************************************************************************/
|
||||
|
||||
#include "bcmath.h"
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
/* In some places we need to check if the number NUM is zero. */
|
||||
|
||||
bool bc_is_zero_for_scale (bc_num num, size_t scale)
|
||||
bool bc_is_zero_for_scale(bc_num num, size_t scale)
|
||||
{
|
||||
size_t count;
|
||||
char *nptr;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue