repo_name string | dataset string | owner string | lang string | func_name string | code string | docstring string | url string | sha string |
|---|---|---|---|---|---|---|---|---|
BugChecker | github_2023 | vitoplantamura | c | NOT_IMPLEMENTED | void NOT_IMPLEMENTED(const char* psz)
{
if (strstr(QJSNotImplLog, psz))
return;
if (strlen(QJSNotImplLog) + strlen(psz) > sizeof(QJSNotImplLog) - 16)
return;
if (strlen(QJSNotImplLog))
strcat(QJSNotImplLog, ",");
strcat(QJSNotImplLog, psz);
return;
} | // --------- NOT_IMPLEMENTED function definition: we need to log any not implemented function invoked by QJS. --------- | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJSCInterface.c#L232-L246 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | _bc_WaitForSingleObject | DWORD __stdcall _bc_WaitForSingleObject(__in HANDLE hHandle, __in DWORD dwMilliseconds)
{
NOT_IMPLEMENTED("WaitForSingleObject");
return 0;
} | // --------- Windows APIs: --------- | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJSCInterface.c#L750-L754 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | gettimeofday | int gettimeofday(struct timeval * tp, struct timezone * tzp)
{
static const uint64_t EPOCH = ((uint64_t)116444736000000000ULL);
SYSTEMTIME system_time;
FILETIME file_time;
uint64_t time;
GetSystemTime(&system_time);
SystemTimeToFileTime(&system_time, &file_time);
time = ((uint64_t)file_time.dwLow... | // From: https://stackoverflow.com/a/26085827 | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/cutils.c#L35-L52 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | dbuf_realloc | int dbuf_realloc(DynBuf *s, size_t new_size)
{
size_t size;
uint8_t *new_buf;
if (new_size > s->allocated_size) {
if (s->error)
return -1;
size = s->allocated_size * 3 / 2;
if (size > new_size)
new_size = size;
new_buf = s->realloc_func(s->opaque, s->b... | /* return < 0 if error */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/cutils.c#L128-L147 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | unicode_to_utf8 | int unicode_to_utf8(uint8_t *buf, unsigned int c)
{
uint8_t *q = buf;
if (c < 0x80) {
*q++ = c;
} else {
if (c < 0x800) {
*q++ = (c >> 6) | 0xc0;
} else {
if (c < 0x10000) {
*q++ = (c >> 12) | 0xe0;
} else {
if (c <... | /* Note: at most 31 bits are encoded. At most UTF8_CHAR_LEN_MAX bytes
are output. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/cutils.c#L229-L262 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | unicode_from_utf8 | int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp)
{
int l, c, b, i;
c = *p++;
if (c < 0x80) {
*pp = p;
return c;
}
switch(c) {
case 0xc0: case 0xc1: case 0xc2: case 0xc3:
case 0xc4: case 0xc5: case 0xc6: case 0xc7:
case 0xc8: case 0xc9: case 0xca: ... | /* return -1 if error. *pp is not updated in this case. max_len must
be >= 1. The maximum length for a UTF8 byte sequence is 6 bytes. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/cutils.c#L274-L327 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | rqsort | void rqsort(void *base, size_t nmemb, size_t size,
int (*cmp)(const void *, const void *, void *),
void *arg)
{
rqsort_arg = arg;
rqsort_cmp = cmp;
qsort(base, nmemb, size, rqsort_cmp2);
} | /* not reentrant, but not needed with emscripten */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/cutils.c#L342-L349 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | rqsort | void rqsort(void *base, size_t nmemb, size_t size, cmp_f cmp, void *opaque)
{
struct { uint8_t *base; size_t count; int depth; } stack[50], *sp = stack;
uint8_t *ptr, *pi, *pj, *plt, *pgt, *top, *m;
size_t m4, i, lt, gt, span, span2;
int c, depth;
exchange_f swap = exchange_func(base, size);
exc... | /* pointer based version with local stack and insertion sort threshhold */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/cutils.c#L535-L652 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | clz | static inline int clz(limb_t a)
{
if (a == 0) {
return LIMB_BITS;
} else {
#if LIMB_BITS == 64
return clz64(a);
#else
return clz32(a);
#endif
}
} | /* could leading zeros */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L94-L105 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | ceil_div | static inline slimb_t ceil_div(slimb_t a, slimb_t b)
{
if (a >= 0)
return (a + b - 1) / b;
else
return a / b;
} | /* b must be >= 1 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L129-L135 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | floor_div | static inline slimb_t floor_div(slimb_t a, slimb_t b)
{
if (a >= 0) {
return a / b;
} else {
return (a - b + 1) / b;
}
} | /* b must be >= 1 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L138-L145 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | smod | static inline limb_t smod(slimb_t a, slimb_t b)
{
a = a % (slimb_t)b;
if (a < 0)
a += b;
return a;
} | /* return r = a modulo b (0 <= r <= b - 1. b must be >= 1 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L148-L154 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | sat_add | static inline slimb_t sat_add(slimb_t a, slimb_t b)
{
slimb_t r;
r = a + b;
/* overflow ? */
if (((a ^ r) & (b ^ r)) < 0)
r = (a >> (LIMB_BITS - 1)) ^ (((limb_t)1 << (LIMB_BITS - 1)) - 1);
return r;
} | /* signed addition with saturation */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L157-L165 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_resize | int bf_resize(bf_t *r, limb_t len)
{
limb_t *tab;
if (len != r->len) {
tab = bf_realloc(r->ctx, r->tab, len * sizeof(limb_t));
if (!tab && len != 0)
return -1;
r->tab = tab;
r->len = len;
}
return 0;
} | /* return 0 if OK, -1 if alloc error */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L194-L206 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_set_ui | int bf_set_ui(bf_t *r, uint64_t a)
{
r->sign = 0;
if (a == 0) {
r->expn = BF_EXP_ZERO;
bf_resize(r, 0); /* cannot fail */
}
#if LIMB_BITS == 32
else if (a <= 0xffffffff)
#else
else
#endif
{
int shift;
if (bf_resize(r, 1))
goto fail;
shift = cl... | /* return 0 or BF_ST_MEM_ERROR */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L209-L247 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_set_si | int bf_set_si(bf_t *r, int64_t a)
{
int ret;
if (a < 0) {
ret = bf_set_ui(r, -a);
r->sign = 1;
} else {
ret = bf_set_ui(r, a);
}
return ret;
} | /* return 0 or BF_ST_MEM_ERROR */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L250-L261 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_set | int bf_set(bf_t *r, const bf_t *a)
{
if (r == a)
return 0;
if (bf_resize(r, a->len)) {
bf_set_nan(r);
return BF_ST_MEM_ERROR;
}
r->sign = a->sign;
r->expn = a->expn;
memcpy(r->tab, a->tab, a->len * sizeof(limb_t));
return 0;
} | /* return 0 or BF_ST_MEM_ERROR */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L285-L297 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_move | void bf_move(bf_t *r, bf_t *a)
{
bf_context_t *s = r->ctx;
if (r == a)
return;
bf_free(s, r->tab);
*r = *a;
} | /* equivalent to bf_set(r, a); bf_delete(a) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L300-L307 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | get_bits | static inline limb_t get_bits(const limb_t *tab, limb_t len, slimb_t pos)
{
limb_t i, a0, a1;
int p;
i = pos >> LIMB_LOG2_BITS;
p = pos & (LIMB_BITS - 1);
if (i < len)
a0 = tab[i];
else
a0 = 0;
if (p == 0) {
return a0;
} else {
i++;
if (i < len)
... | /* get LIMB_BITS at bit position 'pos' in tab */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L318-L339 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | scan_bit_nz | static inline limb_t scan_bit_nz(const bf_t *r, slimb_t bit_pos)
{
slimb_t pos;
limb_t v;
pos = bit_pos >> LIMB_LOG2_BITS;
if (pos < 0)
return 0;
v = r->tab[pos] & limb_mask(0, bit_pos & (LIMB_BITS - 1));
if (v != 0)
return 1;
pos--;
while (pos >= 0) {
if (r-... | /* return != 0 if one bit between 0 and bit_pos inclusive is not zero. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L373-L391 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_get_rnd_add | static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
slimb_t prec, int rnd_mode)
{
int add_one, inexact;
limb_t bit1, bit0;
if (rnd_mode == BF_RNDF) {
bit0 = 1; /* faithful rounding does not honor the INEXACT flag */
} else {
/* starting limb for b... | /* return the addend for rounding. Note that prec can be <= 0 (for
BF_FLAG_RADPNT_PREC) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L395-L446 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | __bf_round | static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
int ret)
{
limb_t v, a;
int shift, add_one, rnd_mode;
slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
/* e_min and e_max are computed to match the IEEE 754 conventions */
e_range = (limb_t)1 << (bf_... | /* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
assumed to have length 'l' (1 <= l <= r->len). Note: 'prec1' can be
infinite (BF_PREC_INF). 'ret' is 0 or BF_ST_INEXACT if the result
is known to be inexact. Can fail with BF_ST_MEM_ERROR in case of
overflow not returning infinity. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L484-L589 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_normalize_and_round | int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
{
limb_t l, v, a;
int shift, ret;
slimb_t i;
// bf_print_str("bf_renorm", r);
l = r->len;
while (l > 0 && r->tab[l - 1] == 0)
l--;
if (l == 0) {
/* zero */
r->expn = BF_EXP_ZERO;
bf_re... | /* 'r' must be a finite number. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L592-L625 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_can_round | int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
{
BOOL is_rndn;
slimb_t bit_pos, n;
limb_t bit;
if (a->expn == BF_EXP_INF || a->expn == BF_EXP_NAN)
return FALSE;
if (rnd_mode == BF_RNDF) {
return (k >= (prec + 1));
}
if (a->expn == BF_EXP_ZERO... | /* return true if rounding can be done at precision 'prec' assuming
the exact result r is such that |r-a| <= 2^(EXP(a)-k). */
/* XXX: check the case where the exponent would be incremented by the
rounding */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L631-L664 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_round | int bf_round(bf_t *r, limb_t prec, bf_flags_t flags)
{
if (r->len == 0)
return 0;
return __bf_round(r, prec, flags, r->len, 0);
} | /* Cannot fail with BF_ST_MEM_ERROR. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L667-L672 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | dump_limbs | static __maybe_unused void dump_limbs(const char *str, const limb_t *tab, limb_t n)
{
limb_t i;
printf("%s: len=%" PRId_LIMB "\n", str, n);
for(i = 0; i < n; i++) {
printf("%" PRId_LIMB ": " FMT_LIMB "\n",
i, tab[i]);
}
} | /* for debugging */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L675-L683 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_print_str | void bf_print_str(const char *str, const bf_t *a)
{
slimb_t i;
printf("%s=", str);
if (a->expn == BF_EXP_NAN) {
printf("NaN");
} else {
if (a->sign)
putchar('-');
if (a->expn == BF_EXP_ZERO) {
putchar('0');
} else if (a->expn == BF_EXP_INF) {
... | /* for debugging */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L712-L734 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_cmpu | int bf_cmpu(const bf_t *a, const bf_t *b)
{
slimb_t i;
limb_t len, v1, v2;
if (a->expn != b->expn) {
if (a->expn < b->expn)
return -1;
else
return 1;
}
len = bf_max(a->len, b->len);
for(i = len - 1; i >= 0; i--) {
v1 = get_limbz(a, a->len - le... | /* compare the absolute value of 'a' and 'b'. Return < 0 if a < b, 0
if a = b and > 0 otherwise. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L738-L761 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_cmp_full | int bf_cmp_full(const bf_t *a, const bf_t *b)
{
int res;
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
if (a->expn == b->expn)
res = 0;
else if (a->expn == BF_EXP_NAN)
res = 1;
else
res = -1;
} else if (a->sign != b->sign) {
re... | /* Full order: -0 < 0, NaN == NaN and NaN is larger than all other numbers */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L764-L783 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_cmp | int bf_cmp(const bf_t *a, const bf_t *b)
{
int res;
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
res = 2;
} else if (a->sign != b->sign) {
if (a->expn == BF_EXP_ZERO && b->expn == BF_EXP_ZERO)
res = 0;
else
res = 1 - 2 * a->sign;
} else {
... | /* Standard floating point comparison: return 2 if one of the operands
is NaN (unordered) or -1, 0, 1 depending on the ordering assuming
-0 == +0 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L788-L805 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | count_cancelled_bits | static limb_t count_cancelled_bits(const bf_t *a, const bf_t *b)
{
slimb_t bit_offset, b_offset, n;
int p, p1;
limb_t v1, v2, mask;
bit_offset = a->len * LIMB_BITS - 1;
b_offset = (b->len - a->len) * LIMB_BITS - (LIMB_BITS - 1) +
a->expn - b->expn;
n = 0;
/* first search the equals... | /* Compute the number of bits 'n' matching the pattern:
a= X1000..0
b= X0111..1
When computing a-b, the result will have at least n leading zero
bits.
Precondition: a > b and a.expn - b.expn = 0 or 1
*/ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L816-L866 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_neg | static limb_t mp_neg(limb_t *res, const limb_t *op2, mp_size_t n, limb_t carry)
{
int i;
limb_t k, a, v, k1;
k = carry;
for(i=0;i<n;i++) {
v = 0;
a = v - op2[i];
k1 = a > v;
v = a - k;
k = (v > a) | k1;
res[i] = v;
}
return k;
} | /* compute 0 - op2 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1077-L1092 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_shr | static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n,
int shift, limb_t high)
{
mp_size_t i;
limb_t l, a;
assert(shift >= 1 && shift < LIMB_BITS);
l = high;
for(i = n - 1; i >= 0; i--) {
a = tab[i];
tab_r[i] = (a >> shift) | (l << (LIMB_BITS - shi... | /* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift).
1 <= shift <= LIMB_BITS - 1 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1113-L1127 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_mul1 | static limb_t mp_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
limb_t b, limb_t l)
{
limb_t i;
dlimb_t t;
for(i = 0; i < n; i++) {
t = (dlimb_t)taba[i] * (dlimb_t)b + l;
tabr[i] = t;
l = t >> LIMB_BITS;
}
return l;
} | /* tabr[] = taba[] * b + l. Return the high carry */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1130-L1142 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_add_mul1 | static limb_t mp_add_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
limb_t b)
{
limb_t i, l;
dlimb_t t;
l = 0;
for(i = 0; i < n; i++) {
t = (dlimb_t)taba[i] * (dlimb_t)b + l + tabr[i];
tabr[i] = t;
l = t >> LIMB_BITS;
}
return l;
} | /* tabr[] += taba[] * b, return the high word. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1145-L1158 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_mul_basecase | static void mp_mul_basecase(limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
limb_t i, r;
result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
for(i=1;i<op2_size;i++) {
r = mp_add_mul1(r... | /* size of the result : op1_size + op2_size. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1161-L1172 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_mul | int mp_mul(bf_context_t *s, limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
#ifdef USE_FFT_MUL
if (unlikely(bf_min(op1_size, op2_size) >= FFT_MUL_THRESHOLD)) {
bf_t r_s, *r = &r_s;
r->tab = result;
/* XXX: optimize memory usa... | /* return 0 if OK, -1 if memory error */
/* XXX: change API so that result can be allocated */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1176-L1194 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sub_mul1 | static limb_t mp_sub_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
limb_t b)
{
limb_t i, l;
dlimb_t t;
l = 0;
for(i = 0; i < n; i++) {
t = tabr[i] - (dlimb_t)taba[i] * (dlimb_t)b - l;
tabr[i] = t;
l = -(t >> LIMB_BITS);
}
return l;
} | /* tabr[] -= taba[] * b. Return the value to substract to the high
word. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1198-L1211 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | udiv1norm_init | static inline limb_t udiv1norm_init(limb_t d)
{
limb_t a0, a1;
a1 = -d - 1;
a0 = -1;
return (((dlimb_t)a1 << LIMB_BITS) | a0) / d;
} | /* WARNING: d must be >= 2^(LIMB_BITS-1) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1214-L1220 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | udiv1norm | static inline limb_t udiv1norm(limb_t *pr, limb_t a1, limb_t a0,
limb_t d, limb_t d_inv)
{
limb_t n1m, n_adj, q, r, ah;
dlimb_t a;
n1m = ((slimb_t)a0 >> (LIMB_BITS - 1));
n_adj = a0 + (n1m & d);
a = (dlimb_t)d_inv * (a1 - n1m) + n_adj;
q = (a >> LIMB_BITS) + a1;
... | /* return the quotient and the remainder in '*pr'of 'a1*2^LIMB_BITS+a0
/ d' with 0 <= a1 < d. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1224-L1242 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_div1norm | static limb_t mp_div1norm(limb_t *tabr, const limb_t *taba, limb_t n,
limb_t b, limb_t r)
{
slimb_t i;
if (n >= UDIV1NORM_THRESHOLD) {
limb_t b_inv;
b_inv = udiv1norm_init(b);
for(i = n - 1; i >= 0; i--) {
tabr[i] = udiv1norm(&r, r, taba[i], b, b_in... | /* b must be >= 1 << (LIMB_BITS - 1) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1245-L1265 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_divnorm | static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na,
const limb_t *tabb, limb_t nb)
{
limb_t r, a, c, q, v, b1, b1_inv, n, dummy_r;
slimb_t i, j;
b1 = tabb[nb - 1];
if (nb == 1) {
taba[0] = mp_div1norm(tabq, taba, na, b1, 0);
return 0;
... | /* base case division: divides taba[0..na-1] by tabb[0..nb-1]. tabb[nb
- 1] must be >= 1 << (LIMB_BITS - 1). na - nb must be >= 0. 'taba'
is modified and contains the remainder (nb limbs). tabq[0..na-nb]
contains the quotient with tabq[na - nb] <= 1. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1275-L1344 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_recip | int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n)
{
mp_size_t l, h, k, i;
limb_t *tabxh, *tabt, c, *tabu;
if (n <= 2) {
/* return ceil(B^(2*n)/a) - 1 */
/* XXX: could avoid allocation */
tabu = bf_malloc(s, sizeof(limb_t) * (2 * n + 1));
tabt = bf... | /* compute r=B^(2*n)/a such as a*r < B^(2*n) < a*r + 2 with n >= 1. 'a'
has n limbs with a[n-1] >= B/2 and 'r' has n+1 limbs with r[n] = 1.
See Modern Computer Arithmetic by Richard P. Brent and Paul
Zimmermann, algorithm 3.5 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1351-L1412 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_cmp | static int mp_cmp(const limb_t *taba, const limb_t *tabb, mp_size_t n)
{
mp_size_t i;
for(i = n - 1; i >= 0; i--) {
if (taba[i] != tabb[i]) {
if (taba[i] < tabb[i])
return -1;
else
return 1;
}
}
return 0;
} | /* return -1, 0 or 1 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1415-L1427 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_divnorm_large | static int mp_divnorm_large(bf_context_t *s,
limb_t *tabq, limb_t *taba, limb_t na,
const limb_t *tabb, limb_t nb)
{
limb_t *tabb_inv, nq, *tabt, i, n;
nq = na - nb;
#ifdef DEBUG_DIVNORM_LARGE
printf("na=%d nb=%d nq=%d\n", (int)na, (int)nb, (int)nq);... | //#define DEBUG_DIVNORM_LARGE
//#define DEBUG_DIVNORM_LARGE2
/* subquadratic divnorm */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1433-L1522 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_mul_2exp | int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags)
{
slimb_t e_max;
if (r->len == 0)
return 0;
e_max = ((limb_t)1 << BF_EXT_EXP_BITS_MAX) - 1;
e = bf_max(e, -e_max);
e = bf_min(e, e_max);
r->expn += e;
return __bf_round(r, prec, flags, r->len, 0);
} | /* multiply 'r' by 2^e */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1606-L1616 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_get_exp_min | slimb_t bf_get_exp_min(const bf_t *a)
{
slimb_t i;
limb_t v;
int k;
for(i = 0; i < a->len; i++) {
v = a->tab[i];
if (v != 0) {
k = ctz(v);
return a->expn - (a->len - i) * LIMB_BITS + k;
}
}
return 0;
} | /* Return e such as a=m*2^e with m odd integer. return 0 if a is zero,
Infinite or Nan. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1620-L1634 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_tdivremu | static void bf_tdivremu(bf_t *q, bf_t *r,
const bf_t *a, const bf_t *b)
{
if (bf_cmpu(a, b) < 0) {
bf_set_ui(q, 0);
bf_set(r, a);
} else {
bf_div(q, a, b, bf_max(a->expn - b->expn + 1, 2), BF_RNDZ);
bf_rint(q, BF_RNDZ);
bf_mul(r, q, b, BF_PREC_INF,... | /* a and b must be finite numbers with a >= 0 and b > 0. 'q' is the
integer defined as floor(a/b) and r = a - q * b. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1638-L1650 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_divrem | int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
limb_t prec, bf_flags_t flags, int rnd_mode)
{
bf_t a1_s, *a1 = &a1_s;
bf_t b1_s, *b1 = &b1_s;
int q_sign, ret;
BOOL is_ceil, is_rndn;
assert(q != a && q != b);
assert(r != a && r != b);
assert(q != r);
... | /* division and remainder.
rnd_mode is the rounding mode for the quotient. The additional
rounding mode BF_RND_EUCLIDIAN is supported.
'q' is an integer. 'r' is rounded with prec and flags (prec can be
BF_PREC_INF).
*/ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1732-L1824 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sqrtrem1 | static limb_t mp_sqrtrem1(limb_t *pr, limb_t a)
{
limb_t s1, r1, s, r, q, u, num;
/* use a table for the 16 -> 8 bit sqrt */
s1 = sqrt_table[(a >> (LIMB_BITS - 8)) - 64];
r1 = (a >> (LIMB_BITS - 16)) - s1 * s1;
if (r1 > 2 * s1) {
r1 -= 2 * s1 + 1;
s1++;
}
/* one ite... | /* a >= 2^(LIMB_BITS - 2). Return (s, r) with s=floor(sqrt(a)) and
r=a-s^2. 0 <= r <= 2 * s */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1887-L1928 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_isqrt | limb_t bf_isqrt(limb_t a)
{
limb_t s, r;
int k;
if (a == 0)
return 0;
k = clz(a) & ~1;
s = mp_sqrtrem1(&r, a << k);
s >>= (k >> 1);
return s;
} | /* return floor(sqrt(a)) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1931-L1942 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sqrtrem_rec | static int mp_sqrtrem_rec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n,
limb_t *tmp_buf, limb_t *prh)
{
limb_t l, h, rh, ql, qh, c, i;
if (n == 1) {
*prh = mp_sqrtrem2(tabs, taba);
return 0;
}
#ifdef DEBUG_SQRTREM
mp_print_str("a", taba, 2 * n);
#e... | //#define DEBUG_SQRTREM
/* tmp_buf must contain (n / 2 + 1 limbs). *prh contains the highest
limb of the remainder. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L1976-L2042 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sqrtrem | int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
{
limb_t tmp_buf1[8];
limb_t *tmp_buf;
mp_size_t n2;
int ret;
n2 = n / 2 + 1;
if (n2 <= countof(tmp_buf1)) {
tmp_buf = tmp_buf1;
} else {
tmp_buf = bf_malloc(s, sizeof(limb_t) * n2);
if (!tmp_buf)
... | /* 'taba' has 2*n limbs with n >= 1 and taba[2*n-1] >= 2 ^ (LIMB_BITS
- 2). Return (s, r) with s=floor(sqrt(a)) and r=a-s^2. 0 <= r <= 2
* s. tabs has n limbs. r is returned in the lower n limbs of
taba. Its r[n] is the returned value of the function. */
/* Algorithm from the article "Karatsuba Square Root" by... | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2050-L2068 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_sqrtrem | int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a)
{
int ret;
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
bf_set_nan(r);
} else if (a->expn == BF_EXP_INF && a->sign) {
goto invalid_op;
} else {
bf_set(r, a);
}
if (rem1)
... | /* Integer square root with remainder. 'a' must be an integer. r =
floor(sqrt(a)) and rem = a - r^2. BF_ST_INEXACT is set if the result
is inexact. 'rem' can be NULL if the remainder is not needed. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2073-L2124 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_rint | int bf_rint(bf_t *r, int rnd_mode)
{
return bf_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
} | /* convert to integer (infinite precision) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2299-L2302 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_logic_or | int bf_logic_or(bf_t *r, const bf_t *a, const bf_t *b)
{
return bf_logic_op(r, a, b, BF_LOGIC_OR);
} | /* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2409-L2412 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_logic_xor | int bf_logic_xor(bf_t *r, const bf_t *a, const bf_t *b)
{
return bf_logic_op(r, a, b, BF_LOGIC_XOR);
} | /* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2415-L2418 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_logic_and | int bf_logic_and(bf_t *r, const bf_t *a, const bf_t *b)
{
return bf_logic_op(r, a, b, BF_LOGIC_AND);
} | /* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2421-L2424 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_get_int32 | int bf_get_int32(int *pres, const bf_t *a, int flags)
{
uint32_t v;
int ret;
if (a->expn >= BF_EXP_INF) {
ret = BF_ST_INVALID_OP;
if (flags & BF_GET_INT_MOD) {
v = 0;
} else if (a->expn == BF_EXP_INF) {
v = (uint32_t)INT32_MAX + a->sign;
} else {
... | /* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
is an overflow and 0 otherwise. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2533-L2573 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_get_int64 | int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
{
uint64_t v;
int ret;
if (a->expn >= BF_EXP_INF) {
ret = BF_ST_INVALID_OP;
if (flags & BF_GET_INT_MOD) {
v = 0;
} else if (a->expn == BF_EXP_INF) {
v = (uint64_t)INT64_MAX + a->sign;
} else {
... | /* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
is an overflow and 0 otherwise. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2577-L2634 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_get_uint64 | int bf_get_uint64(uint64_t *pres, const bf_t *a)
{
uint64_t v;
int ret;
if (a->expn == BF_EXP_NAN) {
goto overflow;
} else if (a->expn <= 0) {
v = 0;
ret = 0;
} else if (a->sign) {
v = 0;
ret = BF_ST_INVALID_OP;
} else if (a->expn <= 64) {
#if LIMB_BITS ==... | /* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
is an overflow and 0 otherwise. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2638-L2668 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_integer_from_radix_rec | static int bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
limb_t n, int level, limb_t n0,
limb_t radix, bf_t *pow_tab)
{
int ret;
if (n == 1) {
ret = bf_set_ui(r, tab[0]);
} else {
bf_t T_s, *T = &T_s, *B;
... | /* return != 0 if error */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2693-L2729 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_integer_from_radix | static int bf_integer_from_radix(bf_t *r, const limb_t *tab,
limb_t n, limb_t radix)
{
bf_context_t *s = r->ctx;
int pow_tab_len, i, ret;
limb_t radixl;
bf_t *pow_tab;
radixl = get_limb_radix(radix);
pow_tab_len = ceil_log2(n) + 2; /* XXX: check */
pow_t... | /* return 0 if OK != 0 if memory error */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2732-L2753 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_mul_pow_radix | int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
slimb_t expn, limb_t prec, bf_flags_t flags)
{
int ret, expn_sign, overflow;
slimb_t e, extra_bits, prec1, ziv_extra_bits;
bf_t B_s, *B = &B_s;
if (T->len == 0) {
return bf_set(r, T);
} else if (expn == 0) {
... | /* compute and round T * radix^expn. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2756-L2818 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_add_limb | static int bf_add_limb(bf_t *a, slimb_t *ppos, limb_t v)
{
slimb_t pos;
pos = *ppos;
if (unlikely(pos < 0)) {
limb_t new_size, d, *new_tab;
new_size = bf_max(a->len + 1, a->len * 3 / 2);
new_tab = bf_realloc(a->ctx, a->tab, sizeof(limb_t) * new_size);
if (!new_tab)
... | /* add a limb at 'pos' and decrement pos. new space is created if
needed. Return 0 if OK, -1 if memory error */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L2834-L2853 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_atof2 | int bf_atof2(bf_t *r, slimb_t *pexponent,
const char *str, const char **pnext, int radix,
limb_t prec, bf_flags_t flags)
{
return bf_atof_internal(r, pexponent, str, pnext, radix, prec, flags,
FALSE);
} | /*
Return (status, n, exp). 'status' is the floating point status. 'n'
is the parsed number.
If (flags & BF_ATOF_EXPONENT) and if the radix is not a power of
two, the parsed number is equal to r *
(*pexponent)^radix. Otherwise *pexponent = 0.
*/ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3137-L3143 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_mul_log2_radix | slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
int is_ceil1)
{
int is_neg;
limb_t a;
BOOL is_ceil;
is_ceil = is_ceil1;
a = a1;
if (a1 < 0) {
a = -a;
is_neg = 1;
} else {
is_neg = 0;
}
is_ceil ^= is_neg;
if ... | /* compute floor(a*b) or ceil(a*b) with b = log2(radix) or
b=1/log2(radix). For is_inv = 0, strict accuracy is not guaranteed
when radix is not a power of two. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3315-L3370 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_integer_to_radix_rec | static int bf_integer_to_radix_rec(bf_t *pow_tab,
limb_t *out, const bf_t *a, limb_t n,
int level, limb_t n0, limb_t radixl,
unsigned int radixl_bits)
{
limb_t n1, n2, q_prec;
int ret;
assert(n >= 1... | /* 'n' is the number of output limbs */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3373-L3456 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_integer_to_radix | static int bf_integer_to_radix(bf_t *r, const bf_t *a, limb_t radixl)
{
bf_context_t *s = r->ctx;
limb_t r_len;
bf_t *pow_tab;
int i, pow_tab_len, ret;
r_len = r->len;
pow_tab_len = (ceil_log2(r_len) + 2) * 2; /* XXX: check */
pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
... | /* return 0 if OK != 0 if memory error */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3459-L3482 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_convert_to_radix | static int bf_convert_to_radix(bf_t *r, slimb_t *pE,
const bf_t *a, int radix,
limb_t P, bf_rnd_t rnd_mode,
BOOL is_fixed_exponent)
{
slimb_t E, e, prec, extra_bits, ziv_extra_bits, prec0;
bf_t B_s, *B = &B_s;
int e... | /* a must be >= 0. 'P' is the wanted number of digits in radix
'radix'. 'r' is the mantissa represented as an integer. *pE
contains the exponent. Return != 0 if memory error. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3487-L3568 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | limb_to_a2 | static void limb_to_a2(char *buf, limb_t n, unsigned int radix_bits, int len)
{
int digit, i;
unsigned int mask;
mask = (1 << radix_bits) - 1;
for(i = len - 1; i >= 0; i--) {
digit = n & mask;
n >>= radix_bits;
if (digit < 10)
digit += '0';
else
d... | /* for power of 2 radixes */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3595-L3610 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | output_digits | static void output_digits(DynBuf *s, const bf_t *a1, int radix, limb_t n_digits,
limb_t dot_pos, BOOL is_dec)
{
limb_t i, v, l;
slimb_t pos, pos_incr;
int digits_per_limb, buf_pos, radix_bits, first_buf_pos;
char buf[65];
bf_t a_s, *a;
if (is_dec) {
digits_per_... | /* 'a' must be an integer if the is_dec = FALSE or if the radix is not
a power of two. A dot is added before the 'dot_pos' digit. dot_pos
= n_digits does not display the dot. 0 <= dot_pos <=
n_digits. n_digits >= 1. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L3616-L3691 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_const_log2_rec | static void bf_const_log2_rec(bf_t *T, bf_t *P, bf_t *Q, limb_t n1,
limb_t n2, BOOL need_P)
{
bf_context_t *s = T->ctx;
if ((n2 - n1) == 1) {
if (n1 == 0) {
bf_set_ui(P, 3);
} else {
bf_set_ui(P, n1);
P->sign = 1;
}
... | /***************************************************************/
/* transcendental functions */
/* Note: the algorithm is from MPFR */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4004-L4040 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_const_log2_internal | static void bf_const_log2_internal(bf_t *T, limb_t prec)
{
limb_t w, N;
bf_t P_s, *P = &P_s;
bf_t Q_s, *Q = &Q_s;
w = prec + 15;
N = w / 3 + 1;
bf_init(T->ctx, P);
bf_init(T->ctx, Q);
bf_const_log2_rec(T, P, Q, 0, N, FALSE);
bf_div(T, T, Q, prec, BF_RNDN);
bf_delete(P);
bf_d... | /* compute log(2) with faithful rounding at precision 'prec' */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4043-L4057 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_const_pi_internal | static void bf_const_pi_internal(bf_t *Q, limb_t prec)
{
bf_context_t *s = Q->ctx;
int64_t n, prec1;
bf_t P, G;
/* number of serie terms */
n = prec / CHUD_BITS_PER_TERM + 1;
/* XXX: precision analysis */
prec1 = prec + 32;
bf_init(s, &P);
bf_init(s, &G);
chud_bs(&P, Q, &G, 0,... | /* compute Pi with faithful rounding at precision 'prec' using the
Chudnovsky formula */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4124-L4150 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_const_pi_signed | static int bf_const_pi_signed(bf_t *T, int sign, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = T->ctx;
return bf_const_get(T, prec, flags, &s->pi_cache, bf_const_pi_internal,
sign);
} | /* return rounded pi * (1 - 2 * sign) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4194-L4199 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_add_epsilon | static int bf_add_epsilon(bf_t *r, const bf_t *a, slimb_t e, int e_sign,
limb_t prec, int flags)
{
bf_t T_s, *T = &T_s;
int ret;
/* small argument case: result = 1 + epsilon * sign(x) */
bf_init(a->ctx, T);
bf_set_ui(T, 1);
T->sign = e_sign;
T->expn += e;
ret = ... | /* add (1 - 2*e_sign) * 2^e */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4263-L4276 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_exp_internal | static int bf_exp_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
bf_t T_s, *T = &T_s;
slimb_t n, K, l, i, prec1;
assert(r != a);
/* argument reduction:
T = a - n*log(2) with 0 <= T < log(2) and n integer.
*/
bf_init(s, T);
if (a->expn... | /* Compute the exponential using faithful rounding at precision 'prec'.
Note: the algorithm is from MPFR */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4280-L4347 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | check_exp_underflow_overflow | static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
const bf_t *a_low, const bf_t *a_high,
limb_t prec, bf_flags_t flags)
{
bf_t T_s, *T = &T_s;
bf_t log2_s, *log2 = &log2_s;
slimb_t e_min, e_max;
if (a_hi... | /* crude overflow and underflow tests for exp(a). a_low <= a <= a_high */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4350-L4398 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_pow_generic | static int bf_pow_generic(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
const bf_t *y = opaque;
bf_t T_s, *T = &T_s;
limb_t prec1;
bf_init(s, T);
/* XXX: proof for the added precision */
prec1 = prec + 32;
bf_log(T, x, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
... | /* x and y finite and x > 0 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4570-L4588 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_pow_int | static int bf_pow_int(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
{
bf_context_t *s = r->ctx;
const bf_t *y = opaque;
bf_t T_s, *T = &T_s;
limb_t prec1;
int ret;
slimb_t y1;
bf_get_limb(&y1, y, 0);
if (y1 < 0)
y1 = -y1;
/* XXX: proof for the added precision */
... | /* x and y finite, x > 0, y integer and y fits on one limb */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4591-L4613 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | check_exact_power2n | static BOOL check_exact_power2n(bf_t *r, const bf_t *x, slimb_t n)
{
bf_context_t *s = r->ctx;
bf_t T_s, *T = &T_s;
slimb_t e, i, er;
limb_t v;
/* x = m*2^e with m odd integer */
e = bf_get_exp_min(x);
/* fast check on the exponent */
if (n > (LIMB_BITS - 1)) {
if (e != 0)
... | /* x must be a finite non zero float. Return TRUE if there is a
floating point number r such as x=r^(2^n) and return this floating
point number 'r'. Otherwise return FALSE and r is undefined. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4618-L4653 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_pow | int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = r->ctx;
bf_t T_s, *T = &T_s;
bf_t ytmp_s;
BOOL y_is_int, y_is_odd;
int r_sign, ret, rnd_mode;
slimb_t y_emin;
if (x->len == 0 || y->len == 0) {
if (y->expn == BF_EXP_ZERO) {
... | /* prec = BF_PREC_INF is accepted for x and y integers and y >= 0 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4656-L4824 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_sqrt_sin | static void bf_sqrt_sin(bf_t *r, const bf_t *x, limb_t prec1)
{
bf_context_t *s = r->ctx;
bf_t T_s, *T = &T_s;
bf_init(s, T);
bf_set(T, x);
bf_mul(r, T, T, prec1, BF_RNDN);
bf_mul_2exp(T, 1, BF_PREC_INF, BF_RNDZ);
bf_add(T, T, r, prec1, BF_RNDN);
bf_neg(T);
bf_sqrt(r, T, prec1, BF_RN... | /* compute sqrt(-2*x-x^2) to get |sin(x)| from cos(x) - 1. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L4827-L4839 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bf_atan_internal | static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
void *opaque)
{
bf_context_t *s = r->ctx;
BOOL add_pi2 = (BOOL)(intptr_t)opaque;
bf_t T_s, *T = &T_s;
bf_t U_s, *U = &U_s;
bf_t V_s, *V = &V_s;
bf_t X2_s, *X2 = &X2_s;
int cmp_1;
slimb_t prec1, i... | /* if add_pi2 is true, add pi/2 to the result (used for acos(x) to
avoid cancellation) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5053-L5137 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | shrd | static inline __maybe_unused limb_t shrd(limb_t low, limb_t high, long shift)
{
if (shift != 0)
low = (low >> shift) | (high << (LIMB_BITS - shift));
return low;
} | /* LIMB_BITS != 64 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5395-L5400 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | fast_udiv_init | static inline __maybe_unused void fast_udiv_init(FastDivData *s, limb_t d)
{
int l;
limb_t q, r, m1;
if (d == 1)
l = 0;
else
l = 64 - clz64(d - 1);
divdq(q, r, ((limb_t)1 << l) - d, 0, d);
(void)r;
m1 = q + 1;
// printf("d=%lu l=%d m1=0x%016lx\n", d, l, m1);
s->m1 ... | /* From "Division by Invariant Integers using Multiplication" by
Torborn Granlund and Peter L. Montgomery */
/* d must be != 0 */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5464-L5483 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | fast_shr_dec | static inline limb_t fast_shr_dec(limb_t a, int shift)
{
return fast_udiv(a, &mp_pow_div[shift]);
} | /* divide by 10^shift with 0 <= shift <= LIMB_DIGITS */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5557-L5560 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_mul1_dec | limb_t mp_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
limb_t b, limb_t l)
{
mp_size_t i;
limb_t t0, t1, r;
for(i = 0; i < n; i++) {
muldq(t1, t0, taba[i], b);
adddq(t1, t0, 0, l);
divdq_base(l, r, t1, t0);
tabr[i] = r;
}
return l;
} | /* taba[] = taba[] * b + l. 0 <= b, l <= base - 1. Return the high carry */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5645-L5658 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_add_mul1_dec | limb_t mp_add_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
limb_t b)
{
mp_size_t i;
limb_t l, t0, t1, r;
l = 0;
for(i = 0; i < n; i++) {
muldq(t1, t0, taba[i], b);
adddq(t1, t0, 0, l);
adddq(t1, t0, 0, tabr[i]);
divdq_base(l, r, t1, t0);... | /* tabr[] += taba[] * b. 0 <= b <= base - 1. Return the value to add
to the high word */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5662-L5677 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sub_mul1_dec | limb_t mp_sub_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
limb_t b)
{
limb_t base = BF_DEC_BASE;
mp_size_t i;
limb_t l, t0, t1, r, a, v, c;
/* XXX: optimize */
l = 0;
for(i = 0; i < n; i++) {
muldq(t1, t0, taba[i], b);
adddq(t1, t0, 0, l);
... | /* tabr[] -= taba[] * b. 0 <= b <= base - 1. Return the value to
substract to the high word. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5681-L5704 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_mul_basecase_dec | void mp_mul_basecase_dec(limb_t *result,
const limb_t *op1, mp_size_t op1_size,
const limb_t *op2, mp_size_t op2_size)
{
mp_size_t i;
limb_t r;
result[op1_size] = mp_mul1_dec(result, op1, op1_size, op2[0], 0);
for(i=1;i<op2_size;i++) {
r... | /* size of the result : op1_size + op2_size. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5707-L5720 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_div1_dec | limb_t mp_div1_dec(limb_t *tabr, const limb_t *taba, mp_size_t na,
limb_t b, limb_t r)
{
limb_t base = BF_DEC_BASE;
mp_size_t i;
limb_t t0, t1, q;
int shift;
#if (BF_DEC_BASE % 2) == 0
if (b == 2) {
limb_t base_div2;
/* Note: only works if base is even */
... | /* taba[] = (taba[] + r*base^na) / b. 0 <= b < base. 0 <= r <
b. Return the remainder. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5724-L5785 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_div_dec | static int mp_div_dec(bf_context_t *s, limb_t *tabq,
limb_t *taba, mp_size_t na,
const limb_t *tabb1, mp_size_t nb)
{
limb_t base = BF_DEC_BASE;
limb_t r, mult, t0, t1, a, c, q, v, *tabb;
mp_size_t i, j;
limb_t static_tabb[DIV_STATIC_ALLOC_LEN];
#ifdef D... | /* return q = a / b and r = a % b.
taba[na] must be allocated if tabb1[nb - 1] < B / 2. tabb1[nb - 1]
must be != zero. na must be >= nb. 's' can be NULL if tabb1[nb - 1]
>= B / 2.
The remainder is is returned in taba and contains nb libms. tabq
contains na - nb + 1 limbs. No overlap is permitted.
... | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5831-L5934 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_shr_dec | static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
limb_t shift, limb_t high)
{
mp_size_t i;
limb_t l, a, q, r;
assert(shift >= 1 && shift < LIMB_DIGITS);
l = high;
for(i = n - 1; i >= 0; i--) {
a = tab[i];
fast_shr_rem_dec(q, r, a, shi... | /* divide by 10^shift */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5937-L5952 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_shl_dec | static limb_t mp_shl_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
limb_t shift, limb_t low)
{
mp_size_t i;
limb_t l, a, q, r;
assert(shift >= 1 && shift < LIMB_DIGITS);
l = low;
for(i = 0; i < n; i++) {
a = tab[i];
fast_shr_rem_dec(q, r, a, LIMB_DIGIT... | /* multiply by 10^shift */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5955-L5970 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sqrtrem_rec_dec | static limb_t mp_sqrtrem_rec_dec(limb_t *tabs, limb_t *taba, limb_t n,
limb_t *tmp_buf)
{
limb_t l, h, rh, ql, qh, c, i;
if (n == 1)
return mp_sqrtrem2_dec(tabs, taba);
#ifdef DEBUG_SQRTREM_DEC
mp_print_str_dec("a", taba, 2 * n);
#endif
l = n / 2;
h = n ... | //#define DEBUG_SQRTREM_DEC
/* tmp_buf must contain (n / 2 + 1 limbs) */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L5997-L6057 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | mp_sqrtrem_dec | int mp_sqrtrem_dec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
{
limb_t tmp_buf1[8];
limb_t *tmp_buf;
mp_size_t n2;
n2 = n / 2 + 1;
if (n2 <= countof(tmp_buf1)) {
tmp_buf = tmp_buf1;
} else {
tmp_buf = bf_malloc(s, sizeof(limb_t) * n2);
if (!tmp_buf)
... | /* 'taba' has 2*n limbs with n >= 1 and taba[2*n-1] >= B/4. Return (s,
r) with s=floor(sqrt(a)) and r=a-s^2. 0 <= r <= 2 * s. tabs has n
limbs. r is returned in the lower n limbs of taba. Its r[n] is the
returned value of the function. */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L6063-L6080 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | clz_dec | static int clz_dec(limb_t a)
{
if (a == 0)
return LIMB_DIGITS;
switch(LIMB_BITS - 1 - clz(a)) {
case 0: /* 1-1 */
return LIMB_DIGITS - 1;
case 1: /* 2-3 */
return LIMB_DIGITS - 1;
case 2: /* 4-7 */
return LIMB_DIGITS - 1;
case 3: /* 8-15 */
if (a < 10)
... | /* return the number of leading zero digits, from 0 to LIMB_DIGITS */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L6083-L6267 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
BugChecker | github_2023 | vitoplantamura | c | bfdec_print_str | void bfdec_print_str(const char *str, const bfdec_t *a)
{
slimb_t i;
printf("%s=", str);
if (a->expn == BF_EXP_NAN) {
printf("NaN");
} else {
if (a->sign)
putchar('-');
if (a->expn == BF_EXP_ZERO) {
putchar('0');
} else if (a->expn == BF_EXP_INF) ... | /* for debugging */ | https://github.com/vitoplantamura/BugChecker/blob/8b81e76efe457b59be3a6e752efd43916ba0cabb/BugChecker/QuickJS/libbf.c#L6270-L6292 | 8b81e76efe457b59be3a6e752efd43916ba0cabb |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.