kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* bignum.c (BDIGITS_ZERO): Defined.

Browse source 
(bary_pack): Use BDIGITS_ZERO.
  (bary_unpack): Ditto.
  (bary_mul_single): Ditto.
  (bary_mul_normal): Ditto.
  (bary_sq_fast): Ditto.
  (bary_mul_balance_with_mulfunc): Ditto.
  (bary_mul_precheck): Ditto.
  (bary_mul_toom3_branch): Ditto.
  (rb_cstr_to_inum): Ditto.
  (big_shift3): Ditto.
  (bigmul1_toom3): Ditto.
  (bary_divmod): Ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42032 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2013-07-18 04:00:49 +00:00
parent 7d9bae8b5a
commit 80afc9b2f3
2 changed files with 49 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

16
ChangeLog
View file

@ -1,3 +1,19 @@
Thu Jul 18 12:57:47 2013 Tanaka Akira <akr@fsij.org>
* bignum.c (BDIGITS_ZERO): Defined.
(bary_pack): Use BDIGITS_ZERO.
(bary_unpack): Ditto.
(bary_mul_single): Ditto.
(bary_mul_normal): Ditto.
(bary_sq_fast): Ditto.
(bary_mul_balance_with_mulfunc): Ditto.
(bary_mul_precheck): Ditto.
(bary_mul_toom3_branch): Ditto.
(rb_cstr_to_inum): Ditto.
(big_shift3): Ditto.
(bigmul1_toom3): Ditto.
(bary_divmod): Ditto.
Thu Jul 18 06:30:02 2013 Koichi Sasada <ko1@atdot.net> Thu Jul 18 06:30:02 2013 Koichi Sasada <ko1@atdot.net>
* gc.c: rename gc related functions with prefix "gc_". * gc.c: rename gc related functions with prefix "gc_".

57
bignum.c
View file

@ -112,6 +112,15 @@ STATIC_ASSERT(sizeof_long_and_sizeof_bdigit, SIZEOF_BDIGITS % SIZEOF_LONG == 0);
#define bignew(len,sign) bignew_1(rb_cBignum,(len),(sign)) #define bignew(len,sign) bignew_1(rb_cBignum,(len),(sign))
#define BDIGITS_ZERO(ptr, n) do { \
BDIGIT *bdigitz_zero_ptr = (ptr); \
size_t bdigitz_zero_n = (n); \
while (bdigitz_zero_n) { \
*bdigitz_zero_ptr++ = 0; \
bdigitz_zero_n--; \
} \
} while (0)
#define KARATSUBA_MUL_DIGITS 70 #define KARATSUBA_MUL_DIGITS 70
#define TOOM3_MUL_DIGITS 150 #define TOOM3_MUL_DIGITS 150
@ -839,7 +848,7 @@ bary_pack(int sign, BDIGIT *ds, size_t num_bdigits, void *words, size_t numwords
(flags & INTEGER_PACK_MSBYTE_FIRST) != 0; (flags & INTEGER_PACK_MSBYTE_FIRST) != 0;
if (src_num_bdigits <= dst_num_bdigits) { if (src_num_bdigits <= dst_num_bdigits) {
MEMCPY(words, dp, BDIGIT, src_num_bdigits); MEMCPY(words, dp, BDIGIT, src_num_bdigits);
MEMZERO((BDIGIT*)words + src_num_bdigits, BDIGIT, dst_num_bdigits - src_num_bdigits); BDIGITS_ZERO((BDIGIT*)words + src_num_bdigits, dst_num_bdigits - src_num_bdigits);
} }
else { else {
MEMCPY(words, dp, BDIGIT, dst_num_bdigits); MEMCPY(words, dp, BDIGIT, dst_num_bdigits);
@ -1376,7 +1385,7 @@ bary_unpack(BDIGIT *bdigits, size_t num_bdigits, const void *words, size_t numwo
sign = bary_unpack_internal(bdigits, num_bdigits0, words, numwords, wordsize, nails, flags, nlp_bits); sign = bary_unpack_internal(bdigits, num_bdigits0, words, numwords, wordsize, nails, flags, nlp_bits);
if (num_bdigits0 < num_bdigits) { if (num_bdigits0 < num_bdigits) {
MEMZERO(bdigits + num_bdigits0, BDIGIT, num_bdigits - num_bdigits0); BDIGITS_ZERO(bdigits + num_bdigits0, num_bdigits - num_bdigits0);
if (sign == -2) { if (sign == -2) {
bdigits[num_bdigits0] = 1; bdigits[num_bdigits0] = 1;
} }
@ -1521,7 +1530,7 @@ bary_mul_single(BDIGIT *zds, size_t zl, BDIGIT x, BDIGIT y)
zds[0] = BIGLO(n); zds[0] = BIGLO(n);
zds[1] = (BDIGIT)BIGDN(n); zds[1] = (BDIGIT)BIGDN(n);
MEMZERO(zds + 2, BDIGIT, zl - 2); BDIGITS_ZERO(zds + 2, zl - 2);
} }
static int static int
@ -1566,7 +1575,7 @@ bary_mul_normal(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, siz
assert(xl + yl <= zl); assert(xl + yl <= zl);
MEMZERO(zds, BDIGIT, zl); BDIGITS_ZERO(zds, zl);
for (i = 0; i < xl; i++) { for (i = 0; i < xl; i++) {
bary_muladd_1xN(zds+i, zl-i, xds[i], yds, yl); bary_muladd_1xN(zds+i, zl-i, xds[i], yds, yl);
} }
@ -1595,7 +1604,7 @@ bary_sq_fast(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn)
assert(xn * 2 <= zn); assert(xn * 2 <= zn);
MEMZERO(zds, BDIGIT, zn); BDIGITS_ZERO(zds, zn);
for (i = 0; i < xn; i++) { for (i = 0; i < xn; i++) {
v = (BDIGIT_DBL)xds[i]; v = (BDIGIT_DBL)xds[i];
if (!v) if (!v)
@ -1644,7 +1653,7 @@ bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BD
assert(xl + yl <= zl); assert(xl + yl <= zl);
assert(2 * xl <= yl || 3 * xl <= 2*(yl+2)); assert(2 * xl <= yl || 3 * xl <= 2*(yl+2));
MEMZERO(zds, BDIGIT, xl); BDIGITS_ZERO(zds, xl);
n = 0; n = 0;
while (yl > 0) { while (yl > 0) {
@ -1655,7 +1664,7 @@ bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BD
if (2 * (xl + r) <= zl - n) { if (2 * (xl + r) <= zl - n) {
tds = zds + n + xl + r; tds = zds + n + xl + r;
mulfunc(tds, tl, xds, xl, yds + n, r, wds, wl); mulfunc(tds, tl, xds, xl, yds + n, r, wds, wl);
MEMZERO(zds + n + xl, BDIGIT, r); BDIGITS_ZERO(zds + n + xl, r);
bary_add(zds + n, tl, bary_add(zds + n, tl,
zds + n, tl, zds + n, tl,
tds, tl); tds, tl);
@ -1675,7 +1684,7 @@ bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BD
yl -= r; yl -= r;
n += r; n += r;
} }
MEMZERO(zds+xl+yl0, BDIGIT, zl - (xl+yl0)); BDIGITS_ZERO(zds+xl+yl0, zl - (xl+yl0));
if (work) if (work)
ALLOCV_END(work); ALLOCV_END(work);
@ -1952,7 +1961,7 @@ bary_mul_precheck(BDIGIT **zdsp, size_t *zlp, BDIGIT **xdsp, size_t *xlp, BDIGIT
} }
if (nlsz) { if (nlsz) {
MEMZERO(zds, BDIGIT, nlsz); BDIGITS_ZERO(zds, nlsz);
zds += nlsz; zds += nlsz;
zl -= nlsz; zl -= nlsz;
} }
@ -1968,23 +1977,23 @@ bary_mul_precheck(BDIGIT **zdsp, size_t *zlp, BDIGIT **xdsp, size_t *xlp, BDIGIT
if (xl <= 1) { if (xl <= 1) {
if (xl == 0) { if (xl == 0) {
MEMZERO(zds, BDIGIT, zl); BDIGITS_ZERO(zds, zl);
return 1; return 1;
} }
if (xds[0] == 1) { if (xds[0] == 1) {
MEMCPY(zds, yds, BDIGIT, yl); MEMCPY(zds, yds, BDIGIT, yl);
MEMZERO(zds+yl, BDIGIT, zl-yl); BDIGITS_ZERO(zds+yl, zl-yl);
return 1; return 1;
} }
if (POW2_P(xds[0])) { if (POW2_P(xds[0])) {
zds[yl] = bary_small_lshift(zds, yds, yl, bitsize(xds[0])-1); zds[yl] = bary_small_lshift(zds, yds, yl, bitsize(xds[0])-1);
MEMZERO(zds+yl+1, BDIGIT, zl-yl-1); BDIGITS_ZERO(zds+yl+1, zl-yl-1);
return 1; return 1;
} }
if (yl == 1 && yds[0] == 1) { if (yl == 1 && yds[0] == 1) {
zds[0] = xds[0]; zds[0] = xds[0];
MEMZERO(zds+1, BDIGIT, zl-1); BDIGITS_ZERO(zds+1, zl-1);
return 1; return 1;
} }
bary_mul_normal(zds, zl, xds, xl, yds, yl); bary_mul_normal(zds, zl, xds, xl, yds, yl);
@ -2066,7 +2075,7 @@ bary_mul_toom3_branch(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yd
} }
z = bigtrunc(bigmul1_toom3(x, y)); z = bigtrunc(bigmul1_toom3(x, y));
MEMCPY(zds, BDIGITS(z), BDIGIT, RBIGNUM_LEN(z)); MEMCPY(zds, BDIGITS(z), BDIGIT, RBIGNUM_LEN(z));
MEMZERO(zds + RBIGNUM_LEN(z), BDIGIT, zl - RBIGNUM_LEN(z)); BDIGITS_ZERO(zds + RBIGNUM_LEN(z), zl - RBIGNUM_LEN(z));
RB_GC_GUARD(z); RB_GC_GUARD(z);
} }
} }
@ -3097,7 +3106,7 @@ rb_cstr_to_inum(const char *str, int base, int badcheck)
z = bignew(num_bdigits, sign); z = bignew(num_bdigits, sign);
zds = BDIGITS(z); zds = BDIGITS(z);
MEMZERO(zds, BDIGIT, num_bdigits); BDIGITS_ZERO(zds, num_bdigits);
for (p = digits_start; p < digits_end; p++) { for (p = digits_start; p < digits_end; p++) {
if ((c = conv_digit(*p)) < 0) if ((c = conv_digit(*p)) < 0)
@ -3314,7 +3323,7 @@ big_shift3(VALUE x, int lshift_p, size_t shift_numdigits, int shift_numbits)
xn = RBIGNUM_LEN(x); xn = RBIGNUM_LEN(x);
z = bignew(xn+s1+1, RBIGNUM_SIGN(x)); z = bignew(xn+s1+1, RBIGNUM_SIGN(x));
zds = BDIGITS(z); zds = BDIGITS(z);
MEMZERO(zds, BDIGIT, s1); BDIGITS_ZERO(zds, s1);
xds = BDIGITS(x); xds = BDIGITS(x);
zds[xn+s1] = bary_small_lshift(zds+s1, xds, xn, s2); zds[xn+s1] = bary_small_lshift(zds+s1, xds, xn, s2);
} }
@ -4809,7 +4818,7 @@ bigmul1_toom3(VALUE x, VALUE y)
z = bignew(zn, RBIGNUM_SIGN(x)==RBIGNUM_SIGN(y)); z = bignew(zn, RBIGNUM_SIGN(x)==RBIGNUM_SIGN(y));
zds = BDIGITS(z); zds = BDIGITS(z);
MEMCPY(zds, BDIGITS(z0), BDIGIT, RBIGNUM_LEN(z0)); MEMCPY(zds, BDIGITS(z0), BDIGIT, RBIGNUM_LEN(z0));
MEMZERO(zds + RBIGNUM_LEN(z0), BDIGIT, zn - RBIGNUM_LEN(z0)); BDIGITS_ZERO(zds + RBIGNUM_LEN(z0), zn - RBIGNUM_LEN(z0));
bigadd_core(zds + n, zn - n, BDIGITS(z1), big_real_len(z1), zds + n, zn - n); bigadd_core(zds + n, zn - n, BDIGITS(z1), big_real_len(z1), zds + n, zn - n);
bigadd_core(zds + 2*n, zn - 2*n, BDIGITS(z2), big_real_len(z2), zds + 2*n, zn - 2*n); bigadd_core(zds + 2*n, zn - 2*n, BDIGITS(z2), big_real_len(z2), zds + 2*n, zn - 2*n);
bigadd_core(zds + 3*n, zn - 3*n, BDIGITS(z3), big_real_len(z3), zds + 3*n, zn - 3*n); bigadd_core(zds + 3*n, zn - 3*n, BDIGITS(z3), big_real_len(z3), zds + 3*n, zn - 3*n);
@ -5016,16 +5025,16 @@ bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, BDIGIT *xds, size_t
while (0 < nx && !xds[nx-1]) nx--; while (0 < nx && !xds[nx-1]) nx--;
if (nx == 0) { if (nx == 0) {
MEMZERO(qds, BDIGIT, nq); BDIGITS_ZERO(qds, nq);
MEMZERO(rds, BDIGIT, nr); BDIGITS_ZERO(rds, nr);
return; return;
} }
if (ny == 1) { if (ny == 1) {
MEMCPY(qds, xds, BDIGIT, nx); MEMCPY(qds, xds, BDIGIT, nx);
MEMZERO(qds+nx, BDIGIT, nq-nx); BDIGITS_ZERO(qds+nx, nq-nx);
rds[0] = bigdivrem_single(qds, xds, nx, yds[0]); rds[0] = bigdivrem_single(qds, xds, nx, yds[0]);
MEMZERO(rds+1, BDIGIT, nr-1); BDIGITS_ZERO(rds+1, nr-1);
} }
else { else {
int extra_words; int extra_words;
@ -5042,7 +5051,7 @@ bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, BDIGIT *xds, size_t
else else
zds = ALLOCV_N(BDIGIT, tmpz, nx + extra_words); zds = ALLOCV_N(BDIGIT, tmpz, nx + extra_words);
MEMCPY(zds, xds, BDIGIT, nx); MEMCPY(zds, xds, BDIGIT, nx);
MEMZERO(zds+nx, BDIGIT, nz-nx); BDIGITS_ZERO(zds+nx, nz-nx);
if (BDIGIT_MSB(yds[ny-1])) { if (BDIGIT_MSB(yds[ny-1])) {
/* bigdivrem_normal will not modify y. /* bigdivrem_normal will not modify y.
@ -5060,12 +5069,12 @@ bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, BDIGIT *xds, size_t
/* copy remainder */ /* copy remainder */
MEMCPY(rds, zds, BDIGIT, ny); MEMCPY(rds, zds, BDIGIT, ny);
MEMZERO(rds+ny, BDIGIT, nr-ny); BDIGITS_ZERO(rds+ny, nr-ny);
/* move quotient */ /* move quotient */
j = nz - ny; j = nz - ny;
MEMMOVE(qds, zds+ny, BDIGIT, j); MEMMOVE(qds, zds+ny, BDIGIT, j);
MEMZERO(qds+j, BDIGIT, nq-j); BDIGITS_ZERO(qds+j, nq-j);
if (tmpz) if (tmpz)
ALLOCV_END(tmpz); ALLOCV_END(tmpz);