steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: a lot of methods in bignum.cpp converted to use data_roots instead of gc_bignums

db4
Björn Lindqvist 2014-06-17 00:30:23 +02:00 committed by John Benediktsson
parent 441a4595bb
commit a4df09a34e
2 changed files with 97 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
vm/bignum.cpp
View File

@ -108,15 +108,15 @@ bignum* factor_vm::bignum_subtract(bignum* x, bignum* y) {
} }
#ifdef _WIN64 #ifdef _WIN64
bignum *factor_vm::bignum_square(bignum * x) bignum *factor_vm::bignum_square(bignum* x_)
{ {
return bignum_multiply(x, x); return bignum_multiply(x, x);
} }
#else #else
/* Allocates memory */ /* Allocates memory */
bignum *factor_vm::bignum_square(bignum * x) bignum *factor_vm::bignum_square(bignum* x_)
{ {
GC_BIGNUM(x); data_root<bignum> x(x_, this);
bignum_length_type length = (BIGNUM_LENGTH (x)); bignum_length_type length = (BIGNUM_LENGTH (x));
bignum * z = (allot_bignum_zeroed ((length + length), 0)); bignum * z = (allot_bignum_zeroed ((length + length), 0));
@ -488,13 +488,14 @@ enum bignum_comparison factor_vm::bignum_compare_unsigned(bignum* x,
/* Addition */ /* Addition */
/* Allocates memory */ /* Allocates memory, fixed! */
bignum* factor_vm::bignum_add_unsigned(bignum* x, bignum* y, int negative_p) { bignum* factor_vm::bignum_add_unsigned(bignum* x_, bignum* y_, int negative_p) {
GC_BIGNUM(x);
GC_BIGNUM(y);
data_root<bignum> x(x_, this);
data_root<bignum> y(y_, this);
if ((BIGNUM_LENGTH(y)) > (BIGNUM_LENGTH(x))) { if ((BIGNUM_LENGTH(y)) > (BIGNUM_LENGTH(x))) {
std::swap(x, y); swap(x, y);
} }
{ {
bignum_length_type x_length = (BIGNUM_LENGTH(x)); bignum_length_type x_length = (BIGNUM_LENGTH(x));
@ -520,7 +521,7 @@ bignum* factor_vm::bignum_add_unsigned(bignum* x, bignum* y, int negative_p) {
} }
} }
{ {
bignum_digit_type* end_x = ((BIGNUM_START_PTR(x)) + x_length); bignum_digit_type* end_x = BIGNUM_START_PTR(x) + x_length;
if (carry != 0) if (carry != 0)
while (scan_x < end_x) { while (scan_x < end_x) {
sum = ((*scan_x++) + 1); sum = ((*scan_x++) + 1);
@ -545,17 +546,17 @@ bignum* factor_vm::bignum_add_unsigned(bignum* x, bignum* y, int negative_p) {
/* Subtraction */ /* Subtraction */
/* Allocates memory */ /* Allocates memory */
bignum* factor_vm::bignum_subtract_unsigned(bignum* x, bignum* y) { bignum* factor_vm::bignum_subtract_unsigned(bignum* x_, bignum* y_) {
GC_BIGNUM(x);
GC_BIGNUM(y); data_root<bignum> x(x_, this);
data_root<bignum> y(y_, this);
int negative_p = 0; int negative_p = 0;
switch (bignum_compare_unsigned(x, y)) { switch (bignum_compare_unsigned(x.untagged(), y.untagged())) {
case bignum_comparison_equal: case bignum_comparison_equal:
return (BIGNUM_ZERO()); return (BIGNUM_ZERO());
case bignum_comparison_less: { case bignum_comparison_less:
std::swap(x, y); swap(x, y);
}
negative_p = 1; negative_p = 1;
break; break;
case bignum_comparison_greater: case bignum_comparison_greater:
@ -569,10 +570,10 @@ bignum* factor_vm::bignum_subtract_unsigned(bignum* x, bignum* y) {
bignum_digit_type difference; bignum_digit_type difference;
bignum_digit_type borrow = 0; bignum_digit_type borrow = 0;
bignum_digit_type* scan_x = (BIGNUM_START_PTR(x)); bignum_digit_type* scan_x = BIGNUM_START_PTR(x);
bignum_digit_type* scan_r = (BIGNUM_START_PTR(r)); bignum_digit_type* scan_r = BIGNUM_START_PTR(r);
{ {
bignum_digit_type* scan_y = (BIGNUM_START_PTR(y)); bignum_digit_type* scan_y = BIGNUM_START_PTR(y);
bignum_digit_type* end_y = (scan_y + (BIGNUM_LENGTH(y))); bignum_digit_type* end_y = (scan_y + (BIGNUM_LENGTH(y)));
while (scan_y < end_y) { while (scan_y < end_y) {
difference = (((*scan_x++) - (*scan_y++)) - borrow); difference = (((*scan_x++) - (*scan_y++)) - borrow);
@ -586,7 +587,7 @@ bignum* factor_vm::bignum_subtract_unsigned(bignum* x, bignum* y) {
} }
} }
{ {
bignum_digit_type* end_x = ((BIGNUM_START_PTR(x)) + x_length); bignum_digit_type* end_x = BIGNUM_START_PTR(x) + x_length;
if (borrow != 0) if (borrow != 0)
while (scan_x < end_x) { while (scan_x < end_x) {
difference = ((*scan_x++) - borrow); difference = ((*scan_x++) - borrow);
@ -613,13 +614,14 @@ bignum* factor_vm::bignum_subtract_unsigned(bignum* x, bignum* y) {
where R == BIGNUM_RADIX_ROOT */ where R == BIGNUM_RADIX_ROOT */
/* Allocates memory */ /* Allocates memory */
bignum* factor_vm::bignum_multiply_unsigned(bignum* x, bignum* y, bignum* factor_vm::bignum_multiply_unsigned(bignum* x_, bignum* y_,
int negative_p) { int negative_p) {
GC_BIGNUM(x);
GC_BIGNUM(y);
if ((BIGNUM_LENGTH(y)) > (BIGNUM_LENGTH(x))) { data_root<bignum> x(x_, this);
std::swap(x, y); data_root<bignum> y(y_, this);
if (BIGNUM_LENGTH(x) > BIGNUM_LENGTH(y)) {
swap(x, y);
} }
{ {
bignum_digit_type carry; bignum_digit_type carry;
@ -630,14 +632,14 @@ bignum* factor_vm::bignum_multiply_unsigned(bignum* x, bignum* y,
bignum_digit_type product_low; bignum_digit_type product_low;
bignum_digit_type* scan_r; bignum_digit_type* scan_r;
bignum_digit_type* scan_y; bignum_digit_type* scan_y;
bignum_length_type x_length = (BIGNUM_LENGTH(x)); bignum_length_type x_length = BIGNUM_LENGTH(x);
bignum_length_type y_length = (BIGNUM_LENGTH(y)); bignum_length_type y_length = BIGNUM_LENGTH(y);
bignum* r = (allot_bignum_zeroed((x_length + y_length), negative_p)); bignum* r = (allot_bignum_zeroed((x_length + y_length), negative_p));
bignum_digit_type* scan_x = (BIGNUM_START_PTR(x)); bignum_digit_type* scan_x = BIGNUM_START_PTR(x);
bignum_digit_type* end_x = (scan_x + x_length); bignum_digit_type* end_x = (scan_x + x_length);
bignum_digit_type* start_y = (BIGNUM_START_PTR(y)); bignum_digit_type* start_y = BIGNUM_START_PTR(y);
bignum_digit_type* end_y = (start_y + y_length); bignum_digit_type* end_y = (start_y + y_length);
bignum_digit_type* start_r = (BIGNUM_START_PTR(r)); bignum_digit_type* start_r = (BIGNUM_START_PTR(r));
#define x_digit x_digit_high #define x_digit x_digit_high
@ -672,16 +674,16 @@ bignum* factor_vm::bignum_multiply_unsigned(bignum* x, bignum* y,
} }
/* Allocates memory */ /* Allocates memory */
bignum* factor_vm::bignum_multiply_unsigned_small_factor(bignum* x, bignum* factor_vm::bignum_multiply_unsigned_small_factor(bignum* x_,
bignum_digit_type y, bignum_digit_type y,
int negative_p) { int negative_p) {
GC_BIGNUM(x); data_root<bignum> x(x_, this);
bignum_length_type length_x = (BIGNUM_LENGTH(x)); bignum_length_type length_x = (BIGNUM_LENGTH(x));
bignum* p = (allot_bignum((length_x + 1), negative_p)); bignum* p = (allot_bignum((length_x + 1), negative_p));
bignum_destructive_copy(x, p); bignum_destructive_copy(x.untagged(), p);
(BIGNUM_REF(p, length_x)) = 0; (BIGNUM_REF(p, length_x)) = 0;
bignum_destructive_scale_up(p, y); bignum_destructive_scale_up(p, y);
return (bignum_trim(p)); return (bignum_trim(p));
@ -741,24 +743,25 @@ void factor_vm::bignum_destructive_scale_up(bignum* bn,
/* Allocates memory */ /* Allocates memory */
void factor_vm::bignum_divide_unsigned_large_denominator( void factor_vm::bignum_divide_unsigned_large_denominator(
bignum* numerator, bignum* denominator, bignum** quotient, bignum* numerator_, bignum* denominator_, bignum** quotient,
bignum** remainder, int q_negative_p, int r_negative_p) { bignum** remainder, int q_negative_p, int r_negative_p) {
GC_BIGNUM(numerator);
GC_BIGNUM(denominator); data_root<bignum> numerator(numerator_, this);
data_root<bignum> denominator(denominator_, this);
bignum_length_type length_n = ((BIGNUM_LENGTH(numerator)) + 1); bignum_length_type length_n = ((BIGNUM_LENGTH(numerator)) + 1);
bignum_length_type length_d = (BIGNUM_LENGTH(denominator)); bignum_length_type length_d = (BIGNUM_LENGTH(denominator));
bignum *q = NULL; bignum *q_ = NULL;
if (quotient != ((bignum**)0)) { if (quotient != ((bignum**)0)) {
q = allot_bignum(length_n - length_d, q_negative_p); q_ = allot_bignum(length_n - length_d, q_negative_p);
} else { } else {
q = BIGNUM_OUT_OF_BAND; q_ = BIGNUM_OUT_OF_BAND;
} }
GC_BIGNUM(q);
bignum* u = allot_bignum(length_n, r_negative_p); data_root<bignum> q(q_, this);
GC_BIGNUM(u);
data_root<bignum> u(allot_bignum(length_n, r_negative_p), this);
int shift = 0; int shift = 0;
BIGNUM_ASSERT(length_d > 1); BIGNUM_ASSERT(length_d > 1);
@ -770,29 +773,36 @@ void factor_vm::bignum_divide_unsigned_large_denominator(
} }
} }
if (shift == 0) { if (shift == 0) {
bignum_destructive_copy(numerator, u); bignum_destructive_copy(numerator.untagged(), u.untagged());
(BIGNUM_REF(u, (length_n - 1))) = 0; (BIGNUM_REF(u, (length_n - 1))) = 0;
bignum_divide_unsigned_normalized(u, denominator, q); bignum_divide_unsigned_normalized(u.untagged(),
denominator.untagged(),
q.untagged());
} else { } else {
bignum* v = (allot_bignum(length_d, 0)); bignum* v = (allot_bignum(length_d, 0));
bignum_destructive_normalization(numerator, u, shift); bignum_destructive_normalization(numerator.untagged(),
bignum_destructive_normalization(denominator, v, shift); u.untagged(),
bignum_divide_unsigned_normalized(u, v, q); shift);
bignum_destructive_normalization(denominator.untagged(),
v,
shift);
bignum_divide_unsigned_normalized(u.untagged(), v, q.untagged());
if (remainder != ((bignum**)0)) if (remainder != ((bignum**)0))
bignum_destructive_unnormalization(u, shift); bignum_destructive_unnormalization(u.untagged(), shift);
} }
if (q) if (q.untagged()) {
q = bignum_trim(q); q = bignum_trim(q.untagged());
}
u = bignum_trim(u); u = bignum_trim(u.untagged());
if (quotient != ((bignum**)0)) if (quotient != ((bignum**)0))
(*quotient) = q; (*quotient) = q.untagged();
if (remainder != ((bignum**)0)) if (remainder != ((bignum**)0))
(*remainder) = u; (*remainder) = u.untagged();
return; return;
} }
@ -1298,19 +1308,19 @@ void factor_vm::bignum_destructive_copy(bignum* source, bignum* target) {
*/ */
/* Allocates memory */ /* Allocates memory */
bignum* factor_vm::bignum_bitwise_not(bignum* x) { bignum* factor_vm::bignum_bitwise_not(bignum* x_) {
GC_BIGNUM(x);
bignum_length_type size = BIGNUM_LENGTH(x);
bignum_digit_type* scan_x, *end_x, *scan_y;
bignum* y;
int carry = 1; int carry = 1;
bignum_length_type size = BIGNUM_LENGTH(x_);
int is_negative = BIGNUM_NEGATIVE_P(x_);
data_root<bignum> x(x_, this);
data_root<bignum> y(allot_bignum(size, is_negative ? 0 : 1), this);
if (BIGNUM_NEGATIVE_P(x)) { bignum_digit_type* scan_x = BIGNUM_START_PTR(x);
y = allot_bignum(size, 0); bignum_digit_type* end_x = scan_x + size;
scan_x = BIGNUM_START_PTR(x); bignum_digit_type* scan_y = BIGNUM_START_PTR(y);
end_x = scan_x + size;
scan_y = BIGNUM_START_PTR(y); if (is_negative) {
while (scan_x < end_x) { while (scan_x < end_x) {
if (*scan_x == 0) { if (*scan_x == 0) {
*scan_y++ = BIGNUM_RADIX - 1; *scan_y++ = BIGNUM_RADIX - 1;
@ -1322,10 +1332,6 @@ bignum* factor_vm::bignum_bitwise_not(bignum* x) {
} }
} }
} else { } else {
y = allot_bignum(size, 1);
scan_x = BIGNUM_START_PTR(x);
end_x = scan_x + size;
scan_y = BIGNUM_START_PTR(y);
while (scan_x < end_x) { while (scan_x < end_x) {
if (*scan_x == (BIGNUM_RADIX - 1)) { if (*scan_x == (BIGNUM_RADIX - 1)) {
*scan_y++ = 0; *scan_y++ = 0;
@ -1343,14 +1349,13 @@ bignum* factor_vm::bignum_bitwise_not(bignum* x) {
} }
if (carry) { if (carry) {
GC_BIGNUM(y); bignum* ret = allot_bignum(size + 1, BIGNUM_NEGATIVE_P(y));
x = allot_bignum(size + 1, BIGNUM_NEGATIVE_P(y)); bignum_destructive_copy(y.untagged(), ret);
bignum_destructive_copy(y, x); bignum_digit_type* ret_start = BIGNUM_START_PTR(ret);
scan_x = BIGNUM_START_PTR(x); *(ret_start + size) = 1;
*(scan_x + size) = 1; return ret;
return x;
} else { } else {
return bignum_trim(y); return bignum_trim(y.untagged());
} }
} }
@ -1678,51 +1683,28 @@ int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bn) {
} }
#ifdef _WIN64 #ifdef _WIN64
/* Allocates memory */ /* Allocates memory. Needs to be fixed, mutates parameters. */
bignum* factor_vm::bignum_gcd(bignum* a, bignum* b) { bignum* factor_vm::bignum_gcd(bignum* a_, bignum* b_) {
GC_BIGNUM(a);
GC_BIGNUM(b);
bignum* d;
bignum_length_type size_a, size_b;
bignum_digit_type* scan_a, *scan_b, *scan_d, *a_end, *b_end;
if (BIGNUM_NEGATIVE_P(a)) { data_root<bignum> a(a_, this);
size_a = BIGNUM_LENGTH(a); data_root<bignum> b(b_, this);
d = allot_bignum(size_a, 0);
scan_d = BIGNUM_START_PTR(d);
scan_a = BIGNUM_START_PTR(a);
a_end = scan_a + size_a;
while (scan_a < a_end)
(*scan_d++) = (*scan_a++);
a = d;
}
if (BIGNUM_NEGATIVE_P(b)) { BIGNUM_SET_NEGATIVE_P(a, 0);
size_b = BIGNUM_LENGTH(b); BIGNUM_SET_NEGATIVE_P(b, 0);
d = allot_bignum(size_b, 0);
scan_d = BIGNUM_START_PTR(d);
scan_b = BIGNUM_START_PTR(b);
b_end = scan_b + size_b;
while (scan_b < b_end)
(*scan_d++) = (*scan_b++);
b = d;
}
if (bignum_compare(a, b) == bignum_comparison_less) { if (bignum_compare(a.untagged(), b.untagged()) == bignum_comparison_less) {
std::swap(a, b); swap(a, b);
} }
while (BIGNUM_LENGTH(b) != 0) { while (BIGNUM_LENGTH(b) != 0) {
d = bignum_remainder(a, b); data_root<bignum> d(bignum_remainder(a.untagged(), b.untagged()), this);
GC_BIGNUM(d); if (d.untagged() == BIGNUM_OUT_OF_BAND) {
if (d == BIGNUM_OUT_OF_BAND) { return d.untagged();
return d;
} }
a = b; a.replace_value(b.value());
b = d; b.replace_value(d.value());
} }
return a.untagged();
return a;
} }
#else #else
/* Allocates memory */ /* Allocates memory */

10
vm/vm.hpp
View File

@ -233,7 +233,7 @@ struct factor_vm {
enum bignum_comparison bignum_compare(bignum* x, bignum* y); enum bignum_comparison bignum_compare(bignum* x, bignum* y);
bignum* bignum_add(bignum* x, bignum* y); bignum* bignum_add(bignum* x, bignum* y);
bignum* bignum_subtract(bignum* x, bignum* y); bignum* bignum_subtract(bignum* x, bignum* y);
bignum* bignum_square(bignum* x); bignum* bignum_square(bignum* x_);
bignum* bignum_multiply(bignum* x, bignum* y); bignum* bignum_multiply(bignum* x, bignum* y);
void bignum_divide(bignum* numerator, bignum* denominator, bignum** quotient, void bignum_divide(bignum* numerator, bignum* denominator, bignum** quotient,
bignum** remainder); bignum** remainder);
@ -247,9 +247,9 @@ struct factor_vm {
bignum* double_to_bignum(double x); bignum* double_to_bignum(double x);
int bignum_equal_p_unsigned(bignum* x, bignum* y); int bignum_equal_p_unsigned(bignum* x, bignum* y);
enum bignum_comparison bignum_compare_unsigned(bignum* x, bignum* y); enum bignum_comparison bignum_compare_unsigned(bignum* x, bignum* y);
bignum* bignum_add_unsigned(bignum* x, bignum* y, int negative_p); bignum* bignum_add_unsigned(bignum* x_, bignum* y_, int negative_p);
bignum* bignum_subtract_unsigned(bignum* x, bignum* y); bignum* bignum_subtract_unsigned(bignum* x_, bignum* y_);
bignum* bignum_multiply_unsigned(bignum* x, bignum* y, int negative_p); bignum* bignum_multiply_unsigned(bignum* x_, bignum* y_, int negative_p);
bignum* bignum_multiply_unsigned_small_factor(bignum* x, bignum_digit_type y, bignum* bignum_multiply_unsigned_small_factor(bignum* x, bignum_digit_type y,
int negative_p); int negative_p);
void bignum_destructive_add(bignum* bn, bignum_digit_type n); void bignum_destructive_add(bignum* bn, bignum_digit_type n);
@ -291,7 +291,7 @@ struct factor_vm {
bignum* bignum_new_sign(bignum* x, int negative_p); bignum* bignum_new_sign(bignum* x, int negative_p);
bignum* bignum_maybe_new_sign(bignum* x, int negative_p); bignum* bignum_maybe_new_sign(bignum* x, int negative_p);
void bignum_destructive_copy(bignum* source, bignum* target); void bignum_destructive_copy(bignum* source, bignum* target);
bignum* bignum_bitwise_not(bignum* x); bignum* bignum_bitwise_not(bignum* x_);
bignum* bignum_arithmetic_shift(bignum* arg1, fixnum n); bignum* bignum_arithmetic_shift(bignum* arg1, fixnum n);
bignum* bignum_bitwise_and(bignum* arg1, bignum* arg2); bignum* bignum_bitwise_and(bignum* arg1, bignum* arg2);
bignum* bignum_bitwise_ior(bignum* arg1, bignum* arg2); bignum* bignum_bitwise_ior(bignum* arg1, bignum* arg2);