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: Constify bary_* functions.

Browse source 
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42209 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2013-07-28 03:12:36 +00:00
parent e5ff9d58ef
commit aecf007782
2 changed files with 46 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ChangeLog
View file

@ -1,3 +1,7 @@
Sun Jul 28 12:03:23 2013 Tanaka Akira <akr@fsij.org>
* bignum.c: Constify bary_* functions.
Sun Jul 28 11:12:07 2013 Tanaka Akira <akr@fsij.org> Sun Jul 28 11:12:07 2013 Tanaka Akira <akr@fsij.org>
* include/ruby/intern.h (rb_absint_size): Declaration moved from * include/ruby/intern.h (rb_absint_size): Declaration moved from

83
bignum.c
View file

@ -127,15 +127,15 @@ STATIC_ASSERT(sizeof_long_and_sizeof_bdigit, SIZEOF_BDIGITS % SIZEOF_LONG == 0);
#define KARATSUBA_MUL_DIGITS 70 #define KARATSUBA_MUL_DIGITS 70
#define TOOM3_MUL_DIGITS 150 #define TOOM3_MUL_DIGITS 150
typedef void (mulfunc_t)(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl); typedef void (mulfunc_t)(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl);
static mulfunc_t bary_mul_toom3_start; static mulfunc_t bary_mul_toom3_start;
static mulfunc_t bary_mul_karatsuba_start; static mulfunc_t bary_mul_karatsuba_start;
static BDIGIT bigdivrem_single(BDIGIT *qds, BDIGIT *xds, long nx, BDIGIT y); static BDIGIT bigdivrem_single(BDIGIT *qds, const BDIGIT *xds, long nx, BDIGIT y);
static void bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, BDIGIT *xds, size_t nx, BDIGIT *yds, size_t ny); static void bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, const BDIGIT *xds, size_t nx, const BDIGIT *yds, size_t ny);
static VALUE bigmul0(VALUE x, VALUE y); static VALUE bigmul0(VALUE x, VALUE y);
static void bary_mul_toom3(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn, BDIGIT *wds, size_t wn); static void bary_mul_toom3(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn, BDIGIT *wds, size_t wn);
static VALUE bignew_1(VALUE klass, long len, int sign); static VALUE bignew_1(VALUE klass, long len, int sign);
static inline VALUE bigtrunc(VALUE x); static inline VALUE bigtrunc(VALUE x);
@ -482,7 +482,7 @@ maxpow_in_bdigit(int base, int *exp_ret)
} }
static BDIGIT static BDIGIT
bary_small_lshift(BDIGIT *zds, BDIGIT *xds, size_t n, int shift) bary_small_lshift(BDIGIT *zds, const BDIGIT *xds, size_t n, int shift)
{ {
size_t i; size_t i;
BDIGIT_DBL num = 0; BDIGIT_DBL num = 0;
@ -497,7 +497,7 @@ bary_small_lshift(BDIGIT *zds, BDIGIT *xds, size_t n, int shift)
} }
static void static void
bary_small_rshift(BDIGIT *zds, BDIGIT *xds, size_t n, int shift, int sign_bit) bary_small_rshift(BDIGIT *zds, const BDIGIT *xds, size_t n, int shift, int sign_bit)
{ {
BDIGIT_DBL num = 0; BDIGIT_DBL num = 0;
BDIGIT x; BDIGIT x;
@ -1396,7 +1396,7 @@ bary_unpack(BDIGIT *bdigits, size_t num_bdigits, const void *words, size_t numwo
} }
static int static int
bary_subb(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn, int borrow) bary_subb(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn, int borrow)
{ {
BDIGIT_DBL_SIGNED num; BDIGIT_DBL_SIGNED num;
size_t i; size_t i;
@ -1447,7 +1447,7 @@ bary_subb(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn
} }
static int static int
bary_sub(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn) bary_sub(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn)
{ {
return bary_subb(zds, zn, xds, xn, yds, yn, 0); return bary_subb(zds, zn, xds, xn, yds, yn, 0);
} }
@ -1459,7 +1459,7 @@ bary_sub_one(BDIGIT *zds, size_t zn)
} }
static int static int
bary_addc(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn, int carry) bary_addc(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn, int carry)
{ {
BDIGIT_DBL num; BDIGIT_DBL num;
size_t i; size_t i;
@ -1468,7 +1468,7 @@ bary_addc(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn
assert(yn <= zn); assert(yn <= zn);
if (xn > yn) { if (xn > yn) {
BDIGIT *tds; const BDIGIT *tds;
tds = xds; xds = yds; yds = tds; tds = xds; xds = yds; yds = tds;
i = xn; xn = yn; yn = i; i = xn; xn = yn; yn = i;
} }
@ -1505,7 +1505,7 @@ bary_addc(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn
} }
static int static int
bary_add(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn) bary_add(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn)
{ {
return bary_addc(zds, zn, xds, xn, yds, yn, 0); return bary_addc(zds, zn, xds, xn, yds, yn, 0);
} }
@ -1537,7 +1537,7 @@ bary_mul_single(BDIGIT *zds, size_t zl, BDIGIT x, BDIGIT y)
} }
static int static int
bary_muladd_1xN(BDIGIT *zds, size_t zl, BDIGIT x, BDIGIT *yds, size_t yl) bary_muladd_1xN(BDIGIT *zds, size_t zl, BDIGIT x, const BDIGIT *yds, size_t yl)
{ {
BDIGIT_DBL n; BDIGIT_DBL n;
BDIGIT_DBL dd; BDIGIT_DBL dd;
@ -1572,7 +1572,7 @@ bary_muladd_1xN(BDIGIT *zds, size_t zl, BDIGIT x, BDIGIT *yds, size_t yl)
} }
static BDIGIT_DBL_SIGNED static BDIGIT_DBL_SIGNED
bigdivrem_mulsub(BDIGIT *zds, size_t zn, BDIGIT x, BDIGIT *yds, size_t yn) bigdivrem_mulsub(BDIGIT *zds, size_t zn, BDIGIT x, const BDIGIT *yds, size_t yn)
{ {
size_t i; size_t i;
BDIGIT_DBL t2; BDIGIT_DBL t2;
@ -1598,7 +1598,7 @@ bigdivrem_mulsub(BDIGIT *zds, size_t zn, BDIGIT x, BDIGIT *yds, size_t yn)
} }
static int static int
bary_mulsub_1xN(BDIGIT *zds, size_t zn, BDIGIT x, BDIGIT *yds, size_t yn) bary_mulsub_1xN(BDIGIT *zds, size_t zn, BDIGIT x, const BDIGIT *yds, size_t yn)
{ {
BDIGIT_DBL_SIGNED num; BDIGIT_DBL_SIGNED num;
@ -1612,7 +1612,7 @@ bary_mulsub_1xN(BDIGIT *zds, size_t zn, BDIGIT x, BDIGIT *yds, size_t yn)
} }
static void static void
bary_mul_normal(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl) bary_mul_normal(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl)
{ {
size_t i; size_t i;
@ -1640,7 +1640,7 @@ rb_big_mul_normal(VALUE x, VALUE y)
* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf * http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
*/ */
static void static void
bary_sq_fast(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn) bary_sq_fast(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn)
{ {
size_t i, j; size_t i, j;
BDIGIT_DBL c, v, w; BDIGIT_DBL c, v, w;
@ -1705,7 +1705,7 @@ rb_big_sq_fast(VALUE x)
/* balancing multiplication by slicing larger argument */ /* balancing multiplication by slicing larger argument */
static void static void
bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl, mulfunc_t *mulfunc) bary_mul_balance_with_mulfunc(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl, mulfunc_t *mulfunc)
{ {
VALUE work = 0; VALUE work = 0;
size_t yl0 = yl; size_t yl0 = yl;
@ -1765,7 +1765,7 @@ rb_big_mul_balance(VALUE x, VALUE y)
/* multiplication by karatsuba method */ /* multiplication by karatsuba method */
static void static void
bary_mul_karatsuba(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl) bary_mul_karatsuba(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl)
{ {
VALUE work = 0; VALUE work = 0;
@ -1776,7 +1776,8 @@ bary_mul_karatsuba(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds,
int odd_xy = 0; int odd_xy = 0;
int sq; int sq;
BDIGIT *xds0, *xds1, *yds0, *yds1, *zds0, *zds1, *zds2, *zds3; const BDIGIT *xds0, *xds1, *yds0, *yds1;
BDIGIT *zds0, *zds1, *zds2, *zds3;
assert(xl + yl <= zl); assert(xl + yl <= zl);
assert(xl <= yl); assert(xl <= yl);
@ -1946,19 +1947,19 @@ rb_big_mul_karatsuba(VALUE x, VALUE y)
} }
static void static void
bary_mul_toom3(BDIGIT *zds, size_t zn, BDIGIT *xds, size_t xn, BDIGIT *yds, size_t yn, BDIGIT *wds, size_t wn) bary_mul_toom3(BDIGIT *zds, size_t zn, const BDIGIT *xds, size_t xn, const BDIGIT *yds, size_t yn, BDIGIT *wds, size_t wn)
{ {
size_t n; size_t n;
size_t wnc; size_t wnc;
VALUE work = 0; VALUE work = 0;
/* "p" means "positive". Actually "non-negative", though. */ /* "p" means "positive". Actually "non-negative", though. */
size_t x0n; BDIGIT *x0ds; size_t x0n; const BDIGIT *x0ds;
size_t x1n; BDIGIT *x1ds; size_t x1n; const BDIGIT *x1ds;
size_t x2n; BDIGIT *x2ds; size_t x2n; const BDIGIT *x2ds;
size_t y0n; BDIGIT *y0ds; size_t y0n; const BDIGIT *y0ds;
size_t y1n; BDIGIT *y1ds; size_t y1n; const BDIGIT *y1ds;
size_t y2n; BDIGIT *y2ds; size_t y2n; const BDIGIT *y2ds;
size_t u1n; BDIGIT *u1ds; int u1p; size_t u1n; BDIGIT *u1ds; int u1p;
size_t u2n; BDIGIT *u2ds; int u2p; size_t u2n; BDIGIT *u2ds; int u2p;
@ -2346,7 +2347,7 @@ rb_big_mul_toom3(VALUE x, VALUE y)
} }
static void static void
bary_mul1(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl) bary_mul1(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl)
{ {
assert(xl + yl <= zl); assert(xl + yl <= zl);
@ -2361,7 +2362,7 @@ bary_mul1(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl
/* determine whether a bignum is sparse or not by random sampling */ /* determine whether a bignum is sparse or not by random sampling */
static inline int static inline int
bary_sparse_p(BDIGIT *ds, size_t n) bary_sparse_p(const BDIGIT *ds, size_t n)
{ {
long c = 0; long c = 0;
@ -2373,15 +2374,15 @@ bary_sparse_p(BDIGIT *ds, size_t n)
} }
static int static int
bary_mul_precheck(BDIGIT **zdsp, size_t *zlp, BDIGIT **xdsp, size_t *xlp, BDIGIT **ydsp, size_t *ylp) bary_mul_precheck(BDIGIT **zdsp, size_t *zlp, const BDIGIT **xdsp, size_t *xlp, const BDIGIT **ydsp, size_t *ylp)
{ {
size_t nlsz; /* number of least significant zero BDIGITs */ size_t nlsz; /* number of least significant zero BDIGITs */
BDIGIT *zds = *zdsp; BDIGIT *zds = *zdsp;
size_t zl = *zlp; size_t zl = *zlp;
BDIGIT *xds = *xdsp; const BDIGIT *xds = *xdsp;
size_t xl = *xlp; size_t xl = *xlp;
BDIGIT *yds = *ydsp; const BDIGIT *yds = *ydsp;
size_t yl = *ylp; size_t yl = *ylp;
assert(xl + yl <= zl); assert(xl + yl <= zl);
@ -2428,7 +2429,7 @@ bary_mul_precheck(BDIGIT **zdsp, size_t *zlp, BDIGIT **xdsp, size_t *xlp, BDIGIT
/* make sure that y is longer than x */ /* make sure that y is longer than x */
if (xl > yl) { if (xl > yl) {
BDIGIT *tds; const BDIGIT *tds;
size_t tl; size_t tl;
tds = xds; xds = yds; yds = tds; tds = xds; xds = yds; yds = tds;
tl = xl; xl = yl; yl = tl; tl = xl; xl = yl; yl = tl;
@ -2471,7 +2472,7 @@ bary_mul_precheck(BDIGIT **zdsp, size_t *zlp, BDIGIT **xdsp, size_t *xlp, BDIGIT
} }
static void static void
bary_mul_karatsuba_branch(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl) bary_mul_karatsuba_branch(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl)
{ {
/* normal multiplication when x is small */ /* normal multiplication when x is small */
if (xl < KARATSUBA_MUL_DIGITS) { if (xl < KARATSUBA_MUL_DIGITS) {
@ -2501,7 +2502,7 @@ bary_mul_karatsuba_branch(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT
} }
static void static void
bary_mul_karatsuba_start(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl) bary_mul_karatsuba_start(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl)
{ {
if (bary_mul_precheck(&zds, &zl, &xds, &xl, &yds, &yl)) if (bary_mul_precheck(&zds, &zl, &xds, &xl, &yds, &yl))
return; return;
@ -2510,7 +2511,7 @@ bary_mul_karatsuba_start(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT
} }
static void static void
bary_mul_toom3_branch(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl) bary_mul_toom3_branch(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl)
{ {
if (yl < TOOM3_MUL_DIGITS) { if (yl < TOOM3_MUL_DIGITS) {
bary_mul_karatsuba_branch(zds, zl, xds, xl, yds, yl, wds, wl); bary_mul_karatsuba_branch(zds, zl, xds, xl, yds, yl, wds, wl);
@ -2526,7 +2527,7 @@ bary_mul_toom3_branch(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yd
} }
static void static void
bary_mul_toom3_start(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl) bary_mul_toom3_start(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl, BDIGIT *wds, size_t wl)
{ {
if (bary_mul_precheck(&zds, &zl, &xds, &xl, &yds, &yl)) if (bary_mul_precheck(&zds, &zl, &xds, &xl, &yds, &yl))
return; return;
@ -2535,7 +2536,7 @@ bary_mul_toom3_start(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds
} }
static void static void
bary_mul(BDIGIT *zds, size_t zl, BDIGIT *xds, size_t xl, BDIGIT *yds, size_t yl) bary_mul(BDIGIT *zds, size_t zl, const BDIGIT *xds, size_t xl, const BDIGIT *yds, size_t yl)
{ {
if (xl < KARATSUBA_MUL_DIGITS || yl < KARATSUBA_MUL_DIGITS) { if (xl < KARATSUBA_MUL_DIGITS || yl < KARATSUBA_MUL_DIGITS) {
if (xds == yds && xl == yl) if (xds == yds && xl == yl)
@ -2606,7 +2607,7 @@ bigdivrem_num_extra_words(long nx, long ny)
} }
static BDIGIT static BDIGIT
bigdivrem_single(BDIGIT *qds, BDIGIT *xds, long nx, BDIGIT y) bigdivrem_single(BDIGIT *qds, const BDIGIT *xds, long nx, BDIGIT y)
{ {
long i; long i;
BDIGIT_DBL t2; BDIGIT_DBL t2;
@ -2621,7 +2622,7 @@ bigdivrem_single(BDIGIT *qds, BDIGIT *xds, long nx, BDIGIT y)
} }
static void static void
bigdivrem_normal(BDIGIT *zds, long nz, BDIGIT *xds, long nx, BDIGIT *yds, long ny, int needs_mod) bigdivrem_normal(BDIGIT *zds, long nz, const BDIGIT *xds, long nx, BDIGIT *yds, long ny, int needs_mod)
{ {
struct big_div_struct bds; struct big_div_struct bds;
BDIGIT q; BDIGIT q;
@ -2666,7 +2667,7 @@ bigdivrem_normal(BDIGIT *zds, long nz, BDIGIT *xds, long nx, BDIGIT *yds, long n
} }
static void static void
bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, BDIGIT *xds, size_t nx, BDIGIT *yds, size_t ny) bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, const BDIGIT *xds, size_t nx, const BDIGIT *yds, size_t ny)
{ {
assert(nx <= nq); assert(nx <= nq);
assert(ny <= nr); assert(ny <= nr);
@ -2725,7 +2726,7 @@ bary_divmod(BDIGIT *qds, size_t nq, BDIGIT *rds, size_t nr, BDIGIT *xds, size_t
if (BDIGIT_MSB(yds[ny-1])) { if (BDIGIT_MSB(yds[ny-1])) {
/* bigdivrem_normal will not modify y. /* bigdivrem_normal will not modify y.
* So use yds directly. */ * So use yds directly. */
tds = yds; tds = (BDIGIT *)yds;
} }
else { else {
/* bigdivrem_normal will modify y. /* bigdivrem_normal will modify y.