8412 lines
233 KiB
C
8412 lines
233 KiB
C
/*
|
|
* Tiny arbitrary precision floating point library
|
|
*
|
|
* Copyright (c) 2017-2021 Fabrice Bellard
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#ifdef __AVX2__
|
|
#include <immintrin.h>
|
|
#endif
|
|
|
|
#include "cutils.h"
|
|
#include "libbf.h"
|
|
|
|
/* enable it to check the multiplication result */
|
|
//#define USE_MUL_CHECK
|
|
/* enable it to use FFT/NTT multiplication */
|
|
#define USE_FFT_MUL
|
|
/* enable decimal floating point support */
|
|
#define USE_BF_DEC
|
|
|
|
//#define inline __attribute__((always_inline))
|
|
|
|
#ifdef __AVX2__
|
|
#define FFT_MUL_THRESHOLD 100 /* in limbs of the smallest factor */
|
|
#else
|
|
#define FFT_MUL_THRESHOLD 100 /* in limbs of the smallest factor */
|
|
#endif
|
|
|
|
/* XXX: adjust */
|
|
#define DIVNORM_LARGE_THRESHOLD 50
|
|
#define UDIV1NORM_THRESHOLD 3
|
|
|
|
#if LIMB_BITS == 64
|
|
#define FMT_LIMB1 "%" PRIx64
|
|
#define FMT_LIMB "%016" PRIx64
|
|
#define PRId_LIMB PRId64
|
|
#define PRIu_LIMB PRIu64
|
|
|
|
#else
|
|
|
|
#define FMT_LIMB1 "%x"
|
|
#define FMT_LIMB "%08x"
|
|
#define PRId_LIMB "d"
|
|
#define PRIu_LIMB "u"
|
|
|
|
#endif
|
|
|
|
typedef intptr_t mp_size_t;
|
|
|
|
typedef int bf_op2_func_t(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags);
|
|
|
|
#ifdef USE_FFT_MUL
|
|
|
|
#define FFT_MUL_R_OVERLAP_A (1 << 0)
|
|
#define FFT_MUL_R_OVERLAP_B (1 << 1)
|
|
#define FFT_MUL_R_NORESIZE (1 << 2)
|
|
|
|
static no_inline int fft_mul(bf_context_t *s,
|
|
bf_t *res, limb_t *a_tab, limb_t a_len,
|
|
limb_t *b_tab, limb_t b_len, int mul_flags);
|
|
static void fft_clear_cache(bf_context_t *s);
|
|
#endif
|
|
#ifdef USE_BF_DEC
|
|
static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos);
|
|
#endif
|
|
|
|
|
|
/* could leading zeros */
|
|
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
|
|
}
|
|
}
|
|
|
|
static inline int ctz(limb_t a)
|
|
{
|
|
if (a == 0) {
|
|
return LIMB_BITS;
|
|
} else {
|
|
#if LIMB_BITS == 64
|
|
return ctz64(a);
|
|
#else
|
|
return ctz32(a);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static inline int ceil_log2(limb_t a)
|
|
{
|
|
if (a <= 1)
|
|
return 0;
|
|
else
|
|
return LIMB_BITS - clz(a - 1);
|
|
}
|
|
|
|
/* b must be >= 1 */
|
|
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 */
|
|
static inline slimb_t floor_div(slimb_t a, slimb_t b)
|
|
{
|
|
if (a >= 0) {
|
|
return a / b;
|
|
} else {
|
|
return (a - b + 1) / b;
|
|
}
|
|
}
|
|
|
|
/* return r = a modulo b (0 <= r <= b - 1. b must be >= 1 */
|
|
static inline limb_t smod(slimb_t a, slimb_t b)
|
|
{
|
|
a = a % (slimb_t)b;
|
|
if (a < 0)
|
|
a += b;
|
|
return a;
|
|
}
|
|
|
|
/* signed addition with saturation */
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static inline __maybe_unused limb_t shld(limb_t a1, limb_t a0, long shift)
|
|
{
|
|
if (shift != 0)
|
|
return (a1 << shift) | (a0 >> (LIMB_BITS - shift));
|
|
else
|
|
return a1;
|
|
}
|
|
|
|
#define malloc(s) malloc_is_forbidden(s)
|
|
#define free(p) free_is_forbidden(p)
|
|
#define realloc(p, s) realloc_is_forbidden(p, s)
|
|
|
|
void bf_context_init(bf_context_t *s, bf_realloc_func_t *realloc_func,
|
|
void *realloc_opaque)
|
|
{
|
|
memset(s, 0, sizeof(*s));
|
|
s->realloc_func = realloc_func;
|
|
s->realloc_opaque = realloc_opaque;
|
|
}
|
|
|
|
void bf_context_end(bf_context_t *s)
|
|
{
|
|
bf_clear_cache(s);
|
|
}
|
|
|
|
void bf_init(bf_context_t *s, bf_t *r)
|
|
{
|
|
r->ctx = s;
|
|
r->sign = 0;
|
|
r->expn = BF_EXP_ZERO;
|
|
r->len = 0;
|
|
r->tab = NULL;
|
|
}
|
|
|
|
/* return 0 if OK, -1 if alloc error */
|
|
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 or BF_ST_MEM_ERROR */
|
|
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 = clz(a);
|
|
r->tab[0] = a << shift;
|
|
r->expn = LIMB_BITS - shift;
|
|
}
|
|
#if LIMB_BITS == 32
|
|
else {
|
|
uint32_t a1, a0;
|
|
int shift;
|
|
if (bf_resize(r, 2))
|
|
goto fail;
|
|
a0 = a;
|
|
a1 = a >> 32;
|
|
shift = clz(a1);
|
|
r->tab[0] = a0 << shift;
|
|
r->tab[1] = shld(a1, a0, shift);
|
|
r->expn = 2 * LIMB_BITS - shift;
|
|
}
|
|
#endif
|
|
return 0;
|
|
fail:
|
|
bf_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
/* return 0 or BF_ST_MEM_ERROR */
|
|
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;
|
|
}
|
|
|
|
void bf_set_nan(bf_t *r)
|
|
{
|
|
bf_resize(r, 0); /* cannot fail */
|
|
r->expn = BF_EXP_NAN;
|
|
r->sign = 0;
|
|
}
|
|
|
|
void bf_set_zero(bf_t *r, int is_neg)
|
|
{
|
|
bf_resize(r, 0); /* cannot fail */
|
|
r->expn = BF_EXP_ZERO;
|
|
r->sign = is_neg;
|
|
}
|
|
|
|
void bf_set_inf(bf_t *r, int is_neg)
|
|
{
|
|
bf_resize(r, 0); /* cannot fail */
|
|
r->expn = BF_EXP_INF;
|
|
r->sign = is_neg;
|
|
}
|
|
|
|
/* return 0 or BF_ST_MEM_ERROR */
|
|
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;
|
|
if (a->len > 0)
|
|
memcpy(r->tab, a->tab, a->len * sizeof(limb_t));
|
|
return 0;
|
|
}
|
|
|
|
/* equivalent to bf_set(r, a); bf_delete(a) */
|
|
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;
|
|
}
|
|
|
|
static limb_t get_limbz(const bf_t *a, limb_t idx)
|
|
{
|
|
if (idx >= a->len)
|
|
return 0;
|
|
else
|
|
return a->tab[idx];
|
|
}
|
|
|
|
/* get LIMB_BITS at bit position 'pos' in tab */
|
|
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)
|
|
a1 = tab[i];
|
|
else
|
|
a1 = 0;
|
|
return (a0 >> p) | (a1 << (LIMB_BITS - p));
|
|
}
|
|
}
|
|
|
|
static inline limb_t get_bit(const limb_t *tab, limb_t len, slimb_t pos)
|
|
{
|
|
slimb_t i;
|
|
i = pos >> LIMB_LOG2_BITS;
|
|
if (i < 0 || i >= len)
|
|
return 0;
|
|
return (tab[i] >> (pos & (LIMB_BITS - 1))) & 1;
|
|
}
|
|
|
|
static inline limb_t limb_mask(int start, int last)
|
|
{
|
|
limb_t v;
|
|
int n;
|
|
n = last - start + 1;
|
|
if (n == LIMB_BITS)
|
|
v = -1;
|
|
else
|
|
v = (((limb_t)1 << n) - 1) << start;
|
|
return v;
|
|
}
|
|
|
|
static limb_t mp_scan_nz(const limb_t *tab, mp_size_t n)
|
|
{
|
|
mp_size_t i;
|
|
for(i = 0; i < n; i++) {
|
|
if (tab[i] != 0)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* return != 0 if one bit between 0 and bit_pos inclusive is not zero. */
|
|
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->tab[pos] != 0)
|
|
return 1;
|
|
pos--;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* return the addend for rounding. Note that prec can be <= 0 (for
|
|
BF_FLAG_RADPNT_PREC) */
|
|
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 bit 'prec + 1' */
|
|
bit0 = scan_bit_nz(r, l * LIMB_BITS - 1 - bf_max(0, prec + 1));
|
|
}
|
|
|
|
/* get the bit at 'prec' */
|
|
bit1 = get_bit(r->tab, l, l * LIMB_BITS - 1 - prec);
|
|
inexact = (bit1 | bit0) != 0;
|
|
|
|
add_one = 0;
|
|
switch(rnd_mode) {
|
|
case BF_RNDZ:
|
|
break;
|
|
case BF_RNDN:
|
|
if (bit1) {
|
|
if (bit0) {
|
|
add_one = 1;
|
|
} else {
|
|
/* round to even */
|
|
add_one =
|
|
get_bit(r->tab, l, l * LIMB_BITS - 1 - (prec - 1));
|
|
}
|
|
}
|
|
break;
|
|
case BF_RNDD:
|
|
case BF_RNDU:
|
|
if (r->sign == (rnd_mode == BF_RNDD))
|
|
add_one = inexact;
|
|
break;
|
|
case BF_RNDA:
|
|
add_one = inexact;
|
|
break;
|
|
case BF_RNDNA:
|
|
case BF_RNDF:
|
|
add_one = bit1;
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
|
|
if (inexact)
|
|
*pret |= BF_ST_INEXACT;
|
|
return add_one;
|
|
}
|
|
|
|
static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
|
|
{
|
|
slimb_t i, l, e_max;
|
|
int rnd_mode;
|
|
|
|
rnd_mode = flags & BF_RND_MASK;
|
|
if (prec == BF_PREC_INF ||
|
|
rnd_mode == BF_RNDN ||
|
|
rnd_mode == BF_RNDNA ||
|
|
rnd_mode == BF_RNDA ||
|
|
(rnd_mode == BF_RNDD && sign == 1) ||
|
|
(rnd_mode == BF_RNDU && sign == 0)) {
|
|
bf_set_inf(r, sign);
|
|
} else {
|
|
/* set to maximum finite number */
|
|
l = (prec + LIMB_BITS - 1) / LIMB_BITS;
|
|
if (bf_resize(r, l)) {
|
|
bf_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
r->tab[0] = limb_mask((-prec) & (LIMB_BITS - 1),
|
|
LIMB_BITS - 1);
|
|
for(i = 1; i < l; i++)
|
|
r->tab[i] = (limb_t)-1;
|
|
e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
|
|
r->expn = e_max;
|
|
r->sign = sign;
|
|
}
|
|
return BF_ST_OVERFLOW | BF_ST_INEXACT;
|
|
}
|
|
|
|
/* 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. */
|
|
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_get_exp_bits(flags) - 1);
|
|
e_min = -e_range + 3;
|
|
e_max = e_range;
|
|
|
|
if (flags & BF_FLAG_RADPNT_PREC) {
|
|
/* 'prec' is the precision after the radix point */
|
|
if (prec1 != BF_PREC_INF)
|
|
prec = r->expn + prec1;
|
|
else
|
|
prec = prec1;
|
|
} else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
|
|
/* restrict the precision in case of potentially subnormal
|
|
result */
|
|
assert(prec1 != BF_PREC_INF);
|
|
prec = prec1 - (e_min - r->expn);
|
|
} else {
|
|
prec = prec1;
|
|
}
|
|
|
|
/* round to prec bits */
|
|
rnd_mode = flags & BF_RND_MASK;
|
|
add_one = bf_get_rnd_add(&ret, r, l, prec, rnd_mode);
|
|
|
|
if (prec <= 0) {
|
|
if (add_one) {
|
|
bf_resize(r, 1); /* cannot fail */
|
|
r->tab[0] = (limb_t)1 << (LIMB_BITS - 1);
|
|
r->expn += 1 - prec;
|
|
ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
|
|
return ret;
|
|
} else {
|
|
goto underflow;
|
|
}
|
|
} else if (add_one) {
|
|
limb_t carry;
|
|
|
|
/* add one starting at digit 'prec - 1' */
|
|
bit_pos = l * LIMB_BITS - 1 - (prec - 1);
|
|
pos = bit_pos >> LIMB_LOG2_BITS;
|
|
carry = (limb_t)1 << (bit_pos & (LIMB_BITS - 1));
|
|
|
|
for(i = pos; i < l; i++) {
|
|
v = r->tab[i] + carry;
|
|
carry = (v < carry);
|
|
r->tab[i] = v;
|
|
if (carry == 0)
|
|
break;
|
|
}
|
|
if (carry) {
|
|
/* shift right by one digit */
|
|
v = 1;
|
|
for(i = l - 1; i >= pos; i--) {
|
|
a = r->tab[i];
|
|
r->tab[i] = (a >> 1) | (v << (LIMB_BITS - 1));
|
|
v = a;
|
|
}
|
|
r->expn++;
|
|
}
|
|
}
|
|
|
|
/* check underflow */
|
|
if (unlikely(r->expn < e_min)) {
|
|
if (flags & BF_FLAG_SUBNORMAL) {
|
|
/* if inexact, also set the underflow flag */
|
|
if (ret & BF_ST_INEXACT)
|
|
ret |= BF_ST_UNDERFLOW;
|
|
} else {
|
|
underflow:
|
|
ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
|
|
bf_set_zero(r, r->sign);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* check overflow */
|
|
if (unlikely(r->expn > e_max))
|
|
return bf_set_overflow(r, r->sign, prec1, flags);
|
|
|
|
/* keep the bits starting at 'prec - 1' */
|
|
bit_pos = l * LIMB_BITS - 1 - (prec - 1);
|
|
i = bit_pos >> LIMB_LOG2_BITS;
|
|
if (i >= 0) {
|
|
shift = bit_pos & (LIMB_BITS - 1);
|
|
if (shift != 0)
|
|
r->tab[i] &= limb_mask(shift, LIMB_BITS - 1);
|
|
} else {
|
|
i = 0;
|
|
}
|
|
/* remove trailing zeros */
|
|
while (r->tab[i] == 0)
|
|
i++;
|
|
if (i > 0) {
|
|
l -= i;
|
|
memmove(r->tab, r->tab + i, l * sizeof(limb_t));
|
|
}
|
|
bf_resize(r, l); /* cannot fail */
|
|
return ret;
|
|
}
|
|
|
|
/* 'r' must be a finite number. */
|
|
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_resize(r, 0); /* cannot fail */
|
|
ret = 0;
|
|
} else {
|
|
r->expn -= (r->len - l) * LIMB_BITS;
|
|
/* shift to have the MSB set to '1' */
|
|
v = r->tab[l - 1];
|
|
shift = clz(v);
|
|
if (shift != 0) {
|
|
v = 0;
|
|
for(i = 0; i < l; i++) {
|
|
a = r->tab[i];
|
|
r->tab[i] = (a << shift) | (v >> (LIMB_BITS - shift));
|
|
v = a;
|
|
}
|
|
r->expn -= shift;
|
|
}
|
|
ret = __bf_round(r, prec1, flags, l, 0);
|
|
}
|
|
// bf_print_str("r_final", r);
|
|
return ret;
|
|
}
|
|
|
|
/* 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 */
|
|
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 FALSE;
|
|
is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
|
|
if (k < (prec + 2))
|
|
return FALSE;
|
|
bit_pos = a->len * LIMB_BITS - 1 - prec;
|
|
n = k - prec;
|
|
/* bit pattern for RNDN or RNDNA: 0111.. or 1000...
|
|
for other rounding modes: 000... or 111...
|
|
*/
|
|
bit = get_bit(a->tab, a->len, bit_pos);
|
|
bit_pos--;
|
|
n--;
|
|
bit ^= is_rndn;
|
|
/* XXX: slow, but a few iterations on average */
|
|
while (n != 0) {
|
|
if (get_bit(a->tab, a->len, bit_pos) != bit)
|
|
return TRUE;
|
|
bit_pos--;
|
|
n--;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/* Cannot fail with BF_ST_MEM_ERROR. */
|
|
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);
|
|
}
|
|
|
|
/* for debugging */
|
|
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]);
|
|
}
|
|
}
|
|
|
|
void mp_print_str(const char *str, const limb_t *tab, limb_t n)
|
|
{
|
|
slimb_t i;
|
|
printf("%s= 0x", str);
|
|
for(i = n - 1; i >= 0; i--) {
|
|
if (i != (n - 1))
|
|
printf("_");
|
|
printf(FMT_LIMB, tab[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static __maybe_unused void mp_print_str_h(const char *str,
|
|
const limb_t *tab, limb_t n,
|
|
limb_t high)
|
|
{
|
|
slimb_t i;
|
|
printf("%s= 0x", str);
|
|
printf(FMT_LIMB, high);
|
|
for(i = n - 1; i >= 0; i--) {
|
|
printf("_");
|
|
printf(FMT_LIMB, tab[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
/* for debugging */
|
|
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) {
|
|
printf("Inf");
|
|
} else {
|
|
printf("0x0.");
|
|
for(i = a->len - 1; i >= 0; i--)
|
|
printf(FMT_LIMB, a->tab[i]);
|
|
printf("p%" PRId_LIMB, a->expn);
|
|
}
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
/* compare the absolute value of 'a' and 'b'. Return < 0 if a < b, 0
|
|
if a = b and > 0 otherwise. */
|
|
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 - len + i);
|
|
v2 = get_limbz(b, b->len - len + i);
|
|
if (v1 != v2) {
|
|
if (v1 < v2)
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Full order: -0 < 0, NaN == NaN and NaN is larger than all other numbers */
|
|
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) {
|
|
res = 1 - 2 * a->sign;
|
|
} else {
|
|
res = bf_cmpu(a, b);
|
|
if (a->sign)
|
|
res = -res;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* 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 */
|
|
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 {
|
|
res = bf_cmpu(a, b);
|
|
if (a->sign)
|
|
res = -res;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* 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
|
|
*/
|
|
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 bits */
|
|
for(;;) {
|
|
v1 = get_limbz(a, bit_offset >> LIMB_LOG2_BITS);
|
|
v2 = get_bits(b->tab, b->len, bit_offset + b_offset);
|
|
// printf("v1=" FMT_LIMB " v2=" FMT_LIMB "\n", v1, v2);
|
|
if (v1 != v2)
|
|
break;
|
|
n += LIMB_BITS;
|
|
bit_offset -= LIMB_BITS;
|
|
}
|
|
/* find the position of the first different bit */
|
|
p = clz(v1 ^ v2) + 1;
|
|
n += p;
|
|
/* then search for '0' in a and '1' in b */
|
|
p = LIMB_BITS - p;
|
|
if (p > 0) {
|
|
/* search in the trailing p bits of v1 and v2 */
|
|
mask = limb_mask(0, p - 1);
|
|
p1 = bf_min(clz(v1 & mask), clz((~v2) & mask)) - (LIMB_BITS - p);
|
|
n += p1;
|
|
if (p1 != p)
|
|
goto done;
|
|
}
|
|
bit_offset -= LIMB_BITS;
|
|
for(;;) {
|
|
v1 = get_limbz(a, bit_offset >> LIMB_LOG2_BITS);
|
|
v2 = get_bits(b->tab, b->len, bit_offset + b_offset);
|
|
// printf("v1=" FMT_LIMB " v2=" FMT_LIMB "\n", v1, v2);
|
|
if (v1 != 0 || v2 != -1) {
|
|
/* different: count the matching bits */
|
|
p1 = bf_min(clz(v1), clz(~v2));
|
|
n += p1;
|
|
break;
|
|
}
|
|
n += LIMB_BITS;
|
|
bit_offset -= LIMB_BITS;
|
|
}
|
|
done:
|
|
return n;
|
|
}
|
|
|
|
static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags, int b_neg)
|
|
{
|
|
const bf_t *tmp;
|
|
int is_sub, ret, cmp_res, a_sign, b_sign;
|
|
|
|
a_sign = a->sign;
|
|
b_sign = b->sign ^ b_neg;
|
|
is_sub = a_sign ^ b_sign;
|
|
cmp_res = bf_cmpu(a, b);
|
|
if (cmp_res < 0) {
|
|
tmp = a;
|
|
a = b;
|
|
b = tmp;
|
|
a_sign = b_sign; /* b_sign is never used later */
|
|
}
|
|
/* abs(a) >= abs(b) */
|
|
if (cmp_res == 0 && is_sub && a->expn < BF_EXP_INF) {
|
|
/* zero result */
|
|
bf_set_zero(r, (flags & BF_RND_MASK) == BF_RNDD);
|
|
ret = 0;
|
|
} else if (a->len == 0 || b->len == 0) {
|
|
ret = 0;
|
|
if (a->expn >= BF_EXP_INF) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
/* at least one operand is NaN */
|
|
bf_set_nan(r);
|
|
} else if (b->expn == BF_EXP_INF && is_sub) {
|
|
/* infinities with different signs */
|
|
bf_set_nan(r);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_inf(r, a_sign);
|
|
}
|
|
} else {
|
|
/* at least one zero and not subtract */
|
|
bf_set(r, a);
|
|
r->sign = a_sign;
|
|
goto renorm;
|
|
}
|
|
} else {
|
|
slimb_t d, a_offset, b_bit_offset, i, cancelled_bits;
|
|
limb_t carry, v1, v2, u, r_len, carry1, precl, tot_len, z, sub_mask;
|
|
|
|
r->sign = a_sign;
|
|
r->expn = a->expn;
|
|
d = a->expn - b->expn;
|
|
/* must add more precision for the leading cancelled bits in
|
|
subtraction */
|
|
if (is_sub) {
|
|
if (d <= 1)
|
|
cancelled_bits = count_cancelled_bits(a, b);
|
|
else
|
|
cancelled_bits = 1;
|
|
} else {
|
|
cancelled_bits = 0;
|
|
}
|
|
|
|
/* add two extra bits for rounding */
|
|
precl = (cancelled_bits + prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
|
|
tot_len = bf_max(a->len, b->len + (d + LIMB_BITS - 1) / LIMB_BITS);
|
|
r_len = bf_min(precl, tot_len);
|
|
if (bf_resize(r, r_len))
|
|
goto fail;
|
|
a_offset = a->len - r_len;
|
|
b_bit_offset = (b->len - r_len) * LIMB_BITS + d;
|
|
|
|
/* compute the bits before for the rounding */
|
|
carry = is_sub;
|
|
z = 0;
|
|
sub_mask = -is_sub;
|
|
i = r_len - tot_len;
|
|
while (i < 0) {
|
|
slimb_t ap, bp;
|
|
BOOL inflag;
|
|
|
|
ap = a_offset + i;
|
|
bp = b_bit_offset + i * LIMB_BITS;
|
|
inflag = FALSE;
|
|
if (ap >= 0 && ap < a->len) {
|
|
v1 = a->tab[ap];
|
|
inflag = TRUE;
|
|
} else {
|
|
v1 = 0;
|
|
}
|
|
if (bp + LIMB_BITS > 0 && bp < (slimb_t)(b->len * LIMB_BITS)) {
|
|
v2 = get_bits(b->tab, b->len, bp);
|
|
inflag = TRUE;
|
|
} else {
|
|
v2 = 0;
|
|
}
|
|
if (!inflag) {
|
|
/* outside 'a' and 'b': go directly to the next value
|
|
inside a or b so that the running time does not
|
|
depend on the exponent difference */
|
|
i = 0;
|
|
if (ap < 0)
|
|
i = bf_min(i, -a_offset);
|
|
/* b_bit_offset + i * LIMB_BITS + LIMB_BITS >= 1
|
|
equivalent to
|
|
i >= ceil(-b_bit_offset + 1 - LIMB_BITS) / LIMB_BITS)
|
|
*/
|
|
if (bp + LIMB_BITS <= 0)
|
|
i = bf_min(i, (-b_bit_offset) >> LIMB_LOG2_BITS);
|
|
} else {
|
|
i++;
|
|
}
|
|
v2 ^= sub_mask;
|
|
u = v1 + v2;
|
|
carry1 = u < v1;
|
|
u += carry;
|
|
carry = (u < carry) | carry1;
|
|
z |= u;
|
|
}
|
|
/* and the result */
|
|
for(i = 0; i < r_len; i++) {
|
|
v1 = get_limbz(a, a_offset + i);
|
|
v2 = get_bits(b->tab, b->len, b_bit_offset + i * LIMB_BITS);
|
|
v2 ^= sub_mask;
|
|
u = v1 + v2;
|
|
carry1 = u < v1;
|
|
u += carry;
|
|
carry = (u < carry) | carry1;
|
|
r->tab[i] = u;
|
|
}
|
|
/* set the extra bits for the rounding */
|
|
r->tab[0] |= (z != 0);
|
|
|
|
/* carry is only possible in add case */
|
|
if (!is_sub && carry) {
|
|
if (bf_resize(r, r_len + 1))
|
|
goto fail;
|
|
r->tab[r_len] = 1;
|
|
r->expn += LIMB_BITS;
|
|
}
|
|
renorm:
|
|
ret = bf_normalize_and_round(r, prec, flags);
|
|
}
|
|
return ret;
|
|
fail:
|
|
bf_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
static int __bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_add_internal(r, a, b, prec, flags, 0);
|
|
}
|
|
|
|
static int __bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_add_internal(r, a, b, prec, flags, 1);
|
|
}
|
|
|
|
limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
|
|
limb_t n, limb_t carry)
|
|
{
|
|
slimb_t i;
|
|
limb_t k, a, v, k1;
|
|
|
|
k = carry;
|
|
for(i=0;i<n;i++) {
|
|
v = op1[i];
|
|
a = v + op2[i];
|
|
k1 = a < v;
|
|
a = a + k;
|
|
k = (a < k) | k1;
|
|
res[i] = a;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n)
|
|
{
|
|
size_t i;
|
|
limb_t k, a;
|
|
|
|
k=b;
|
|
for(i=0;i<n;i++) {
|
|
if (k == 0)
|
|
break;
|
|
a = tab[i] + k;
|
|
k = (a < k);
|
|
tab[i] = a;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
limb_t mp_sub(limb_t *res, const limb_t *op1, 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 = op1[i];
|
|
a = v - op2[i];
|
|
k1 = a > v;
|
|
v = a - k;
|
|
k = (v > a) | k1;
|
|
res[i] = v;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
/* compute 0 - op2 */
|
|
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;
|
|
}
|
|
|
|
limb_t mp_sub_ui(limb_t *tab, limb_t b, mp_size_t n)
|
|
{
|
|
mp_size_t i;
|
|
limb_t k, a, v;
|
|
|
|
k=b;
|
|
for(i=0;i<n;i++) {
|
|
v = tab[i];
|
|
a = v - k;
|
|
k = a > v;
|
|
tab[i] = a;
|
|
if (k == 0)
|
|
break;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift).
|
|
1 <= shift <= LIMB_BITS - 1 */
|
|
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 - shift));
|
|
l = a;
|
|
}
|
|
return l & (((limb_t)1 << shift) - 1);
|
|
}
|
|
|
|
/* tabr[] = taba[] * b + l. Return the high carry */
|
|
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, return the high word. */
|
|
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;
|
|
}
|
|
|
|
/* size of the result : op1_size + op2_size. */
|
|
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(result + i, op1, op1_size, op2[i]);
|
|
result[i + op1_size] = r;
|
|
}
|
|
}
|
|
|
|
/* return 0 if OK, -1 if memory error */
|
|
/* XXX: change API so that result can be allocated */
|
|
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 usage in API */
|
|
if (fft_mul(s, r, (limb_t *)op1, op1_size,
|
|
(limb_t *)op2, op2_size, FFT_MUL_R_NORESIZE))
|
|
return -1;
|
|
} else
|
|
#endif
|
|
{
|
|
mp_mul_basecase(result, op1, op1_size, op2, op2_size);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* tabr[] -= taba[] * b. Return the value to substract to the high
|
|
word. */
|
|
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;
|
|
}
|
|
|
|
/* WARNING: d must be >= 2^(LIMB_BITS-1) */
|
|
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;
|
|
}
|
|
|
|
/* return the quotient and the remainder in '*pr'of 'a1*2^LIMB_BITS+a0
|
|
/ d' with 0 <= a1 < d. */
|
|
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;
|
|
/* compute a - q * r and update q so that the remainder is\
|
|
between 0 and d - 1 */
|
|
a = ((dlimb_t)a1 << LIMB_BITS) | a0;
|
|
a = a - (dlimb_t)q * d - d;
|
|
ah = a >> LIMB_BITS;
|
|
q += 1 + ah;
|
|
r = (limb_t)a + (ah & d);
|
|
*pr = r;
|
|
return q;
|
|
}
|
|
|
|
/* b must be >= 1 << (LIMB_BITS - 1) */
|
|
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_inv);
|
|
}
|
|
} else {
|
|
dlimb_t a1;
|
|
for(i = n - 1; i >= 0; i--) {
|
|
a1 = ((dlimb_t)r << LIMB_BITS) | taba[i];
|
|
tabr[i] = a1 / b;
|
|
r = a1 % b;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
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);
|
|
|
|
/* 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. */
|
|
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;
|
|
}
|
|
n = na - nb;
|
|
if (bf_min(n, nb) >= DIVNORM_LARGE_THRESHOLD) {
|
|
return mp_divnorm_large(s, tabq, taba, na, tabb, nb);
|
|
}
|
|
|
|
if (n >= UDIV1NORM_THRESHOLD)
|
|
b1_inv = udiv1norm_init(b1);
|
|
else
|
|
b1_inv = 0;
|
|
|
|
/* first iteration: the quotient is only 0 or 1 */
|
|
q = 1;
|
|
for(j = nb - 1; j >= 0; j--) {
|
|
if (taba[n + j] != tabb[j]) {
|
|
if (taba[n + j] < tabb[j])
|
|
q = 0;
|
|
break;
|
|
}
|
|
}
|
|
tabq[n] = q;
|
|
if (q) {
|
|
mp_sub(taba + n, taba + n, tabb, nb, 0);
|
|
}
|
|
|
|
for(i = n - 1; i >= 0; i--) {
|
|
if (unlikely(taba[i + nb] >= b1)) {
|
|
q = -1;
|
|
} else if (b1_inv) {
|
|
q = udiv1norm(&dummy_r, taba[i + nb], taba[i + nb - 1], b1, b1_inv);
|
|
} else {
|
|
dlimb_t al;
|
|
al = ((dlimb_t)taba[i + nb] << LIMB_BITS) | taba[i + nb - 1];
|
|
q = al / b1;
|
|
r = al % b1;
|
|
}
|
|
r = mp_sub_mul1(taba + i, tabb, nb, q);
|
|
|
|
v = taba[i + nb];
|
|
a = v - r;
|
|
c = (a > v);
|
|
taba[i + nb] = a;
|
|
|
|
if (c != 0) {
|
|
/* negative result */
|
|
for(;;) {
|
|
q--;
|
|
c = mp_add(taba + i, taba + i, tabb, nb, 0);
|
|
/* propagate carry and test if positive result */
|
|
if (c != 0) {
|
|
if (++taba[i + nb] == 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tabq[i] = q;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* 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 */
|
|
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_malloc(s, sizeof(limb_t) * (n + 2));
|
|
if (!tabt || !tabu)
|
|
goto fail;
|
|
for(i = 0; i < 2 * n; i++)
|
|
tabu[i] = 0;
|
|
tabu[2 * n] = 1;
|
|
if (mp_divnorm(s, tabt, tabu, 2 * n + 1, taba, n))
|
|
goto fail;
|
|
for(i = 0; i < n + 1; i++)
|
|
tabr[i] = tabt[i];
|
|
if (mp_scan_nz(tabu, n) == 0) {
|
|
/* only happens for a=B^n/2 */
|
|
mp_sub_ui(tabr, 1, n + 1);
|
|
}
|
|
} else {
|
|
l = (n - 1) / 2;
|
|
h = n - l;
|
|
/* n=2p -> l=p-1, h = p + 1, k = p + 3
|
|
n=2p+1-> l=p, h = p + 1; k = p + 2
|
|
*/
|
|
tabt = bf_malloc(s, sizeof(limb_t) * (n + h + 1));
|
|
tabu = bf_malloc(s, sizeof(limb_t) * (n + 2 * h - l + 2));
|
|
if (!tabt || !tabu)
|
|
goto fail;
|
|
tabxh = tabr + l;
|
|
if (mp_recip(s, tabxh, taba + l, h))
|
|
goto fail;
|
|
if (mp_mul(s, tabt, taba, n, tabxh, h + 1)) /* n + h + 1 limbs */
|
|
goto fail;
|
|
while (tabt[n + h] != 0) {
|
|
mp_sub_ui(tabxh, 1, h + 1);
|
|
c = mp_sub(tabt, tabt, taba, n, 0);
|
|
mp_sub_ui(tabt + n, c, h + 1);
|
|
}
|
|
/* T = B^(n+h) - T */
|
|
mp_neg(tabt, tabt, n + h + 1, 0);
|
|
tabt[n + h]++;
|
|
if (mp_mul(s, tabu, tabt + l, n + h + 1 - l, tabxh, h + 1))
|
|
goto fail;
|
|
/* n + 2*h - l + 2 limbs */
|
|
k = 2 * h - l;
|
|
for(i = 0; i < l; i++)
|
|
tabr[i] = tabu[i + k];
|
|
mp_add(tabr + l, tabr + l, tabu + 2 * h, h, 0);
|
|
}
|
|
bf_free(s, tabt);
|
|
bf_free(s, tabu);
|
|
return 0;
|
|
fail:
|
|
bf_free(s, tabt);
|
|
bf_free(s, tabu);
|
|
return -1;
|
|
}
|
|
|
|
/* return -1, 0 or 1 */
|
|
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;
|
|
}
|
|
|
|
//#define DEBUG_DIVNORM_LARGE
|
|
//#define DEBUG_DIVNORM_LARGE2
|
|
|
|
/* subquadratic divnorm */
|
|
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);
|
|
mp_print_str("a", taba, na);
|
|
mp_print_str("b", tabb, nb);
|
|
#endif
|
|
assert(nq >= 1);
|
|
n = nq;
|
|
if (nq < nb)
|
|
n++;
|
|
tabb_inv = bf_malloc(s, sizeof(limb_t) * (n + 1));
|
|
tabt = bf_malloc(s, sizeof(limb_t) * 2 * (n + 1));
|
|
if (!tabb_inv || !tabt)
|
|
goto fail;
|
|
|
|
if (n >= nb) {
|
|
for(i = 0; i < n - nb; i++)
|
|
tabt[i] = 0;
|
|
for(i = 0; i < nb; i++)
|
|
tabt[i + n - nb] = tabb[i];
|
|
} else {
|
|
/* truncate B: need to increment it so that the approximate
|
|
inverse is smaller that the exact inverse */
|
|
for(i = 0; i < n; i++)
|
|
tabt[i] = tabb[i + nb - n];
|
|
if (mp_add_ui(tabt, 1, n)) {
|
|
/* tabt = B^n : tabb_inv = B^n */
|
|
memset(tabb_inv, 0, n * sizeof(limb_t));
|
|
tabb_inv[n] = 1;
|
|
goto recip_done;
|
|
}
|
|
}
|
|
if (mp_recip(s, tabb_inv, tabt, n))
|
|
goto fail;
|
|
recip_done:
|
|
/* Q=A*B^-1 */
|
|
if (mp_mul(s, tabt, tabb_inv, n + 1, taba + na - (n + 1), n + 1))
|
|
goto fail;
|
|
|
|
for(i = 0; i < nq + 1; i++)
|
|
tabq[i] = tabt[i + 2 * (n + 1) - (nq + 1)];
|
|
#ifdef DEBUG_DIVNORM_LARGE
|
|
mp_print_str("q", tabq, nq + 1);
|
|
#endif
|
|
|
|
bf_free(s, tabt);
|
|
bf_free(s, tabb_inv);
|
|
tabb_inv = NULL;
|
|
|
|
/* R=A-B*Q */
|
|
tabt = bf_malloc(s, sizeof(limb_t) * (na + 1));
|
|
if (!tabt)
|
|
goto fail;
|
|
if (mp_mul(s, tabt, tabq, nq + 1, tabb, nb))
|
|
goto fail;
|
|
/* we add one more limb for the result */
|
|
mp_sub(taba, taba, tabt, nb + 1, 0);
|
|
bf_free(s, tabt);
|
|
/* the approximated quotient is smaller than than the exact one,
|
|
hence we may have to increment it */
|
|
#ifdef DEBUG_DIVNORM_LARGE2
|
|
int cnt = 0;
|
|
static int cnt_max;
|
|
#endif
|
|
for(;;) {
|
|
if (taba[nb] == 0 && mp_cmp(taba, tabb, nb) < 0)
|
|
break;
|
|
taba[nb] -= mp_sub(taba, taba, tabb, nb, 0);
|
|
mp_add_ui(tabq, 1, nq + 1);
|
|
#ifdef DEBUG_DIVNORM_LARGE2
|
|
cnt++;
|
|
#endif
|
|
}
|
|
#ifdef DEBUG_DIVNORM_LARGE2
|
|
if (cnt > cnt_max) {
|
|
cnt_max = cnt;
|
|
printf("\ncnt=%d nq=%d nb=%d\n", cnt_max, (int)nq, (int)nb);
|
|
}
|
|
#endif
|
|
return 0;
|
|
fail:
|
|
bf_free(s, tabb_inv);
|
|
bf_free(s, tabt);
|
|
return -1;
|
|
}
|
|
|
|
int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
int ret, r_sign;
|
|
|
|
if (a->len < b->len) {
|
|
const bf_t *tmp = a;
|
|
a = b;
|
|
b = tmp;
|
|
}
|
|
r_sign = a->sign ^ b->sign;
|
|
/* here b->len <= a->len */
|
|
if (b->len == 0) {
|
|
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
ret = 0;
|
|
} else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_INF) {
|
|
if ((a->expn == BF_EXP_INF && b->expn == BF_EXP_ZERO) ||
|
|
(a->expn == BF_EXP_ZERO && b->expn == BF_EXP_INF)) {
|
|
bf_set_nan(r);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_inf(r, r_sign);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
bf_set_zero(r, r_sign);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
bf_t tmp, *r1 = NULL;
|
|
limb_t a_len, b_len, precl;
|
|
limb_t *a_tab, *b_tab;
|
|
|
|
a_len = a->len;
|
|
b_len = b->len;
|
|
|
|
if ((flags & BF_RND_MASK) == BF_RNDF) {
|
|
/* faithful rounding does not require using the full inputs */
|
|
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
|
|
a_len = bf_min(a_len, precl);
|
|
b_len = bf_min(b_len, precl);
|
|
}
|
|
a_tab = a->tab + a->len - a_len;
|
|
b_tab = b->tab + b->len - b_len;
|
|
|
|
#ifdef USE_FFT_MUL
|
|
if (b_len >= FFT_MUL_THRESHOLD) {
|
|
int mul_flags = 0;
|
|
if (r == a)
|
|
mul_flags |= FFT_MUL_R_OVERLAP_A;
|
|
if (r == b)
|
|
mul_flags |= FFT_MUL_R_OVERLAP_B;
|
|
if (fft_mul(r->ctx, r, a_tab, a_len, b_tab, b_len, mul_flags))
|
|
goto fail;
|
|
} else
|
|
#endif
|
|
{
|
|
if (r == a || r == b) {
|
|
bf_init(r->ctx, &tmp);
|
|
r1 = r;
|
|
r = &tmp;
|
|
}
|
|
if (bf_resize(r, a_len + b_len)) {
|
|
fail:
|
|
bf_set_nan(r);
|
|
ret = BF_ST_MEM_ERROR;
|
|
goto done;
|
|
}
|
|
mp_mul_basecase(r->tab, a_tab, a_len, b_tab, b_len);
|
|
}
|
|
r->sign = r_sign;
|
|
r->expn = a->expn + b->expn;
|
|
ret = bf_normalize_and_round(r, prec, flags);
|
|
done:
|
|
if (r == &tmp)
|
|
bf_move(r1, &tmp);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* multiply 'r' by 2^e */
|
|
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);
|
|
}
|
|
|
|
/* Return e such as a=m*2^e with m odd integer. return 0 if a is zero,
|
|
Infinite or Nan. */
|
|
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;
|
|
}
|
|
|
|
/* 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. */
|
|
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, BF_RNDZ);
|
|
bf_sub(r, a, r, BF_PREC_INF, BF_RNDZ);
|
|
}
|
|
}
|
|
|
|
static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
int ret, r_sign;
|
|
limb_t n, nb, precl;
|
|
|
|
r_sign = a->sign ^ b->sign;
|
|
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
|
|
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bf_set_inf(r, r_sign);
|
|
return 0;
|
|
} else {
|
|
bf_set_zero(r, r_sign);
|
|
return 0;
|
|
}
|
|
} else if (a->expn == BF_EXP_ZERO) {
|
|
if (b->expn == BF_EXP_ZERO) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_zero(r, r_sign);
|
|
return 0;
|
|
}
|
|
} else if (b->expn == BF_EXP_ZERO) {
|
|
bf_set_inf(r, r_sign);
|
|
return BF_ST_DIVIDE_ZERO;
|
|
}
|
|
|
|
/* number of limbs of the quotient (2 extra bits for rounding) */
|
|
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
|
|
nb = b->len;
|
|
n = bf_max(a->len, precl);
|
|
|
|
{
|
|
limb_t *taba, na;
|
|
slimb_t d;
|
|
|
|
na = n + nb;
|
|
taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
|
|
if (!taba)
|
|
goto fail;
|
|
d = na - a->len;
|
|
memset(taba, 0, d * sizeof(limb_t));
|
|
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
|
|
if (bf_resize(r, n + 1))
|
|
goto fail1;
|
|
if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
|
|
fail1:
|
|
bf_free(s, taba);
|
|
goto fail;
|
|
}
|
|
/* see if non zero remainder */
|
|
if (mp_scan_nz(taba, nb))
|
|
r->tab[0] |= 1;
|
|
bf_free(r->ctx, taba);
|
|
r->expn = a->expn - b->expn + LIMB_BITS;
|
|
r->sign = r_sign;
|
|
ret = bf_normalize_and_round(r, prec, flags);
|
|
}
|
|
return ret;
|
|
fail:
|
|
bf_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
/* 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).
|
|
*/
|
|
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);
|
|
|
|
if (a->len == 0 || b->len == 0) {
|
|
bf_set_zero(q, 0);
|
|
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_ZERO) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set(r, a);
|
|
return bf_round(r, prec, flags);
|
|
}
|
|
}
|
|
|
|
q_sign = a->sign ^ b->sign;
|
|
is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
|
|
switch(rnd_mode) {
|
|
default:
|
|
case BF_RNDZ:
|
|
case BF_RNDN:
|
|
case BF_RNDNA:
|
|
is_ceil = FALSE;
|
|
break;
|
|
case BF_RNDD:
|
|
is_ceil = q_sign;
|
|
break;
|
|
case BF_RNDU:
|
|
is_ceil = q_sign ^ 1;
|
|
break;
|
|
case BF_RNDA:
|
|
is_ceil = TRUE;
|
|
break;
|
|
case BF_DIVREM_EUCLIDIAN:
|
|
is_ceil = a->sign;
|
|
break;
|
|
}
|
|
|
|
a1->expn = a->expn;
|
|
a1->tab = a->tab;
|
|
a1->len = a->len;
|
|
a1->sign = 0;
|
|
|
|
b1->expn = b->expn;
|
|
b1->tab = b->tab;
|
|
b1->len = b->len;
|
|
b1->sign = 0;
|
|
|
|
/* XXX: could improve to avoid having a large 'q' */
|
|
bf_tdivremu(q, r, a1, b1);
|
|
if (bf_is_nan(q) || bf_is_nan(r))
|
|
goto fail;
|
|
|
|
if (r->len != 0) {
|
|
if (is_rndn) {
|
|
int res;
|
|
b1->expn--;
|
|
res = bf_cmpu(r, b1);
|
|
b1->expn++;
|
|
if (res > 0 ||
|
|
(res == 0 &&
|
|
(rnd_mode == BF_RNDNA ||
|
|
get_bit(q->tab, q->len, q->len * LIMB_BITS - q->expn)))) {
|
|
goto do_sub_r;
|
|
}
|
|
} else if (is_ceil) {
|
|
do_sub_r:
|
|
ret = bf_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
|
|
ret |= bf_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
|
|
if (ret & BF_ST_MEM_ERROR)
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
r->sign ^= a->sign;
|
|
q->sign = q_sign;
|
|
return bf_round(r, prec, flags);
|
|
fail:
|
|
bf_set_nan(q);
|
|
bf_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags, int rnd_mode)
|
|
{
|
|
bf_t q_s, *q = &q_s;
|
|
int ret;
|
|
|
|
bf_init(r->ctx, q);
|
|
ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
|
|
bf_delete(q);
|
|
return ret;
|
|
}
|
|
|
|
static inline int bf_get_limb(slimb_t *pres, const bf_t *a, int flags)
|
|
{
|
|
#if LIMB_BITS == 32
|
|
return bf_get_int32(pres, a, flags);
|
|
#else
|
|
return bf_get_int64(pres, a, flags);
|
|
#endif
|
|
}
|
|
|
|
int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags, int rnd_mode)
|
|
{
|
|
bf_t q_s, *q = &q_s;
|
|
int ret;
|
|
|
|
bf_init(r->ctx, q);
|
|
ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
|
|
bf_get_limb(pq, q, BF_GET_INT_MOD);
|
|
bf_delete(q);
|
|
return ret;
|
|
}
|
|
|
|
static __maybe_unused inline limb_t mul_mod(limb_t a, limb_t b, limb_t m)
|
|
{
|
|
dlimb_t t;
|
|
t = (dlimb_t)a * (dlimb_t)b;
|
|
return t % m;
|
|
}
|
|
|
|
#if defined(USE_MUL_CHECK)
|
|
static limb_t mp_mod1(const limb_t *tab, limb_t n, limb_t m, limb_t r)
|
|
{
|
|
slimb_t i;
|
|
dlimb_t t;
|
|
|
|
for(i = n - 1; i >= 0; i--) {
|
|
t = ((dlimb_t)r << LIMB_BITS) | tab[i];
|
|
r = t % m;
|
|
}
|
|
return r;
|
|
}
|
|
#endif
|
|
|
|
static const uint16_t sqrt_table[192] = {
|
|
128,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,144,145,146,147,148,149,150,150,151,152,153,154,155,155,156,157,158,159,160,160,161,162,163,163,164,165,166,167,167,168,169,170,170,171,172,173,173,174,175,176,176,177,178,178,179,180,181,181,182,183,183,184,185,185,186,187,187,188,189,189,190,191,192,192,193,193,194,195,195,196,197,197,198,199,199,200,201,201,202,203,203,204,204,205,206,206,207,208,208,209,209,210,211,211,212,212,213,214,214,215,215,216,217,217,218,218,219,219,220,221,221,222,222,223,224,224,225,225,226,226,227,227,228,229,229,230,230,231,231,232,232,233,234,234,235,235,236,236,237,237,238,238,239,240,240,241,241,242,242,243,243,244,244,245,245,246,246,247,247,248,248,249,249,250,250,251,251,252,252,253,253,254,254,255,
|
|
};
|
|
|
|
/* a >= 2^(LIMB_BITS - 2). Return (s, r) with s=floor(sqrt(a)) and
|
|
r=a-s^2. 0 <= r <= 2 * s */
|
|
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 iteration to get a 32 -> 16 bit sqrt */
|
|
num = (r1 << 8) | ((a >> (LIMB_BITS - 32 + 8)) & 0xff);
|
|
q = num / (2 * s1); /* q <= 2^8 */
|
|
u = num % (2 * s1);
|
|
s = (s1 << 8) + q;
|
|
r = (u << 8) | ((a >> (LIMB_BITS - 32)) & 0xff);
|
|
r -= q * q;
|
|
if ((slimb_t)r < 0) {
|
|
s--;
|
|
r += 2 * s + 1;
|
|
}
|
|
|
|
#if LIMB_BITS == 64
|
|
s1 = s;
|
|
r1 = r;
|
|
/* one more iteration for 64 -> 32 bit sqrt */
|
|
num = (r1 << 16) | ((a >> (LIMB_BITS - 64 + 16)) & 0xffff);
|
|
q = num / (2 * s1); /* q <= 2^16 */
|
|
u = num % (2 * s1);
|
|
s = (s1 << 16) + q;
|
|
r = (u << 16) | ((a >> (LIMB_BITS - 64)) & 0xffff);
|
|
r -= q * q;
|
|
if ((slimb_t)r < 0) {
|
|
s--;
|
|
r += 2 * s + 1;
|
|
}
|
|
#endif
|
|
*pr = r;
|
|
return s;
|
|
}
|
|
|
|
/* return floor(sqrt(a)) */
|
|
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;
|
|
}
|
|
|
|
static limb_t mp_sqrtrem2(limb_t *tabs, limb_t *taba)
|
|
{
|
|
limb_t s1, r1, s, q, u, a0, a1;
|
|
dlimb_t r, num;
|
|
int l;
|
|
|
|
a0 = taba[0];
|
|
a1 = taba[1];
|
|
s1 = mp_sqrtrem1(&r1, a1);
|
|
l = LIMB_BITS / 2;
|
|
num = ((dlimb_t)r1 << l) | (a0 >> l);
|
|
q = num / (2 * s1);
|
|
u = num % (2 * s1);
|
|
s = (s1 << l) + q;
|
|
r = ((dlimb_t)u << l) | (a0 & (((limb_t)1 << l) - 1));
|
|
if (unlikely((q >> l) != 0))
|
|
r -= (dlimb_t)1 << LIMB_BITS; /* special case when q=2^l */
|
|
else
|
|
r -= q * q;
|
|
if ((slimb_t)(r >> LIMB_BITS) < 0) {
|
|
s--;
|
|
r += 2 * (dlimb_t)s + 1;
|
|
}
|
|
tabs[0] = s;
|
|
taba[0] = r;
|
|
return r >> LIMB_BITS;
|
|
}
|
|
|
|
//#define DEBUG_SQRTREM
|
|
|
|
/* tmp_buf must contain (n / 2 + 1 limbs). *prh contains the highest
|
|
limb of the remainder. */
|
|
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);
|
|
#endif
|
|
l = n / 2;
|
|
h = n - l;
|
|
if (mp_sqrtrem_rec(s, tabs + l, taba + 2 * l, h, tmp_buf, &qh))
|
|
return -1;
|
|
#ifdef DEBUG_SQRTREM
|
|
mp_print_str("s1", tabs + l, h);
|
|
mp_print_str_h("r1", taba + 2 * l, h, qh);
|
|
mp_print_str_h("r2", taba + l, n, qh);
|
|
#endif
|
|
|
|
/* the remainder is in taba + 2 * l. Its high bit is in qh */
|
|
if (qh) {
|
|
mp_sub(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
|
|
}
|
|
/* instead of dividing by 2*s, divide by s (which is normalized)
|
|
and update q and r */
|
|
if (mp_divnorm(s, tmp_buf, taba + l, n, tabs + l, h))
|
|
return -1;
|
|
qh += tmp_buf[l];
|
|
for(i = 0; i < l; i++)
|
|
tabs[i] = tmp_buf[i];
|
|
ql = mp_shr(tabs, tabs, l, 1, qh & 1);
|
|
qh = qh >> 1; /* 0 or 1 */
|
|
if (ql)
|
|
rh = mp_add(taba + l, taba + l, tabs + l, h, 0);
|
|
else
|
|
rh = 0;
|
|
#ifdef DEBUG_SQRTREM
|
|
mp_print_str_h("q", tabs, l, qh);
|
|
mp_print_str_h("u", taba + l, h, rh);
|
|
#endif
|
|
|
|
mp_add_ui(tabs + l, qh, h);
|
|
#ifdef DEBUG_SQRTREM
|
|
mp_print_str_h("s2", tabs, n, sh);
|
|
#endif
|
|
|
|
/* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
|
|
/* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
|
|
if (qh) {
|
|
c = qh;
|
|
} else {
|
|
if (mp_mul(s, taba + n, tabs, l, tabs, l))
|
|
return -1;
|
|
c = mp_sub(taba, taba, taba + n, 2 * l, 0);
|
|
}
|
|
rh -= mp_sub_ui(taba + 2 * l, c, n - 2 * l);
|
|
if ((slimb_t)rh < 0) {
|
|
mp_sub_ui(tabs, 1, n);
|
|
rh += mp_add_mul1(taba, tabs, n, 2);
|
|
rh += mp_add_ui(taba, 1, n);
|
|
}
|
|
*prh = rh;
|
|
return 0;
|
|
}
|
|
|
|
/* '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 Paul Zimmermann and
|
|
inspirated from its GMP implementation */
|
|
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)
|
|
return -1;
|
|
}
|
|
ret = mp_sqrtrem_rec(s, tabs, taba, n, tmp_buf, taba + n);
|
|
if (tmp_buf != tmp_buf1)
|
|
bf_free(s, tmp_buf);
|
|
return ret;
|
|
}
|
|
|
|
/* 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. */
|
|
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)
|
|
bf_set_ui(rem1, 0);
|
|
ret = 0;
|
|
} else if (a->sign) {
|
|
invalid_op:
|
|
bf_set_nan(r);
|
|
if (rem1)
|
|
bf_set_ui(rem1, 0);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_t rem_s, *rem;
|
|
|
|
bf_sqrt(r, a, (a->expn + 1) / 2, BF_RNDZ);
|
|
bf_rint(r, BF_RNDZ);
|
|
/* see if the result is exact by computing the remainder */
|
|
if (rem1) {
|
|
rem = rem1;
|
|
} else {
|
|
rem = &rem_s;
|
|
bf_init(r->ctx, rem);
|
|
}
|
|
/* XXX: could avoid recomputing the remainder */
|
|
bf_mul(rem, r, r, BF_PREC_INF, BF_RNDZ);
|
|
bf_neg(rem);
|
|
bf_add(rem, rem, a, BF_PREC_INF, BF_RNDZ);
|
|
if (bf_is_nan(rem)) {
|
|
ret = BF_ST_MEM_ERROR;
|
|
goto done;
|
|
}
|
|
if (rem->len != 0) {
|
|
ret = BF_ST_INEXACT;
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
done:
|
|
if (!rem1)
|
|
bf_delete(rem);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = a->ctx;
|
|
int ret;
|
|
|
|
assert(r != a);
|
|
|
|
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);
|
|
}
|
|
ret = 0;
|
|
} else if (a->sign) {
|
|
invalid_op:
|
|
bf_set_nan(r);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
limb_t *a1;
|
|
slimb_t n, n1;
|
|
limb_t res;
|
|
|
|
/* convert the mantissa to an integer with at least 2 *
|
|
prec + 4 bits */
|
|
n = (2 * (prec + 2) + 2 * LIMB_BITS - 1) / (2 * LIMB_BITS);
|
|
if (bf_resize(r, n))
|
|
goto fail;
|
|
a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
|
|
if (!a1)
|
|
goto fail;
|
|
n1 = bf_min(2 * n, a->len);
|
|
memset(a1, 0, (2 * n - n1) * sizeof(limb_t));
|
|
memcpy(a1 + 2 * n - n1, a->tab + a->len - n1, n1 * sizeof(limb_t));
|
|
if (a->expn & 1) {
|
|
res = mp_shr(a1, a1, 2 * n, 1, 0);
|
|
} else {
|
|
res = 0;
|
|
}
|
|
if (mp_sqrtrem(s, r->tab, a1, n)) {
|
|
bf_free(s, a1);
|
|
goto fail;
|
|
}
|
|
if (!res) {
|
|
res = mp_scan_nz(a1, n + 1);
|
|
}
|
|
bf_free(s, a1);
|
|
if (!res) {
|
|
res = mp_scan_nz(a->tab, a->len - n1);
|
|
}
|
|
if (res != 0)
|
|
r->tab[0] |= 1;
|
|
r->sign = 0;
|
|
r->expn = (a->expn + 1) >> 1;
|
|
ret = bf_round(r, prec, flags);
|
|
}
|
|
return ret;
|
|
fail:
|
|
bf_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
static no_inline int bf_op2(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags, bf_op2_func_t *func)
|
|
{
|
|
bf_t tmp;
|
|
int ret;
|
|
|
|
if (r == a || r == b) {
|
|
bf_init(r->ctx, &tmp);
|
|
ret = func(&tmp, a, b, prec, flags);
|
|
bf_move(r, &tmp);
|
|
} else {
|
|
ret = func(r, a, b, prec, flags);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int bf_add(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_op2(r, a, b, prec, flags, __bf_add);
|
|
}
|
|
|
|
int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_op2(r, a, b, prec, flags, __bf_sub);
|
|
}
|
|
|
|
int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_op2(r, a, b, prec, flags, __bf_div);
|
|
}
|
|
|
|
int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
bf_t b;
|
|
int ret;
|
|
bf_init(r->ctx, &b);
|
|
ret = bf_set_ui(&b, b1);
|
|
ret |= bf_mul(r, a, &b, prec, flags);
|
|
bf_delete(&b);
|
|
return ret;
|
|
}
|
|
|
|
int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
bf_t b;
|
|
int ret;
|
|
bf_init(r->ctx, &b);
|
|
ret = bf_set_si(&b, b1);
|
|
ret |= bf_mul(r, a, &b, prec, flags);
|
|
bf_delete(&b);
|
|
return ret;
|
|
}
|
|
|
|
int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
bf_t b;
|
|
int ret;
|
|
|
|
bf_init(r->ctx, &b);
|
|
ret = bf_set_si(&b, b1);
|
|
ret |= bf_add(r, a, &b, prec, flags);
|
|
bf_delete(&b);
|
|
return ret;
|
|
}
|
|
|
|
static int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
int ret, n_bits, i;
|
|
|
|
assert(r != a);
|
|
if (b == 0)
|
|
return bf_set_ui(r, 1);
|
|
ret = bf_set(r, a);
|
|
n_bits = LIMB_BITS - clz(b);
|
|
for(i = n_bits - 2; i >= 0; i--) {
|
|
ret |= bf_mul(r, r, r, prec, flags);
|
|
if ((b >> i) & 1)
|
|
ret |= bf_mul(r, r, a, prec, flags);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
|
|
limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_t a;
|
|
int ret;
|
|
|
|
if (a1 == 10 && b <= LIMB_DIGITS) {
|
|
/* use precomputed powers. We do not round at this point
|
|
because we expect the caller to do it */
|
|
ret = bf_set_ui(r, mp_pow_dec[b]);
|
|
} else {
|
|
bf_init(r->ctx, &a);
|
|
ret = bf_set_ui(&a, a1);
|
|
ret |= bf_pow_ui(r, &a, b, prec, flags);
|
|
bf_delete(&a);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* convert to integer (infinite precision) */
|
|
int bf_rint(bf_t *r, int rnd_mode)
|
|
{
|
|
return bf_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
|
|
}
|
|
|
|
/* logical operations */
|
|
#define BF_LOGIC_OR 0
|
|
#define BF_LOGIC_XOR 1
|
|
#define BF_LOGIC_AND 2
|
|
|
|
static inline limb_t bf_logic_op1(limb_t a, limb_t b, int op)
|
|
{
|
|
switch(op) {
|
|
case BF_LOGIC_OR:
|
|
return a | b;
|
|
case BF_LOGIC_XOR:
|
|
return a ^ b;
|
|
default:
|
|
case BF_LOGIC_AND:
|
|
return a & b;
|
|
}
|
|
}
|
|
|
|
static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
|
|
{
|
|
bf_t b1_s, a1_s, *a, *b;
|
|
limb_t a_sign, b_sign, r_sign;
|
|
slimb_t l, i, a_bit_offset, b_bit_offset;
|
|
limb_t v1, v2, v1_mask, v2_mask, r_mask;
|
|
int ret;
|
|
|
|
assert(r != a1 && r != b1);
|
|
|
|
if (a1->expn <= 0)
|
|
a_sign = 0; /* minus zero is considered as positive */
|
|
else
|
|
a_sign = a1->sign;
|
|
|
|
if (b1->expn <= 0)
|
|
b_sign = 0; /* minus zero is considered as positive */
|
|
else
|
|
b_sign = b1->sign;
|
|
|
|
if (a_sign) {
|
|
a = &a1_s;
|
|
bf_init(r->ctx, a);
|
|
if (bf_add_si(a, a1, 1, BF_PREC_INF, BF_RNDZ)) {
|
|
b = NULL;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
a = (bf_t *)a1;
|
|
}
|
|
|
|
if (b_sign) {
|
|
b = &b1_s;
|
|
bf_init(r->ctx, b);
|
|
if (bf_add_si(b, b1, 1, BF_PREC_INF, BF_RNDZ))
|
|
goto fail;
|
|
} else {
|
|
b = (bf_t *)b1;
|
|
}
|
|
|
|
r_sign = bf_logic_op1(a_sign, b_sign, op);
|
|
if (op == BF_LOGIC_AND && r_sign == 0) {
|
|
/* no need to compute extra zeros for and */
|
|
if (a_sign == 0 && b_sign == 0)
|
|
l = bf_min(a->expn, b->expn);
|
|
else if (a_sign == 0)
|
|
l = a->expn;
|
|
else
|
|
l = b->expn;
|
|
} else {
|
|
l = bf_max(a->expn, b->expn);
|
|
}
|
|
/* Note: a or b can be zero */
|
|
l = (bf_max(l, 1) + LIMB_BITS - 1) / LIMB_BITS;
|
|
if (bf_resize(r, l))
|
|
goto fail;
|
|
a_bit_offset = a->len * LIMB_BITS - a->expn;
|
|
b_bit_offset = b->len * LIMB_BITS - b->expn;
|
|
v1_mask = -a_sign;
|
|
v2_mask = -b_sign;
|
|
r_mask = -r_sign;
|
|
for(i = 0; i < l; i++) {
|
|
v1 = get_bits(a->tab, a->len, a_bit_offset + i * LIMB_BITS) ^ v1_mask;
|
|
v2 = get_bits(b->tab, b->len, b_bit_offset + i * LIMB_BITS) ^ v2_mask;
|
|
r->tab[i] = bf_logic_op1(v1, v2, op) ^ r_mask;
|
|
}
|
|
r->expn = l * LIMB_BITS;
|
|
r->sign = r_sign;
|
|
bf_normalize_and_round(r, BF_PREC_INF, BF_RNDZ); /* cannot fail */
|
|
if (r_sign) {
|
|
if (bf_add_si(r, r, -1, BF_PREC_INF, BF_RNDZ))
|
|
goto fail;
|
|
}
|
|
ret = 0;
|
|
done:
|
|
if (a == &a1_s)
|
|
bf_delete(a);
|
|
if (b == &b1_s)
|
|
bf_delete(b);
|
|
return ret;
|
|
fail:
|
|
bf_set_nan(r);
|
|
ret = BF_ST_MEM_ERROR;
|
|
goto done;
|
|
}
|
|
|
|
/* 'a' and 'b' must be integers. Return 0 or BF_ST_MEM_ERROR. */
|
|
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. */
|
|
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. */
|
|
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);
|
|
}
|
|
|
|
/* conversion between fixed size types */
|
|
|
|
typedef union {
|
|
double d;
|
|
uint64_t u;
|
|
} Float64Union;
|
|
|
|
int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode)
|
|
{
|
|
Float64Union u;
|
|
int e, ret;
|
|
uint64_t m;
|
|
|
|
ret = 0;
|
|
if (a->expn == BF_EXP_NAN) {
|
|
u.u = 0x7ff8000000000000; /* quiet nan */
|
|
} else {
|
|
bf_t b_s, *b = &b_s;
|
|
|
|
bf_init(a->ctx, b);
|
|
bf_set(b, a);
|
|
if (bf_is_finite(b)) {
|
|
ret = bf_round(b, 53, rnd_mode | BF_FLAG_SUBNORMAL | bf_set_exp_bits(11));
|
|
}
|
|
if (b->expn == BF_EXP_INF) {
|
|
e = (1 << 11) - 1;
|
|
m = 0;
|
|
} else if (b->expn == BF_EXP_ZERO) {
|
|
e = 0;
|
|
m = 0;
|
|
} else {
|
|
e = b->expn + 1023 - 1;
|
|
#if LIMB_BITS == 32
|
|
if (b->len == 2) {
|
|
m = ((uint64_t)b->tab[1] << 32) | b->tab[0];
|
|
} else {
|
|
m = ((uint64_t)b->tab[0] << 32);
|
|
}
|
|
#else
|
|
m = b->tab[0];
|
|
#endif
|
|
if (e <= 0) {
|
|
/* subnormal */
|
|
m = m >> (12 - e);
|
|
e = 0;
|
|
} else {
|
|
m = (m << 1) >> 12;
|
|
}
|
|
}
|
|
u.u = m | ((uint64_t)e << 52) | ((uint64_t)b->sign << 63);
|
|
bf_delete(b);
|
|
}
|
|
*pres = u.d;
|
|
return ret;
|
|
}
|
|
|
|
int bf_set_float64(bf_t *a, double d)
|
|
{
|
|
Float64Union u;
|
|
uint64_t m;
|
|
int shift, e, sgn;
|
|
|
|
u.d = d;
|
|
sgn = u.u >> 63;
|
|
e = (u.u >> 52) & ((1 << 11) - 1);
|
|
m = u.u & (((uint64_t)1 << 52) - 1);
|
|
if (e == ((1 << 11) - 1)) {
|
|
if (m != 0) {
|
|
bf_set_nan(a);
|
|
} else {
|
|
bf_set_inf(a, sgn);
|
|
}
|
|
} else if (e == 0) {
|
|
if (m == 0) {
|
|
bf_set_zero(a, sgn);
|
|
} else {
|
|
/* subnormal number */
|
|
m <<= 12;
|
|
shift = clz64(m);
|
|
m <<= shift;
|
|
e = -shift;
|
|
goto norm;
|
|
}
|
|
} else {
|
|
m = (m << 11) | ((uint64_t)1 << 63);
|
|
norm:
|
|
a->expn = e - 1023 + 1;
|
|
#if LIMB_BITS == 32
|
|
if (bf_resize(a, 2))
|
|
goto fail;
|
|
a->tab[0] = m;
|
|
a->tab[1] = m >> 32;
|
|
#else
|
|
if (bf_resize(a, 1))
|
|
goto fail;
|
|
a->tab[0] = m;
|
|
#endif
|
|
a->sign = sgn;
|
|
}
|
|
return 0;
|
|
fail:
|
|
bf_set_nan(a);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
|
|
is an overflow and 0 otherwise. */
|
|
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 {
|
|
v = INT32_MAX;
|
|
}
|
|
} else if (a->expn <= 0) {
|
|
v = 0;
|
|
ret = 0;
|
|
} else if (a->expn <= 31) {
|
|
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
|
|
if (a->sign)
|
|
v = -v;
|
|
ret = 0;
|
|
} else if (!(flags & BF_GET_INT_MOD)) {
|
|
ret = BF_ST_INVALID_OP;
|
|
if (a->sign) {
|
|
v = (uint32_t)INT32_MAX + 1;
|
|
if (a->expn == 32 &&
|
|
(a->tab[a->len - 1] >> (LIMB_BITS - 32)) == v) {
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
v = INT32_MAX;
|
|
}
|
|
} else {
|
|
v = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
|
|
if (a->sign)
|
|
v = -v;
|
|
ret = 0;
|
|
}
|
|
*pres = v;
|
|
return ret;
|
|
}
|
|
|
|
/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
|
|
is an overflow and 0 otherwise. */
|
|
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 {
|
|
v = INT64_MAX;
|
|
}
|
|
} else if (a->expn <= 0) {
|
|
v = 0;
|
|
ret = 0;
|
|
} else if (a->expn <= 63) {
|
|
#if LIMB_BITS == 32
|
|
if (a->expn <= 32)
|
|
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
|
|
else
|
|
v = (((uint64_t)a->tab[a->len - 1] << 32) |
|
|
get_limbz(a, a->len - 2)) >> (64 - a->expn);
|
|
#else
|
|
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
|
|
#endif
|
|
if (a->sign)
|
|
v = -v;
|
|
ret = 0;
|
|
} else if (!(flags & BF_GET_INT_MOD)) {
|
|
ret = BF_ST_INVALID_OP;
|
|
if (a->sign) {
|
|
uint64_t v1;
|
|
v = (uint64_t)INT64_MAX + 1;
|
|
if (a->expn == 64) {
|
|
v1 = a->tab[a->len - 1];
|
|
#if LIMB_BITS == 32
|
|
v1 = (v1 << 32) | get_limbz(a, a->len - 2);
|
|
#endif
|
|
if (v1 == v)
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
v = INT64_MAX;
|
|
}
|
|
} else {
|
|
slimb_t bit_pos = a->len * LIMB_BITS - a->expn;
|
|
v = get_bits(a->tab, a->len, bit_pos);
|
|
#if LIMB_BITS == 32
|
|
v |= (uint64_t)get_bits(a->tab, a->len, bit_pos + 32) << 32;
|
|
#endif
|
|
if (a->sign)
|
|
v = -v;
|
|
ret = 0;
|
|
}
|
|
*pres = v;
|
|
return ret;
|
|
}
|
|
|
|
/* The rounding mode is always BF_RNDZ. Return BF_ST_INVALID_OP if there
|
|
is an overflow and 0 otherwise. */
|
|
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 == 32
|
|
if (a->expn <= 32)
|
|
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
|
|
else
|
|
v = (((uint64_t)a->tab[a->len - 1] << 32) |
|
|
get_limbz(a, a->len - 2)) >> (64 - a->expn);
|
|
#else
|
|
v = a->tab[a->len - 1] >> (LIMB_BITS - a->expn);
|
|
#endif
|
|
ret = 0;
|
|
} else {
|
|
overflow:
|
|
v = UINT64_MAX;
|
|
ret = BF_ST_INVALID_OP;
|
|
}
|
|
*pres = v;
|
|
return ret;
|
|
}
|
|
|
|
/* base conversion from radix */
|
|
|
|
static const uint8_t digits_per_limb_table[BF_RADIX_MAX - 1] = {
|
|
#if LIMB_BITS == 32
|
|
32,20,16,13,12,11,10,10, 9, 9, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
|
|
#else
|
|
64,40,32,27,24,22,21,20,19,18,17,17,16,16,16,15,15,15,14,14,14,14,13,13,13,13,13,13,13,12,12,12,12,12,12,
|
|
#endif
|
|
};
|
|
|
|
static limb_t get_limb_radix(int radix)
|
|
{
|
|
int i, k;
|
|
limb_t radixl;
|
|
|
|
k = digits_per_limb_table[radix - 2];
|
|
radixl = radix;
|
|
for(i = 1; i < k; i++)
|
|
radixl *= radix;
|
|
return radixl;
|
|
}
|
|
|
|
/* return != 0 if error */
|
|
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;
|
|
limb_t n1, n2;
|
|
|
|
n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
|
|
n1 = n - n2;
|
|
// printf("level=%d n0=%ld n1=%ld n2=%ld\n", level, n0, n1, n2);
|
|
B = &pow_tab[level];
|
|
if (B->len == 0) {
|
|
ret = bf_pow_ui_ui(B, radix, n2, BF_PREC_INF, BF_RNDZ);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
ret = bf_integer_from_radix_rec(r, tab + n2, n1, level + 1, n0,
|
|
radix, pow_tab);
|
|
if (ret)
|
|
return ret;
|
|
ret = bf_mul(r, r, B, BF_PREC_INF, BF_RNDZ);
|
|
if (ret)
|
|
return ret;
|
|
bf_init(r->ctx, T);
|
|
ret = bf_integer_from_radix_rec(T, tab, n2, level + 1, n0,
|
|
radix, pow_tab);
|
|
if (!ret)
|
|
ret = bf_add(r, r, T, BF_PREC_INF, BF_RNDZ);
|
|
bf_delete(T);
|
|
}
|
|
return ret;
|
|
// bf_print_str(" r=", r);
|
|
}
|
|
|
|
/* return 0 if OK != 0 if memory error */
|
|
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_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
|
|
if (!pow_tab)
|
|
return -1;
|
|
for(i = 0; i < pow_tab_len; i++)
|
|
bf_init(r->ctx, &pow_tab[i]);
|
|
ret = bf_integer_from_radix_rec(r, tab, n, 0, n, radixl, pow_tab);
|
|
for(i = 0; i < pow_tab_len; i++) {
|
|
bf_delete(&pow_tab[i]);
|
|
}
|
|
bf_free(s, pow_tab);
|
|
return ret;
|
|
}
|
|
|
|
/* compute and round T * radix^expn. */
|
|
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) {
|
|
ret = bf_set(r, T);
|
|
ret |= bf_round(r, prec, flags);
|
|
return ret;
|
|
}
|
|
|
|
e = expn;
|
|
expn_sign = 0;
|
|
if (e < 0) {
|
|
e = -e;
|
|
expn_sign = 1;
|
|
}
|
|
bf_init(r->ctx, B);
|
|
if (prec == BF_PREC_INF) {
|
|
/* infinite precision: only used if the result is known to be exact */
|
|
ret = bf_pow_ui_ui(B, radix, e, BF_PREC_INF, BF_RNDN);
|
|
if (expn_sign) {
|
|
ret |= bf_div(r, T, B, T->len * LIMB_BITS, BF_RNDN);
|
|
} else {
|
|
ret |= bf_mul(r, T, B, BF_PREC_INF, BF_RNDN);
|
|
}
|
|
} else {
|
|
ziv_extra_bits = 16;
|
|
for(;;) {
|
|
prec1 = prec + ziv_extra_bits;
|
|
/* XXX: correct overflow/underflow handling */
|
|
/* XXX: rigorous error analysis needed */
|
|
extra_bits = ceil_log2(e) * 2 + 1;
|
|
ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
|
|
overflow = !bf_is_finite(B);
|
|
/* XXX: if bf_pow_ui_ui returns an exact result, can stop
|
|
after the next operation */
|
|
if (expn_sign)
|
|
ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
|
|
else
|
|
ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
|
|
if (ret & BF_ST_MEM_ERROR)
|
|
break;
|
|
if ((ret & BF_ST_INEXACT) &&
|
|
!bf_can_round(r, prec, flags & BF_RND_MASK, prec1) &&
|
|
!overflow) {
|
|
/* and more precision and retry */
|
|
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
|
|
} else {
|
|
/* XXX: need to use __bf_round() to pass the inexact
|
|
flag for the subnormal case */
|
|
ret = bf_round(r, prec, flags) | (ret & BF_ST_INEXACT);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
bf_delete(B);
|
|
return ret;
|
|
}
|
|
|
|
static inline int to_digit(int c)
|
|
{
|
|
if (c >= '0' && c <= '9')
|
|
return c - '0';
|
|
else if (c >= 'A' && c <= 'Z')
|
|
return c - 'A' + 10;
|
|
else if (c >= 'a' && c <= 'z')
|
|
return c - 'a' + 10;
|
|
else
|
|
return 36;
|
|
}
|
|
|
|
/* add a limb at 'pos' and decrement pos. new space is created if
|
|
needed. Return 0 if OK, -1 if memory error */
|
|
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)
|
|
return -1;
|
|
a->tab = new_tab;
|
|
d = new_size - a->len;
|
|
memmove(a->tab + d, a->tab, a->len * sizeof(limb_t));
|
|
a->len = new_size;
|
|
pos += d;
|
|
}
|
|
a->tab[pos--] = v;
|
|
*ppos = pos;
|
|
return 0;
|
|
}
|
|
|
|
static int bf_tolower(int c)
|
|
{
|
|
if (c >= 'A' && c <= 'Z')
|
|
c = c - 'A' + 'a';
|
|
return c;
|
|
}
|
|
|
|
static int strcasestart(const char *str, const char *val, const char **ptr)
|
|
{
|
|
const char *p, *q;
|
|
p = str;
|
|
q = val;
|
|
while (*q != '\0') {
|
|
if (bf_tolower(*p) != *q)
|
|
return 0;
|
|
p++;
|
|
q++;
|
|
}
|
|
if (ptr)
|
|
*ptr = p;
|
|
return 1;
|
|
}
|
|
|
|
static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
|
|
const char *str, const char **pnext, int radix,
|
|
limb_t prec, bf_flags_t flags, BOOL is_dec)
|
|
{
|
|
const char *p, *p_start;
|
|
int is_neg, radix_bits, exp_is_neg, ret, digits_per_limb, shift;
|
|
limb_t cur_limb;
|
|
slimb_t pos, expn, int_len, digit_count;
|
|
BOOL has_decpt, is_bin_exp;
|
|
bf_t a_s, *a;
|
|
|
|
*pexponent = 0;
|
|
p = str;
|
|
if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
|
|
strcasestart(p, "nan", &p)) {
|
|
bf_set_nan(r);
|
|
ret = 0;
|
|
goto done;
|
|
}
|
|
is_neg = 0;
|
|
|
|
if (p[0] == '+') {
|
|
p++;
|
|
p_start = p;
|
|
} else if (p[0] == '-') {
|
|
is_neg = 1;
|
|
p++;
|
|
p_start = p;
|
|
} else {
|
|
p_start = p;
|
|
}
|
|
if (p[0] == '0') {
|
|
if ((p[1] == 'x' || p[1] == 'X') &&
|
|
(radix == 0 || radix == 16) &&
|
|
!(flags & BF_ATOF_NO_HEX)) {
|
|
radix = 16;
|
|
p += 2;
|
|
} else if ((p[1] == 'o' || p[1] == 'O') &&
|
|
radix == 0 && (flags & BF_ATOF_BIN_OCT)) {
|
|
p += 2;
|
|
radix = 8;
|
|
} else if ((p[1] == 'b' || p[1] == 'B') &&
|
|
radix == 0 && (flags & BF_ATOF_BIN_OCT)) {
|
|
p += 2;
|
|
radix = 2;
|
|
} else {
|
|
goto no_prefix;
|
|
}
|
|
/* there must be a digit after the prefix */
|
|
if (to_digit((uint8_t)*p) >= radix) {
|
|
bf_set_nan(r);
|
|
ret = 0;
|
|
goto done;
|
|
}
|
|
no_prefix: ;
|
|
} else {
|
|
if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
|
|
strcasestart(p, "inf", &p)) {
|
|
bf_set_inf(r, is_neg);
|
|
ret = 0;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
if (radix == 0)
|
|
radix = 10;
|
|
if (is_dec) {
|
|
assert(radix == 10);
|
|
radix_bits = 0;
|
|
a = r;
|
|
} else if ((radix & (radix - 1)) != 0) {
|
|
radix_bits = 0; /* base is not a power of two */
|
|
a = &a_s;
|
|
bf_init(r->ctx, a);
|
|
} else {
|
|
radix_bits = ceil_log2(radix);
|
|
a = r;
|
|
}
|
|
|
|
/* skip leading zeros */
|
|
/* XXX: could also skip zeros after the decimal point */
|
|
while (*p == '0')
|
|
p++;
|
|
|
|
if (radix_bits) {
|
|
shift = digits_per_limb = LIMB_BITS;
|
|
} else {
|
|
radix_bits = 0;
|
|
shift = digits_per_limb = digits_per_limb_table[radix - 2];
|
|
}
|
|
cur_limb = 0;
|
|
bf_resize(a, 1);
|
|
pos = 0;
|
|
has_decpt = FALSE;
|
|
int_len = digit_count = 0;
|
|
for(;;) {
|
|
limb_t c;
|
|
if (*p == '.' && (p > p_start || to_digit(p[1]) < radix)) {
|
|
if (has_decpt)
|
|
break;
|
|
has_decpt = TRUE;
|
|
int_len = digit_count;
|
|
p++;
|
|
}
|
|
c = to_digit(*p);
|
|
if (c >= radix)
|
|
break;
|
|
digit_count++;
|
|
p++;
|
|
if (radix_bits) {
|
|
shift -= radix_bits;
|
|
if (shift <= 0) {
|
|
cur_limb |= c >> (-shift);
|
|
if (bf_add_limb(a, &pos, cur_limb))
|
|
goto mem_error;
|
|
if (shift < 0)
|
|
cur_limb = c << (LIMB_BITS + shift);
|
|
else
|
|
cur_limb = 0;
|
|
shift += LIMB_BITS;
|
|
} else {
|
|
cur_limb |= c << shift;
|
|
}
|
|
} else {
|
|
cur_limb = cur_limb * radix + c;
|
|
shift--;
|
|
if (shift == 0) {
|
|
if (bf_add_limb(a, &pos, cur_limb))
|
|
goto mem_error;
|
|
shift = digits_per_limb;
|
|
cur_limb = 0;
|
|
}
|
|
}
|
|
}
|
|
if (!has_decpt)
|
|
int_len = digit_count;
|
|
|
|
/* add the last limb and pad with zeros */
|
|
if (shift != digits_per_limb) {
|
|
if (radix_bits == 0) {
|
|
while (shift != 0) {
|
|
cur_limb *= radix;
|
|
shift--;
|
|
}
|
|
}
|
|
if (bf_add_limb(a, &pos, cur_limb)) {
|
|
mem_error:
|
|
ret = BF_ST_MEM_ERROR;
|
|
if (!radix_bits)
|
|
bf_delete(a);
|
|
bf_set_nan(r);
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
/* reset the next limbs to zero (we prefer to reallocate in the
|
|
renormalization) */
|
|
memset(a->tab, 0, (pos + 1) * sizeof(limb_t));
|
|
|
|
if (p == p_start) {
|
|
ret = 0;
|
|
if (!radix_bits)
|
|
bf_delete(a);
|
|
bf_set_nan(r);
|
|
goto done;
|
|
}
|
|
|
|
/* parse the exponent, if any */
|
|
expn = 0;
|
|
is_bin_exp = FALSE;
|
|
if (((radix == 10 && (*p == 'e' || *p == 'E')) ||
|
|
(radix != 10 && (*p == '@' ||
|
|
(radix_bits && (*p == 'p' || *p == 'P'))))) &&
|
|
p > p_start) {
|
|
is_bin_exp = (*p == 'p' || *p == 'P');
|
|
p++;
|
|
exp_is_neg = 0;
|
|
if (*p == '+') {
|
|
p++;
|
|
} else if (*p == '-') {
|
|
exp_is_neg = 1;
|
|
p++;
|
|
}
|
|
for(;;) {
|
|
int c;
|
|
c = to_digit(*p);
|
|
if (c >= 10)
|
|
break;
|
|
if (unlikely(expn > ((BF_RAW_EXP_MAX - 2 - 9) / 10))) {
|
|
/* exponent overflow */
|
|
if (exp_is_neg) {
|
|
bf_set_zero(r, is_neg);
|
|
ret = BF_ST_UNDERFLOW | BF_ST_INEXACT;
|
|
} else {
|
|
bf_set_inf(r, is_neg);
|
|
ret = BF_ST_OVERFLOW | BF_ST_INEXACT;
|
|
}
|
|
goto done;
|
|
}
|
|
p++;
|
|
expn = expn * 10 + c;
|
|
}
|
|
if (exp_is_neg)
|
|
expn = -expn;
|
|
}
|
|
if (is_dec) {
|
|
a->expn = expn + int_len;
|
|
a->sign = is_neg;
|
|
ret = bfdec_normalize_and_round((bfdec_t *)a, prec, flags);
|
|
} else if (radix_bits) {
|
|
/* XXX: may overflow */
|
|
if (!is_bin_exp)
|
|
expn *= radix_bits;
|
|
a->expn = expn + (int_len * radix_bits);
|
|
a->sign = is_neg;
|
|
ret = bf_normalize_and_round(a, prec, flags);
|
|
} else {
|
|
limb_t l;
|
|
pos++;
|
|
l = a->len - pos; /* number of limbs */
|
|
if (l == 0) {
|
|
bf_set_zero(r, is_neg);
|
|
ret = 0;
|
|
} else {
|
|
bf_t T_s, *T = &T_s;
|
|
|
|
expn -= l * digits_per_limb - int_len;
|
|
bf_init(r->ctx, T);
|
|
if (bf_integer_from_radix(T, a->tab + pos, l, radix)) {
|
|
bf_set_nan(r);
|
|
ret = BF_ST_MEM_ERROR;
|
|
} else {
|
|
T->sign = is_neg;
|
|
if (flags & BF_ATOF_EXPONENT) {
|
|
/* return the exponent */
|
|
*pexponent = expn;
|
|
ret = bf_set(r, T);
|
|
} else {
|
|
ret = bf_mul_pow_radix(r, T, radix, expn, prec, flags);
|
|
}
|
|
}
|
|
bf_delete(T);
|
|
}
|
|
bf_delete(a);
|
|
}
|
|
done:
|
|
if (pnext)
|
|
*pnext = p;
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
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.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
int bf_atof(bf_t *r, const char *str, const char **pnext, int radix,
|
|
limb_t prec, bf_flags_t flags)
|
|
{
|
|
slimb_t dummy_exp;
|
|
return bf_atof_internal(r, &dummy_exp, str, pnext, radix, prec, flags, FALSE);
|
|
}
|
|
|
|
/* base conversion to radix */
|
|
|
|
#if LIMB_BITS == 64
|
|
#define RADIXL_10 UINT64_C(10000000000000000000)
|
|
#else
|
|
#define RADIXL_10 UINT64_C(1000000000)
|
|
#endif
|
|
|
|
static const uint32_t inv_log2_radix[BF_RADIX_MAX - 1][LIMB_BITS / 32 + 1] = {
|
|
#if LIMB_BITS == 32
|
|
{ 0x80000000, 0x00000000,},
|
|
{ 0x50c24e60, 0xd4d4f4a7,},
|
|
{ 0x40000000, 0x00000000,},
|
|
{ 0x372068d2, 0x0a1ee5ca,},
|
|
{ 0x3184648d, 0xb8153e7a,},
|
|
{ 0x2d983275, 0x9d5369c4,},
|
|
{ 0x2aaaaaaa, 0xaaaaaaab,},
|
|
{ 0x28612730, 0x6a6a7a54,},
|
|
{ 0x268826a1, 0x3ef3fde6,},
|
|
{ 0x25001383, 0xbac8a744,},
|
|
{ 0x23b46706, 0x82c0c709,},
|
|
{ 0x229729f1, 0xb2c83ded,},
|
|
{ 0x219e7ffd, 0xa5ad572b,},
|
|
{ 0x20c33b88, 0xda7c29ab,},
|
|
{ 0x20000000, 0x00000000,},
|
|
{ 0x1f50b57e, 0xac5884b3,},
|
|
{ 0x1eb22cc6, 0x8aa6e26f,},
|
|
{ 0x1e21e118, 0x0c5daab2,},
|
|
{ 0x1d9dcd21, 0x439834e4,},
|
|
{ 0x1d244c78, 0x367a0d65,},
|
|
{ 0x1cb40589, 0xac173e0c,},
|
|
{ 0x1c4bd95b, 0xa8d72b0d,},
|
|
{ 0x1bead768, 0x98f8ce4c,},
|
|
{ 0x1b903469, 0x050f72e5,},
|
|
{ 0x1b3b433f, 0x2eb06f15,},
|
|
{ 0x1aeb6f75, 0x9c46fc38,},
|
|
{ 0x1aa038eb, 0x0e3bfd17,},
|
|
{ 0x1a593062, 0xb38d8c56,},
|
|
{ 0x1a15f4c3, 0x2b95a2e6,},
|
|
{ 0x19d630dc, 0xcc7ddef9,},
|
|
{ 0x19999999, 0x9999999a,},
|
|
{ 0x195fec80, 0x8a609431,},
|
|
{ 0x1928ee7b, 0x0b4f22f9,},
|
|
{ 0x18f46acf, 0x8c06e318,},
|
|
{ 0x18c23246, 0xdc0a9f3d,},
|
|
#else
|
|
{ 0x80000000, 0x00000000, 0x00000000,},
|
|
{ 0x50c24e60, 0xd4d4f4a7, 0x021f57bc,},
|
|
{ 0x40000000, 0x00000000, 0x00000000,},
|
|
{ 0x372068d2, 0x0a1ee5ca, 0x19ea911b,},
|
|
{ 0x3184648d, 0xb8153e7a, 0x7fc2d2e1,},
|
|
{ 0x2d983275, 0x9d5369c4, 0x4dec1661,},
|
|
{ 0x2aaaaaaa, 0xaaaaaaaa, 0xaaaaaaab,},
|
|
{ 0x28612730, 0x6a6a7a53, 0x810fabde,},
|
|
{ 0x268826a1, 0x3ef3fde6, 0x23e2566b,},
|
|
{ 0x25001383, 0xbac8a744, 0x385a3349,},
|
|
{ 0x23b46706, 0x82c0c709, 0x3f891718,},
|
|
{ 0x229729f1, 0xb2c83ded, 0x15fba800,},
|
|
{ 0x219e7ffd, 0xa5ad572a, 0xe169744b,},
|
|
{ 0x20c33b88, 0xda7c29aa, 0x9bddee52,},
|
|
{ 0x20000000, 0x00000000, 0x00000000,},
|
|
{ 0x1f50b57e, 0xac5884b3, 0x70e28eee,},
|
|
{ 0x1eb22cc6, 0x8aa6e26f, 0x06d1a2a2,},
|
|
{ 0x1e21e118, 0x0c5daab1, 0x81b4f4bf,},
|
|
{ 0x1d9dcd21, 0x439834e3, 0x81667575,},
|
|
{ 0x1d244c78, 0x367a0d64, 0xc8204d6d,},
|
|
{ 0x1cb40589, 0xac173e0c, 0x3b7b16ba,},
|
|
{ 0x1c4bd95b, 0xa8d72b0d, 0x5879f25a,},
|
|
{ 0x1bead768, 0x98f8ce4c, 0x66cc2858,},
|
|
{ 0x1b903469, 0x050f72e5, 0x0cf5488e,},
|
|
{ 0x1b3b433f, 0x2eb06f14, 0x8c89719c,},
|
|
{ 0x1aeb6f75, 0x9c46fc37, 0xab5fc7e9,},
|
|
{ 0x1aa038eb, 0x0e3bfd17, 0x1bd62080,},
|
|
{ 0x1a593062, 0xb38d8c56, 0x7998ab45,},
|
|
{ 0x1a15f4c3, 0x2b95a2e6, 0x46aed6a0,},
|
|
{ 0x19d630dc, 0xcc7ddef9, 0x5aadd61b,},
|
|
{ 0x19999999, 0x99999999, 0x9999999a,},
|
|
{ 0x195fec80, 0x8a609430, 0xe1106014,},
|
|
{ 0x1928ee7b, 0x0b4f22f9, 0x5f69791d,},
|
|
{ 0x18f46acf, 0x8c06e318, 0x4d2aeb2c,},
|
|
{ 0x18c23246, 0xdc0a9f3d, 0x3fe16970,},
|
|
#endif
|
|
};
|
|
|
|
static const limb_t log2_radix[BF_RADIX_MAX - 1] = {
|
|
#if LIMB_BITS == 32
|
|
0x20000000,
|
|
0x32b80347,
|
|
0x40000000,
|
|
0x4a4d3c26,
|
|
0x52b80347,
|
|
0x59d5d9fd,
|
|
0x60000000,
|
|
0x6570068e,
|
|
0x6a4d3c26,
|
|
0x6eb3a9f0,
|
|
0x72b80347,
|
|
0x766a008e,
|
|
0x79d5d9fd,
|
|
0x7d053f6d,
|
|
0x80000000,
|
|
0x82cc7edf,
|
|
0x8570068e,
|
|
0x87ef05ae,
|
|
0x8a4d3c26,
|
|
0x8c8ddd45,
|
|
0x8eb3a9f0,
|
|
0x90c10501,
|
|
0x92b80347,
|
|
0x949a784c,
|
|
0x966a008e,
|
|
0x982809d6,
|
|
0x99d5d9fd,
|
|
0x9b74948f,
|
|
0x9d053f6d,
|
|
0x9e88c6b3,
|
|
0xa0000000,
|
|
0xa16bad37,
|
|
0xa2cc7edf,
|
|
0xa4231623,
|
|
0xa570068e,
|
|
#else
|
|
0x2000000000000000,
|
|
0x32b803473f7ad0f4,
|
|
0x4000000000000000,
|
|
0x4a4d3c25e68dc57f,
|
|
0x52b803473f7ad0f4,
|
|
0x59d5d9fd5010b366,
|
|
0x6000000000000000,
|
|
0x6570068e7ef5a1e8,
|
|
0x6a4d3c25e68dc57f,
|
|
0x6eb3a9f01975077f,
|
|
0x72b803473f7ad0f4,
|
|
0x766a008e4788cbcd,
|
|
0x79d5d9fd5010b366,
|
|
0x7d053f6d26089673,
|
|
0x8000000000000000,
|
|
0x82cc7edf592262d0,
|
|
0x8570068e7ef5a1e8,
|
|
0x87ef05ae409a0289,
|
|
0x8a4d3c25e68dc57f,
|
|
0x8c8ddd448f8b845a,
|
|
0x8eb3a9f01975077f,
|
|
0x90c10500d63aa659,
|
|
0x92b803473f7ad0f4,
|
|
0x949a784bcd1b8afe,
|
|
0x966a008e4788cbcd,
|
|
0x982809d5be7072dc,
|
|
0x99d5d9fd5010b366,
|
|
0x9b74948f5532da4b,
|
|
0x9d053f6d26089673,
|
|
0x9e88c6b3626a72aa,
|
|
0xa000000000000000,
|
|
0xa16bad3758efd873,
|
|
0xa2cc7edf592262d0,
|
|
0xa4231623369e78e6,
|
|
0xa570068e7ef5a1e8,
|
|
#endif
|
|
};
|
|
|
|
/* 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. */
|
|
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 ((radix & (radix - 1)) == 0) {
|
|
int radix_bits;
|
|
/* radix is a power of two */
|
|
radix_bits = ceil_log2(radix);
|
|
if (is_inv) {
|
|
if (is_ceil)
|
|
a += radix_bits - 1;
|
|
a = a / radix_bits;
|
|
} else {
|
|
a = a * radix_bits;
|
|
}
|
|
} else {
|
|
const uint32_t *tab;
|
|
limb_t b0, b1;
|
|
dlimb_t t;
|
|
|
|
if (is_inv) {
|
|
tab = inv_log2_radix[radix - 2];
|
|
#if LIMB_BITS == 32
|
|
b1 = tab[0];
|
|
b0 = tab[1];
|
|
#else
|
|
b1 = ((limb_t)tab[0] << 32) | tab[1];
|
|
b0 = (limb_t)tab[2] << 32;
|
|
#endif
|
|
t = (dlimb_t)b0 * (dlimb_t)a;
|
|
t = (dlimb_t)b1 * (dlimb_t)a + (t >> LIMB_BITS);
|
|
a = t >> (LIMB_BITS - 1);
|
|
} else {
|
|
b0 = log2_radix[radix - 2];
|
|
t = (dlimb_t)b0 * (dlimb_t)a;
|
|
a = t >> (LIMB_BITS - 3);
|
|
}
|
|
/* a = floor(result) and 'result' cannot be an integer */
|
|
a += is_ceil;
|
|
}
|
|
if (is_neg)
|
|
a = -a;
|
|
return a;
|
|
}
|
|
|
|
/* 'n' is the number of output limbs */
|
|
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);
|
|
if (n == 1) {
|
|
out[0] = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
|
|
} else if (n == 2) {
|
|
dlimb_t t;
|
|
slimb_t pos;
|
|
pos = a->len * LIMB_BITS - a->expn;
|
|
t = ((dlimb_t)get_bits(a->tab, a->len, pos + LIMB_BITS) << LIMB_BITS) |
|
|
get_bits(a->tab, a->len, pos);
|
|
if (likely(radixl == RADIXL_10)) {
|
|
/* use division by a constant when possible */
|
|
out[0] = t % RADIXL_10;
|
|
out[1] = t / RADIXL_10;
|
|
} else {
|
|
out[0] = t % radixl;
|
|
out[1] = t / radixl;
|
|
}
|
|
} else {
|
|
bf_t Q, R, *B, *B_inv;
|
|
int q_add;
|
|
bf_init(a->ctx, &Q);
|
|
bf_init(a->ctx, &R);
|
|
n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
|
|
n1 = n - n2;
|
|
B = &pow_tab[2 * level];
|
|
B_inv = &pow_tab[2 * level + 1];
|
|
ret = 0;
|
|
if (B->len == 0) {
|
|
/* compute BASE^n2 */
|
|
ret |= bf_pow_ui_ui(B, radixl, n2, BF_PREC_INF, BF_RNDZ);
|
|
/* we use enough bits for the maximum possible 'n1' value,
|
|
i.e. n2 + 1 */
|
|
ret |= bf_set_ui(&R, 1);
|
|
ret |= bf_div(B_inv, &R, B, (n2 + 1) * radixl_bits + 2, BF_RNDN);
|
|
}
|
|
// printf("%d: n1=% " PRId64 " n2=%" PRId64 "\n", level, n1, n2);
|
|
q_prec = n1 * radixl_bits;
|
|
ret |= bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
|
|
ret |= bf_rint(&Q, BF_RNDZ);
|
|
|
|
ret |= bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
|
|
ret |= bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
|
|
|
|
if (ret & BF_ST_MEM_ERROR)
|
|
goto fail;
|
|
/* adjust if necessary */
|
|
q_add = 0;
|
|
while (R.sign && R.len != 0) {
|
|
if (bf_add(&R, &R, B, BF_PREC_INF, BF_RNDZ))
|
|
goto fail;
|
|
q_add--;
|
|
}
|
|
while (bf_cmpu(&R, B) >= 0) {
|
|
if (bf_sub(&R, &R, B, BF_PREC_INF, BF_RNDZ))
|
|
goto fail;
|
|
q_add++;
|
|
}
|
|
if (q_add != 0) {
|
|
if (bf_add_si(&Q, &Q, q_add, BF_PREC_INF, BF_RNDZ))
|
|
goto fail;
|
|
}
|
|
if (bf_integer_to_radix_rec(pow_tab, out + n2, &Q, n1, level + 1, n0,
|
|
radixl, radixl_bits))
|
|
goto fail;
|
|
if (bf_integer_to_radix_rec(pow_tab, out, &R, n2, level + 1, n0,
|
|
radixl, radixl_bits)) {
|
|
fail:
|
|
bf_delete(&Q);
|
|
bf_delete(&R);
|
|
return -1;
|
|
}
|
|
bf_delete(&Q);
|
|
bf_delete(&R);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* return 0 if OK != 0 if memory error */
|
|
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);
|
|
if (!pow_tab)
|
|
return -1;
|
|
for(i = 0; i < pow_tab_len; i++)
|
|
bf_init(r->ctx, &pow_tab[i]);
|
|
|
|
ret = bf_integer_to_radix_rec(pow_tab, r->tab, a, r_len, 0, r_len, radixl,
|
|
ceil_log2(radixl));
|
|
|
|
for(i = 0; i < pow_tab_len; i++) {
|
|
bf_delete(&pow_tab[i]);
|
|
}
|
|
bf_free(s, pow_tab);
|
|
return ret;
|
|
}
|
|
|
|
/* 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. */
|
|
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_sign, ret, res;
|
|
|
|
if (a->len == 0) {
|
|
/* zero case */
|
|
*pE = 0;
|
|
return bf_set(r, a);
|
|
}
|
|
|
|
if (is_fixed_exponent) {
|
|
E = *pE;
|
|
} else {
|
|
/* compute the new exponent */
|
|
E = 1 + bf_mul_log2_radix(a->expn - 1, radix, TRUE, FALSE);
|
|
}
|
|
// bf_print_str("a", a);
|
|
// printf("E=%ld P=%ld radix=%d\n", E, P, radix);
|
|
|
|
for(;;) {
|
|
e = P - E;
|
|
e_sign = 0;
|
|
if (e < 0) {
|
|
e = -e;
|
|
e_sign = 1;
|
|
}
|
|
/* Note: precision for log2(radix) is not critical here */
|
|
prec0 = bf_mul_log2_radix(P, radix, FALSE, TRUE);
|
|
ziv_extra_bits = 16;
|
|
for(;;) {
|
|
prec = prec0 + ziv_extra_bits;
|
|
/* XXX: rigorous error analysis needed */
|
|
extra_bits = ceil_log2(e) * 2 + 1;
|
|
ret = bf_pow_ui_ui(r, radix, e, prec + extra_bits,
|
|
BF_RNDN | BF_FLAG_EXT_EXP);
|
|
if (!e_sign)
|
|
ret |= bf_mul(r, r, a, prec + extra_bits,
|
|
BF_RNDN | BF_FLAG_EXT_EXP);
|
|
else
|
|
ret |= bf_div(r, a, r, prec + extra_bits,
|
|
BF_RNDN | BF_FLAG_EXT_EXP);
|
|
if (ret & BF_ST_MEM_ERROR)
|
|
return BF_ST_MEM_ERROR;
|
|
/* if the result is not exact, check that it can be safely
|
|
rounded to an integer */
|
|
if ((ret & BF_ST_INEXACT) &&
|
|
!bf_can_round(r, r->expn, rnd_mode, prec)) {
|
|
/* and more precision and retry */
|
|
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
|
|
continue;
|
|
} else {
|
|
ret = bf_rint(r, rnd_mode);
|
|
if (ret & BF_ST_MEM_ERROR)
|
|
return BF_ST_MEM_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
if (is_fixed_exponent)
|
|
break;
|
|
/* check that the result is < B^P */
|
|
/* XXX: do a fast approximate test first ? */
|
|
bf_init(r->ctx, B);
|
|
ret = bf_pow_ui_ui(B, radix, P, BF_PREC_INF, BF_RNDZ);
|
|
if (ret) {
|
|
bf_delete(B);
|
|
return ret;
|
|
}
|
|
res = bf_cmpu(r, B);
|
|
bf_delete(B);
|
|
if (res < 0)
|
|
break;
|
|
/* try a larger exponent */
|
|
E++;
|
|
}
|
|
*pE = E;
|
|
return 0;
|
|
}
|
|
|
|
static void limb_to_a(char *buf, limb_t n, unsigned int radix, int len)
|
|
{
|
|
int digit, i;
|
|
|
|
if (radix == 10) {
|
|
/* specific case with constant divisor */
|
|
for(i = len - 1; i >= 0; i--) {
|
|
digit = (limb_t)n % 10;
|
|
n = (limb_t)n / 10;
|
|
buf[i] = digit + '0';
|
|
}
|
|
} else {
|
|
for(i = len - 1; i >= 0; i--) {
|
|
digit = (limb_t)n % radix;
|
|
n = (limb_t)n / radix;
|
|
if (digit < 10)
|
|
digit += '0';
|
|
else
|
|
digit += 'a' - 10;
|
|
buf[i] = digit;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* for power of 2 radixes */
|
|
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
|
|
digit += 'a' - 10;
|
|
buf[i] = digit;
|
|
}
|
|
}
|
|
|
|
/* '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. */
|
|
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_limb = LIMB_DIGITS;
|
|
a = (bf_t *)a1;
|
|
radix_bits = 0;
|
|
pos = a->len;
|
|
pos_incr = 1;
|
|
first_buf_pos = 0;
|
|
} else if ((radix & (radix - 1)) == 0) {
|
|
a = (bf_t *)a1;
|
|
radix_bits = ceil_log2(radix);
|
|
digits_per_limb = LIMB_BITS / radix_bits;
|
|
pos_incr = digits_per_limb * radix_bits;
|
|
/* digits are aligned relative to the radix point */
|
|
pos = a->len * LIMB_BITS + smod(-a->expn, radix_bits);
|
|
first_buf_pos = 0;
|
|
} else {
|
|
limb_t n, radixl;
|
|
|
|
digits_per_limb = digits_per_limb_table[radix - 2];
|
|
radixl = get_limb_radix(radix);
|
|
a = &a_s;
|
|
bf_init(a1->ctx, a);
|
|
n = (n_digits + digits_per_limb - 1) / digits_per_limb;
|
|
if (bf_resize(a, n)) {
|
|
dbuf_set_error(s);
|
|
goto done;
|
|
}
|
|
if (bf_integer_to_radix(a, a1, radixl)) {
|
|
dbuf_set_error(s);
|
|
goto done;
|
|
}
|
|
radix_bits = 0;
|
|
pos = n;
|
|
pos_incr = 1;
|
|
first_buf_pos = pos * digits_per_limb - n_digits;
|
|
}
|
|
buf_pos = digits_per_limb;
|
|
i = 0;
|
|
while (i < n_digits) {
|
|
if (buf_pos == digits_per_limb) {
|
|
pos -= pos_incr;
|
|
if (radix_bits == 0) {
|
|
v = get_limbz(a, pos);
|
|
limb_to_a(buf, v, radix, digits_per_limb);
|
|
} else {
|
|
v = get_bits(a->tab, a->len, pos);
|
|
limb_to_a2(buf, v, radix_bits, digits_per_limb);
|
|
}
|
|
buf_pos = first_buf_pos;
|
|
first_buf_pos = 0;
|
|
}
|
|
if (i < dot_pos) {
|
|
l = dot_pos;
|
|
} else {
|
|
if (i == dot_pos)
|
|
dbuf_putc(s, '.');
|
|
l = n_digits;
|
|
}
|
|
l = bf_min(digits_per_limb - buf_pos, l - i);
|
|
dbuf_put(s, (uint8_t *)(buf + buf_pos), l);
|
|
buf_pos += l;
|
|
i += l;
|
|
}
|
|
done:
|
|
if (a != a1)
|
|
bf_delete(a);
|
|
}
|
|
|
|
static void *bf_dbuf_realloc(void *opaque, void *ptr, size_t size)
|
|
{
|
|
bf_context_t *s = opaque;
|
|
return bf_realloc(s, ptr, size);
|
|
}
|
|
|
|
/* return the length in bytes. A trailing '\0' is added */
|
|
static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
|
|
limb_t prec, bf_flags_t flags, BOOL is_dec)
|
|
{
|
|
bf_context_t *ctx = a2->ctx;
|
|
DynBuf s_s, *s = &s_s;
|
|
int radix_bits;
|
|
|
|
// bf_print_str("ftoa", a2);
|
|
// printf("radix=%d\n", radix);
|
|
dbuf_init2(s, ctx, bf_dbuf_realloc);
|
|
if (a2->expn == BF_EXP_NAN) {
|
|
dbuf_putstr(s, "NaN");
|
|
} else {
|
|
if (a2->sign)
|
|
dbuf_putc(s, '-');
|
|
if (a2->expn == BF_EXP_INF) {
|
|
if (flags & BF_FTOA_JS_QUIRKS)
|
|
dbuf_putstr(s, "Infinity");
|
|
else
|
|
dbuf_putstr(s, "Inf");
|
|
} else {
|
|
int fmt, ret;
|
|
slimb_t n_digits, n, i, n_max, n1;
|
|
bf_t a1_s, *a1 = &a1_s;
|
|
|
|
if ((radix & (radix - 1)) != 0)
|
|
radix_bits = 0;
|
|
else
|
|
radix_bits = ceil_log2(radix);
|
|
|
|
fmt = flags & BF_FTOA_FORMAT_MASK;
|
|
bf_init(ctx, a1);
|
|
if (fmt == BF_FTOA_FORMAT_FRAC) {
|
|
if (is_dec || radix_bits != 0) {
|
|
if (bf_set(a1, a2))
|
|
goto fail1;
|
|
#ifdef USE_BF_DEC
|
|
if (is_dec) {
|
|
if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
|
|
goto fail1;
|
|
n = a1->expn;
|
|
} else
|
|
#endif
|
|
{
|
|
if (bf_round(a1, prec * radix_bits, (flags & BF_RND_MASK) | BF_FLAG_RADPNT_PREC) & BF_ST_MEM_ERROR)
|
|
goto fail1;
|
|
n = ceil_div(a1->expn, radix_bits);
|
|
}
|
|
if (flags & BF_FTOA_ADD_PREFIX) {
|
|
if (radix == 16)
|
|
dbuf_putstr(s, "0x");
|
|
else if (radix == 8)
|
|
dbuf_putstr(s, "0o");
|
|
else if (radix == 2)
|
|
dbuf_putstr(s, "0b");
|
|
}
|
|
if (a1->expn == BF_EXP_ZERO) {
|
|
dbuf_putstr(s, "0");
|
|
if (prec > 0) {
|
|
dbuf_putstr(s, ".");
|
|
for(i = 0; i < prec; i++) {
|
|
dbuf_putc(s, '0');
|
|
}
|
|
}
|
|
} else {
|
|
n_digits = prec + n;
|
|
if (n <= 0) {
|
|
/* 0.x */
|
|
dbuf_putstr(s, "0.");
|
|
for(i = 0; i < -n; i++) {
|
|
dbuf_putc(s, '0');
|
|
}
|
|
if (n_digits > 0) {
|
|
output_digits(s, a1, radix, n_digits, n_digits, is_dec);
|
|
}
|
|
} else {
|
|
output_digits(s, a1, radix, n_digits, n, is_dec);
|
|
}
|
|
}
|
|
} else {
|
|
size_t pos, start;
|
|
bf_t a_s, *a = &a_s;
|
|
|
|
/* make a positive number */
|
|
a->tab = a2->tab;
|
|
a->len = a2->len;
|
|
a->expn = a2->expn;
|
|
a->sign = 0;
|
|
|
|
/* one more digit for the rounding */
|
|
n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
|
|
n_digits = n + prec;
|
|
n1 = n;
|
|
if (bf_convert_to_radix(a1, &n1, a, radix, n_digits,
|
|
flags & BF_RND_MASK, TRUE))
|
|
goto fail1;
|
|
start = s->size;
|
|
output_digits(s, a1, radix, n_digits, n, is_dec);
|
|
/* remove leading zeros because we allocated one more digit */
|
|
pos = start;
|
|
while ((pos + 1) < s->size && s->buf[pos] == '0' &&
|
|
s->buf[pos + 1] != '.')
|
|
pos++;
|
|
if (pos > start) {
|
|
memmove(s->buf + start, s->buf + pos, s->size - pos);
|
|
s->size -= (pos - start);
|
|
}
|
|
}
|
|
} else {
|
|
#ifdef USE_BF_DEC
|
|
if (is_dec) {
|
|
if (bf_set(a1, a2))
|
|
goto fail1;
|
|
if (fmt == BF_FTOA_FORMAT_FIXED) {
|
|
n_digits = prec;
|
|
n_max = n_digits;
|
|
if (bfdec_round((bfdec_t *)a1, prec, (flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
|
|
goto fail1;
|
|
} else {
|
|
/* prec is ignored */
|
|
prec = n_digits = a1->len * LIMB_DIGITS;
|
|
/* remove the trailing zero digits */
|
|
while (n_digits > 1 &&
|
|
get_digit(a1->tab, a1->len, prec - n_digits) == 0) {
|
|
n_digits--;
|
|
}
|
|
n_max = n_digits + 4;
|
|
}
|
|
n = a1->expn;
|
|
} else
|
|
#endif
|
|
if (radix_bits != 0) {
|
|
if (bf_set(a1, a2))
|
|
goto fail1;
|
|
if (fmt == BF_FTOA_FORMAT_FIXED) {
|
|
slimb_t prec_bits;
|
|
n_digits = prec;
|
|
n_max = n_digits;
|
|
/* align to the radix point */
|
|
prec_bits = prec * radix_bits -
|
|
smod(-a1->expn, radix_bits);
|
|
if (bf_round(a1, prec_bits,
|
|
(flags & BF_RND_MASK)) & BF_ST_MEM_ERROR)
|
|
goto fail1;
|
|
} else {
|
|
limb_t digit_mask;
|
|
slimb_t pos;
|
|
/* position of the digit before the most
|
|
significant digit in bits */
|
|
pos = a1->len * LIMB_BITS +
|
|
smod(-a1->expn, radix_bits);
|
|
n_digits = ceil_div(pos, radix_bits);
|
|
/* remove the trailing zero digits */
|
|
digit_mask = ((limb_t)1 << radix_bits) - 1;
|
|
while (n_digits > 1 &&
|
|
(get_bits(a1->tab, a1->len, pos - n_digits * radix_bits) & digit_mask) == 0) {
|
|
n_digits--;
|
|
}
|
|
n_max = n_digits + 4;
|
|
}
|
|
n = ceil_div(a1->expn, radix_bits);
|
|
} else {
|
|
bf_t a_s, *a = &a_s;
|
|
|
|
/* make a positive number */
|
|
a->tab = a2->tab;
|
|
a->len = a2->len;
|
|
a->expn = a2->expn;
|
|
a->sign = 0;
|
|
|
|
if (fmt == BF_FTOA_FORMAT_FIXED) {
|
|
n_digits = prec;
|
|
n_max = n_digits;
|
|
} else {
|
|
slimb_t n_digits_max, n_digits_min;
|
|
|
|
assert(prec != BF_PREC_INF);
|
|
n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
|
|
/* max number of digits for non exponential
|
|
notation. The rational is to have the same rule
|
|
as JS i.e. n_max = 21 for 64 bit float in base 10. */
|
|
n_max = n_digits + 4;
|
|
if (fmt == BF_FTOA_FORMAT_FREE_MIN) {
|
|
bf_t b_s, *b = &b_s;
|
|
|
|
/* find the minimum number of digits by
|
|
dichotomy. */
|
|
/* XXX: inefficient */
|
|
n_digits_max = n_digits;
|
|
n_digits_min = 1;
|
|
bf_init(ctx, b);
|
|
while (n_digits_min < n_digits_max) {
|
|
n_digits = (n_digits_min + n_digits_max) / 2;
|
|
if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
|
|
flags & BF_RND_MASK, FALSE)) {
|
|
bf_delete(b);
|
|
goto fail1;
|
|
}
|
|
/* convert back to a number and compare */
|
|
ret = bf_mul_pow_radix(b, a1, radix, n - n_digits,
|
|
prec,
|
|
(flags & ~BF_RND_MASK) |
|
|
BF_RNDN);
|
|
if (ret & BF_ST_MEM_ERROR) {
|
|
bf_delete(b);
|
|
goto fail1;
|
|
}
|
|
if (bf_cmpu(b, a) == 0) {
|
|
n_digits_max = n_digits;
|
|
} else {
|
|
n_digits_min = n_digits + 1;
|
|
}
|
|
}
|
|
bf_delete(b);
|
|
n_digits = n_digits_max;
|
|
}
|
|
}
|
|
if (bf_convert_to_radix(a1, &n, a, radix, n_digits,
|
|
flags & BF_RND_MASK, FALSE)) {
|
|
fail1:
|
|
bf_delete(a1);
|
|
goto fail;
|
|
}
|
|
}
|
|
if (a1->expn == BF_EXP_ZERO &&
|
|
fmt != BF_FTOA_FORMAT_FIXED &&
|
|
!(flags & BF_FTOA_FORCE_EXP)) {
|
|
/* just output zero */
|
|
dbuf_putstr(s, "0");
|
|
} else {
|
|
if (flags & BF_FTOA_ADD_PREFIX) {
|
|
if (radix == 16)
|
|
dbuf_putstr(s, "0x");
|
|
else if (radix == 8)
|
|
dbuf_putstr(s, "0o");
|
|
else if (radix == 2)
|
|
dbuf_putstr(s, "0b");
|
|
}
|
|
if (a1->expn == BF_EXP_ZERO)
|
|
n = 1;
|
|
if ((flags & BF_FTOA_FORCE_EXP) ||
|
|
n <= -6 || n > n_max) {
|
|
const char *fmt;
|
|
/* exponential notation */
|
|
output_digits(s, a1, radix, n_digits, 1, is_dec);
|
|
if (radix_bits != 0 && radix <= 16) {
|
|
if (flags & BF_FTOA_JS_QUIRKS)
|
|
fmt = "p%+" PRId_LIMB;
|
|
else
|
|
fmt = "p%" PRId_LIMB;
|
|
dbuf_printf(s, fmt, (n - 1) * radix_bits);
|
|
} else {
|
|
if (flags & BF_FTOA_JS_QUIRKS)
|
|
fmt = "%c%+" PRId_LIMB;
|
|
else
|
|
fmt = "%c%" PRId_LIMB;
|
|
dbuf_printf(s, fmt,
|
|
radix <= 10 ? 'e' : '@', n - 1);
|
|
}
|
|
} else if (n <= 0) {
|
|
/* 0.x */
|
|
dbuf_putstr(s, "0.");
|
|
for(i = 0; i < -n; i++) {
|
|
dbuf_putc(s, '0');
|
|
}
|
|
output_digits(s, a1, radix, n_digits, n_digits, is_dec);
|
|
} else {
|
|
if (n_digits <= n) {
|
|
/* no dot */
|
|
output_digits(s, a1, radix, n_digits, n_digits, is_dec);
|
|
for(i = 0; i < (n - n_digits); i++)
|
|
dbuf_putc(s, '0');
|
|
} else {
|
|
output_digits(s, a1, radix, n_digits, n, is_dec);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bf_delete(a1);
|
|
}
|
|
}
|
|
dbuf_putc(s, '\0');
|
|
if (dbuf_error(s))
|
|
goto fail;
|
|
if (plen)
|
|
*plen = s->size - 1;
|
|
return (char *)s->buf;
|
|
fail:
|
|
bf_free(ctx, s->buf);
|
|
if (plen)
|
|
*plen = 0;
|
|
return NULL;
|
|
}
|
|
|
|
char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_ftoa_internal(plen, a, radix, prec, flags, FALSE);
|
|
}
|
|
|
|
/***************************************************************/
|
|
/* transcendental functions */
|
|
|
|
/* Note: the algorithm is from MPFR */
|
|
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;
|
|
}
|
|
bf_set_ui(Q, 2 * n1 + 1);
|
|
Q->expn += 2;
|
|
bf_set(T, P);
|
|
} else {
|
|
limb_t m;
|
|
bf_t T1_s, *T1 = &T1_s;
|
|
bf_t P1_s, *P1 = &P1_s;
|
|
bf_t Q1_s, *Q1 = &Q1_s;
|
|
|
|
m = n1 + ((n2 - n1) >> 1);
|
|
bf_const_log2_rec(T, P, Q, n1, m, TRUE);
|
|
bf_init(s, T1);
|
|
bf_init(s, P1);
|
|
bf_init(s, Q1);
|
|
bf_const_log2_rec(T1, P1, Q1, m, n2, need_P);
|
|
bf_mul(T, T, Q1, BF_PREC_INF, BF_RNDZ);
|
|
bf_mul(T1, T1, P, BF_PREC_INF, BF_RNDZ);
|
|
bf_add(T, T, T1, BF_PREC_INF, BF_RNDZ);
|
|
if (need_P)
|
|
bf_mul(P, P, P1, BF_PREC_INF, BF_RNDZ);
|
|
bf_mul(Q, Q, Q1, BF_PREC_INF, BF_RNDZ);
|
|
bf_delete(T1);
|
|
bf_delete(P1);
|
|
bf_delete(Q1);
|
|
}
|
|
}
|
|
|
|
/* compute log(2) with faithful rounding at precision 'prec' */
|
|
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_delete(Q);
|
|
}
|
|
|
|
/* PI constant */
|
|
|
|
#define CHUD_A 13591409
|
|
#define CHUD_B 545140134
|
|
#define CHUD_C 640320
|
|
#define CHUD_BITS_PER_TERM 47
|
|
|
|
static void chud_bs(bf_t *P, bf_t *Q, bf_t *G, int64_t a, int64_t b, int need_g,
|
|
limb_t prec)
|
|
{
|
|
bf_context_t *s = P->ctx;
|
|
int64_t c;
|
|
|
|
if (a == (b - 1)) {
|
|
bf_t T0, T1;
|
|
|
|
bf_init(s, &T0);
|
|
bf_init(s, &T1);
|
|
bf_set_ui(G, 2 * b - 1);
|
|
bf_mul_ui(G, G, 6 * b - 1, prec, BF_RNDN);
|
|
bf_mul_ui(G, G, 6 * b - 5, prec, BF_RNDN);
|
|
bf_set_ui(&T0, CHUD_B);
|
|
bf_mul_ui(&T0, &T0, b, prec, BF_RNDN);
|
|
bf_set_ui(&T1, CHUD_A);
|
|
bf_add(&T0, &T0, &T1, prec, BF_RNDN);
|
|
bf_mul(P, G, &T0, prec, BF_RNDN);
|
|
P->sign = b & 1;
|
|
|
|
bf_set_ui(Q, b);
|
|
bf_mul_ui(Q, Q, b, prec, BF_RNDN);
|
|
bf_mul_ui(Q, Q, b, prec, BF_RNDN);
|
|
bf_mul_ui(Q, Q, (uint64_t)CHUD_C * CHUD_C * CHUD_C / 24, prec, BF_RNDN);
|
|
bf_delete(&T0);
|
|
bf_delete(&T1);
|
|
} else {
|
|
bf_t P2, Q2, G2;
|
|
|
|
bf_init(s, &P2);
|
|
bf_init(s, &Q2);
|
|
bf_init(s, &G2);
|
|
|
|
c = (a + b) / 2;
|
|
chud_bs(P, Q, G, a, c, 1, prec);
|
|
chud_bs(&P2, &Q2, &G2, c, b, need_g, prec);
|
|
|
|
/* Q = Q1 * Q2 */
|
|
/* G = G1 * G2 */
|
|
/* P = P1 * Q2 + P2 * G1 */
|
|
bf_mul(&P2, &P2, G, prec, BF_RNDN);
|
|
if (!need_g)
|
|
bf_set_ui(G, 0);
|
|
bf_mul(P, P, &Q2, prec, BF_RNDN);
|
|
bf_add(P, P, &P2, prec, BF_RNDN);
|
|
bf_delete(&P2);
|
|
|
|
bf_mul(Q, Q, &Q2, prec, BF_RNDN);
|
|
bf_delete(&Q2);
|
|
if (need_g)
|
|
bf_mul(G, G, &G2, prec, BF_RNDN);
|
|
bf_delete(&G2);
|
|
}
|
|
}
|
|
|
|
/* compute Pi with faithful rounding at precision 'prec' using the
|
|
Chudnovsky formula */
|
|
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, n, 0, BF_PREC_INF);
|
|
|
|
bf_mul_ui(&G, Q, CHUD_A, prec1, BF_RNDN);
|
|
bf_add(&P, &G, &P, prec1, BF_RNDN);
|
|
bf_div(Q, Q, &P, prec1, BF_RNDF);
|
|
|
|
bf_set_ui(&P, CHUD_C);
|
|
bf_sqrt(&G, &P, prec1, BF_RNDF);
|
|
bf_mul_ui(&G, &G, (uint64_t)CHUD_C / 12, prec1, BF_RNDF);
|
|
bf_mul(Q, Q, &G, prec, BF_RNDN);
|
|
bf_delete(&P);
|
|
bf_delete(&G);
|
|
}
|
|
|
|
static int bf_const_get(bf_t *T, limb_t prec, bf_flags_t flags,
|
|
BFConstCache *c,
|
|
void (*func)(bf_t *res, limb_t prec), int sign)
|
|
{
|
|
limb_t ziv_extra_bits, prec1;
|
|
|
|
ziv_extra_bits = 32;
|
|
for(;;) {
|
|
prec1 = prec + ziv_extra_bits;
|
|
if (c->prec < prec1) {
|
|
if (c->val.len == 0)
|
|
bf_init(T->ctx, &c->val);
|
|
func(&c->val, prec1);
|
|
c->prec = prec1;
|
|
} else {
|
|
prec1 = c->prec;
|
|
}
|
|
bf_set(T, &c->val);
|
|
T->sign = sign;
|
|
if (!bf_can_round(T, prec, flags & BF_RND_MASK, prec1)) {
|
|
/* and more precision and retry */
|
|
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return bf_round(T, prec, flags);
|
|
}
|
|
|
|
static void bf_const_free(BFConstCache *c)
|
|
{
|
|
bf_delete(&c->val);
|
|
memset(c, 0, sizeof(*c));
|
|
}
|
|
|
|
int bf_const_log2(bf_t *T, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = T->ctx;
|
|
return bf_const_get(T, prec, flags, &s->log2_cache, bf_const_log2_internal, 0);
|
|
}
|
|
|
|
/* return rounded pi * (1 - 2 * sign) */
|
|
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);
|
|
}
|
|
|
|
int bf_const_pi(bf_t *T, limb_t prec, bf_flags_t flags)
|
|
{
|
|
return bf_const_pi_signed(T, 0, prec, flags);
|
|
}
|
|
|
|
void bf_clear_cache(bf_context_t *s)
|
|
{
|
|
#ifdef USE_FFT_MUL
|
|
fft_clear_cache(s);
|
|
#endif
|
|
bf_const_free(&s->log2_cache);
|
|
bf_const_free(&s->pi_cache);
|
|
}
|
|
|
|
/* ZivFunc should compute the result 'r' with faithful rounding at
|
|
precision 'prec'. For efficiency purposes, the final bf_round()
|
|
does not need to be done in the function. */
|
|
typedef int ZivFunc(bf_t *r, const bf_t *a, limb_t prec, void *opaque);
|
|
|
|
static int bf_ziv_rounding(bf_t *r, const bf_t *a,
|
|
limb_t prec, bf_flags_t flags,
|
|
ZivFunc *f, void *opaque)
|
|
{
|
|
int rnd_mode, ret;
|
|
slimb_t prec1, ziv_extra_bits;
|
|
|
|
rnd_mode = flags & BF_RND_MASK;
|
|
if (rnd_mode == BF_RNDF) {
|
|
/* no need to iterate */
|
|
f(r, a, prec, opaque);
|
|
ret = 0;
|
|
} else {
|
|
ziv_extra_bits = 32;
|
|
for(;;) {
|
|
prec1 = prec + ziv_extra_bits;
|
|
ret = f(r, a, prec1, opaque);
|
|
if (ret & (BF_ST_OVERFLOW | BF_ST_UNDERFLOW | BF_ST_MEM_ERROR)) {
|
|
/* overflow or underflow should never happen because
|
|
it indicates the rounding cannot be done correctly,
|
|
but we do not catch all the cases */
|
|
return ret;
|
|
}
|
|
/* if the result is exact, we can stop */
|
|
if (!(ret & BF_ST_INEXACT)) {
|
|
ret = 0;
|
|
break;
|
|
}
|
|
if (bf_can_round(r, prec, rnd_mode, prec1)) {
|
|
ret = BF_ST_INEXACT;
|
|
break;
|
|
}
|
|
ziv_extra_bits = ziv_extra_bits * 2;
|
|
// printf("ziv_extra_bits=%" PRId64 "\n", (int64_t)ziv_extra_bits);
|
|
}
|
|
}
|
|
if (r->len == 0)
|
|
return ret;
|
|
else
|
|
return __bf_round(r, prec, flags, r->len, ret);
|
|
}
|
|
|
|
/* add (1 - 2*e_sign) * 2^e */
|
|
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 = bf_add(r, r, T, prec, flags);
|
|
bf_delete(T);
|
|
return ret;
|
|
}
|
|
|
|
/* Compute the exponential using faithful rounding at precision 'prec'.
|
|
Note: the algorithm is from MPFR */
|
|
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 <= -1) {
|
|
/* 0 <= abs(a) <= 0.5 */
|
|
if (a->sign)
|
|
n = -1;
|
|
else
|
|
n = 0;
|
|
} else {
|
|
bf_const_log2(T, LIMB_BITS, BF_RNDZ);
|
|
bf_div(T, a, T, LIMB_BITS, BF_RNDD);
|
|
bf_get_limb(&n, T, 0);
|
|
}
|
|
|
|
K = bf_isqrt((prec + 1) / 2);
|
|
l = (prec - 1) / K + 1;
|
|
/* XXX: precision analysis ? */
|
|
prec1 = prec + (K + 2 * l + 18) + K + 8;
|
|
if (a->expn > 0)
|
|
prec1 += a->expn;
|
|
// printf("n=%ld K=%ld prec1=%ld\n", n, K, prec1);
|
|
|
|
bf_const_log2(T, prec1, BF_RNDF);
|
|
bf_mul_si(T, T, n, prec1, BF_RNDN);
|
|
bf_sub(T, a, T, prec1, BF_RNDN);
|
|
|
|
/* reduce the range of T */
|
|
bf_mul_2exp(T, -K, BF_PREC_INF, BF_RNDZ);
|
|
|
|
/* Taylor expansion around zero :
|
|
1 + x + x^2/2 + ... + x^n/n!
|
|
= (1 + x * (1 + x/2 * (1 + ... (x/n))))
|
|
*/
|
|
{
|
|
bf_t U_s, *U = &U_s;
|
|
|
|
bf_init(s, U);
|
|
bf_set_ui(r, 1);
|
|
for(i = l ; i >= 1; i--) {
|
|
bf_set_ui(U, i);
|
|
bf_div(U, T, U, prec1, BF_RNDN);
|
|
bf_mul(r, r, U, prec1, BF_RNDN);
|
|
bf_add_si(r, r, 1, prec1, BF_RNDN);
|
|
}
|
|
bf_delete(U);
|
|
}
|
|
bf_delete(T);
|
|
|
|
/* undo the range reduction */
|
|
for(i = 0; i < K; i++) {
|
|
bf_mul(r, r, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
|
|
}
|
|
|
|
/* undo the argument reduction */
|
|
bf_mul_2exp(r, n, BF_PREC_INF, BF_RNDZ | BF_FLAG_EXT_EXP);
|
|
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
/* crude overflow and underflow tests for exp(a). a_low <= a <= a_high */
|
|
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_high->expn <= 0)
|
|
return 0;
|
|
|
|
e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
|
|
e_min = -e_max + 3;
|
|
if (flags & BF_FLAG_SUBNORMAL)
|
|
e_min -= (prec - 1);
|
|
|
|
bf_init(s, T);
|
|
bf_init(s, log2);
|
|
bf_const_log2(log2, LIMB_BITS, BF_RNDU);
|
|
bf_mul_ui(T, log2, e_max, LIMB_BITS, BF_RNDU);
|
|
/* a_low > e_max * log(2) implies exp(a) > e_max */
|
|
if (bf_cmp_lt(T, a_low) > 0) {
|
|
/* overflow */
|
|
bf_delete(T);
|
|
bf_delete(log2);
|
|
return bf_set_overflow(r, 0, prec, flags);
|
|
}
|
|
/* a_high < (e_min - 2) * log(2) implies exp(a) < (e_min - 2) */
|
|
bf_const_log2(log2, LIMB_BITS, BF_RNDD);
|
|
bf_mul_si(T, log2, e_min - 2, LIMB_BITS, BF_RNDD);
|
|
if (bf_cmp_lt(a_high, T)) {
|
|
int rnd_mode = flags & BF_RND_MASK;
|
|
|
|
/* underflow */
|
|
bf_delete(T);
|
|
bf_delete(log2);
|
|
if (rnd_mode == BF_RNDU) {
|
|
/* set the smallest value */
|
|
bf_set_ui(r, 1);
|
|
r->expn = e_min;
|
|
} else {
|
|
bf_set_zero(r, 0);
|
|
}
|
|
return BF_ST_UNDERFLOW | BF_ST_INEXACT;
|
|
}
|
|
bf_delete(log2);
|
|
bf_delete(T);
|
|
return 0;
|
|
}
|
|
|
|
int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
int ret;
|
|
assert(r != a);
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
if (a->sign)
|
|
bf_set_zero(r, 0);
|
|
else
|
|
bf_set_inf(r, 0);
|
|
} else {
|
|
bf_set_ui(r, 1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
|
|
if (ret)
|
|
return ret;
|
|
if (a->expn < 0 && (-a->expn) >= (prec + 2)) {
|
|
/* small argument case: result = 1 + epsilon * sign(x) */
|
|
bf_set_ui(r, 1);
|
|
return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
|
|
}
|
|
|
|
static int bf_log_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;
|
|
bf_t U_s, *U = &U_s;
|
|
bf_t V_s, *V = &V_s;
|
|
slimb_t n, prec1, l, i, K;
|
|
|
|
assert(r != a);
|
|
|
|
bf_init(s, T);
|
|
/* argument reduction 1 */
|
|
/* T=a*2^n with 2/3 <= T <= 4/3 */
|
|
{
|
|
bf_t U_s, *U = &U_s;
|
|
bf_set(T, a);
|
|
n = T->expn;
|
|
T->expn = 0;
|
|
/* U= ~ 2/3 */
|
|
bf_init(s, U);
|
|
bf_set_ui(U, 0xaaaaaaaa);
|
|
U->expn = 0;
|
|
if (bf_cmp_lt(T, U)) {
|
|
T->expn++;
|
|
n--;
|
|
}
|
|
bf_delete(U);
|
|
}
|
|
// printf("n=%ld\n", n);
|
|
// bf_print_str("T", T);
|
|
|
|
/* XXX: precision analysis */
|
|
/* number of iterations for argument reduction 2 */
|
|
K = bf_isqrt((prec + 1) / 2);
|
|
/* order of Taylor expansion */
|
|
l = prec / (2 * K) + 1;
|
|
/* precision of the intermediate computations */
|
|
prec1 = prec + K + 2 * l + 32;
|
|
|
|
bf_init(s, U);
|
|
bf_init(s, V);
|
|
|
|
/* Note: cancellation occurs here, so we use more precision (XXX:
|
|
reduce the precision by computing the exact cancellation) */
|
|
bf_add_si(T, T, -1, BF_PREC_INF, BF_RNDN);
|
|
|
|
/* argument reduction 2 */
|
|
for(i = 0; i < K; i++) {
|
|
/* T = T / (1 + sqrt(1 + T)) */
|
|
bf_add_si(U, T, 1, prec1, BF_RNDN);
|
|
bf_sqrt(V, U, prec1, BF_RNDF);
|
|
bf_add_si(U, V, 1, prec1, BF_RNDN);
|
|
bf_div(T, T, U, prec1, BF_RNDN);
|
|
}
|
|
|
|
{
|
|
bf_t Y_s, *Y = &Y_s;
|
|
bf_t Y2_s, *Y2 = &Y2_s;
|
|
bf_init(s, Y);
|
|
bf_init(s, Y2);
|
|
|
|
/* compute ln(1+x) = ln((1+y)/(1-y)) with y=x/(2+x)
|
|
= y + y^3/3 + ... + y^(2*l + 1) / (2*l+1)
|
|
with Y=Y^2
|
|
= y*(1+Y/3+Y^2/5+...) = y*(1+Y*(1/3+Y*(1/5 + ...)))
|
|
*/
|
|
bf_add_si(Y, T, 2, prec1, BF_RNDN);
|
|
bf_div(Y, T, Y, prec1, BF_RNDN);
|
|
|
|
bf_mul(Y2, Y, Y, prec1, BF_RNDN);
|
|
bf_set_ui(r, 0);
|
|
for(i = l; i >= 1; i--) {
|
|
bf_set_ui(U, 1);
|
|
bf_set_ui(V, 2 * i + 1);
|
|
bf_div(U, U, V, prec1, BF_RNDN);
|
|
bf_add(r, r, U, prec1, BF_RNDN);
|
|
bf_mul(r, r, Y2, prec1, BF_RNDN);
|
|
}
|
|
bf_add_si(r, r, 1, prec1, BF_RNDN);
|
|
bf_mul(r, r, Y, prec1, BF_RNDN);
|
|
bf_delete(Y);
|
|
bf_delete(Y2);
|
|
}
|
|
bf_delete(V);
|
|
bf_delete(U);
|
|
|
|
/* multiplication by 2 for the Taylor expansion and undo the
|
|
argument reduction 2*/
|
|
bf_mul_2exp(r, K + 1, BF_PREC_INF, BF_RNDZ);
|
|
|
|
/* undo the argument reduction 1 */
|
|
bf_const_log2(T, prec1, BF_RNDF);
|
|
bf_mul_si(T, T, n, prec1, BF_RNDN);
|
|
bf_add(r, r, T, prec1, BF_RNDN);
|
|
|
|
bf_delete(T);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
bf_t T_s, *T = &T_s;
|
|
|
|
assert(r != a);
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
if (a->sign) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_inf(r, 0);
|
|
return 0;
|
|
}
|
|
} else {
|
|
bf_set_inf(r, 1);
|
|
return 0;
|
|
}
|
|
}
|
|
if (a->sign) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
}
|
|
bf_init(s, T);
|
|
bf_set_ui(T, 1);
|
|
if (bf_cmp_eq(a, T)) {
|
|
bf_set_zero(r, 0);
|
|
bf_delete(T);
|
|
return 0;
|
|
}
|
|
bf_delete(T);
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_log_internal, NULL);
|
|
}
|
|
|
|
/* x and y finite and x > 0 */
|
|
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);
|
|
bf_mul(T, T, y, prec1, BF_RNDF | BF_FLAG_EXT_EXP);
|
|
if (bf_is_nan(T))
|
|
bf_set_nan(r);
|
|
else
|
|
bf_exp_internal(r, T, prec1, NULL); /* no overflow/underlow test needed */
|
|
bf_delete(T);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
/* x and y finite, x > 0, y integer and y fits on one limb */
|
|
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 */
|
|
prec1 = prec + ceil_log2(y1) * 2 + 8;
|
|
ret = bf_pow_ui(r, x, y1 < 0 ? -y1 : y1, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
|
|
if (y->sign) {
|
|
bf_init(s, T);
|
|
bf_set_ui(T, 1);
|
|
ret |= bf_div(r, T, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
|
|
bf_delete(T);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* 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. */
|
|
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)
|
|
return FALSE;
|
|
er = 0;
|
|
} else {
|
|
if ((e & (((limb_t)1 << n) - 1)) != 0)
|
|
return FALSE;
|
|
er = e >> n;
|
|
}
|
|
/* every perfect odd square = 1 modulo 8 */
|
|
v = get_bits(x->tab, x->len, x->len * LIMB_BITS - x->expn + e);
|
|
if ((v & 7) != 1)
|
|
return FALSE;
|
|
|
|
bf_init(s, T);
|
|
bf_set(T, x);
|
|
T->expn -= e;
|
|
for(i = 0; i < n; i++) {
|
|
if (i != 0)
|
|
bf_set(T, r);
|
|
if (bf_sqrtrem(r, NULL, T) != 0)
|
|
return FALSE;
|
|
}
|
|
r->expn += er;
|
|
return TRUE;
|
|
}
|
|
|
|
/* prec = BF_PREC_INF is accepted for x and y integers and y >= 0 */
|
|
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) {
|
|
/* pow(x, 0) = 1 */
|
|
bf_set_ui(r, 1);
|
|
} else if (x->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
} else {
|
|
int cmp_x_abs_1;
|
|
bf_set_ui(r, 1);
|
|
cmp_x_abs_1 = bf_cmpu(x, r);
|
|
if (cmp_x_abs_1 == 0 && (flags & BF_POW_JS_QUIRKS) &&
|
|
(y->expn >= BF_EXP_INF)) {
|
|
bf_set_nan(r);
|
|
} else if (cmp_x_abs_1 == 0 &&
|
|
(!x->sign || y->expn != BF_EXP_NAN)) {
|
|
/* pow(1, y) = 1 even if y = NaN */
|
|
/* pow(-1, +/-inf) = 1 */
|
|
} else if (y->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
} else if (y->expn == BF_EXP_INF) {
|
|
if (y->sign == (cmp_x_abs_1 > 0)) {
|
|
bf_set_zero(r, 0);
|
|
} else {
|
|
bf_set_inf(r, 0);
|
|
}
|
|
} else {
|
|
y_emin = bf_get_exp_min(y);
|
|
y_is_odd = (y_emin == 0);
|
|
if (y->sign == (x->expn == BF_EXP_ZERO)) {
|
|
bf_set_inf(r, y_is_odd & x->sign);
|
|
if (y->sign) {
|
|
/* pow(0, y) with y < 0 */
|
|
return BF_ST_DIVIDE_ZERO;
|
|
}
|
|
} else {
|
|
bf_set_zero(r, y_is_odd & x->sign);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
bf_init(s, T);
|
|
bf_set(T, x);
|
|
y_emin = bf_get_exp_min(y);
|
|
y_is_int = (y_emin >= 0);
|
|
rnd_mode = flags & BF_RND_MASK;
|
|
if (x->sign) {
|
|
if (!y_is_int) {
|
|
bf_set_nan(r);
|
|
bf_delete(T);
|
|
return BF_ST_INVALID_OP;
|
|
}
|
|
y_is_odd = (y_emin == 0);
|
|
r_sign = y_is_odd;
|
|
/* change the directed rounding mode if the sign of the result
|
|
is changed */
|
|
if (r_sign && (rnd_mode == BF_RNDD || rnd_mode == BF_RNDU))
|
|
flags ^= 1;
|
|
bf_neg(T);
|
|
} else {
|
|
r_sign = 0;
|
|
}
|
|
|
|
bf_set_ui(r, 1);
|
|
if (bf_cmp_eq(T, r)) {
|
|
/* abs(x) = 1: nothing more to do */
|
|
ret = 0;
|
|
} else {
|
|
/* check the overflow/underflow cases */
|
|
{
|
|
bf_t al_s, *al = &al_s;
|
|
bf_t ah_s, *ah = &ah_s;
|
|
limb_t precl = LIMB_BITS;
|
|
|
|
bf_init(s, al);
|
|
bf_init(s, ah);
|
|
/* compute bounds of log(abs(x)) * y with a low precision */
|
|
/* XXX: compute bf_log() once */
|
|
/* XXX: add a fast test before this slow test */
|
|
bf_log(al, T, precl, BF_RNDD);
|
|
bf_log(ah, T, precl, BF_RNDU);
|
|
bf_mul(al, al, y, precl, BF_RNDD ^ y->sign);
|
|
bf_mul(ah, ah, y, precl, BF_RNDU ^ y->sign);
|
|
ret = check_exp_underflow_overflow(s, r, al, ah, prec, flags);
|
|
bf_delete(al);
|
|
bf_delete(ah);
|
|
if (ret)
|
|
goto done;
|
|
}
|
|
|
|
if (y_is_int) {
|
|
slimb_t T_bits, e;
|
|
int_pow:
|
|
T_bits = T->expn - bf_get_exp_min(T);
|
|
if (T_bits == 1) {
|
|
/* pow(2^b, y) = 2^(b*y) */
|
|
bf_mul_si(T, y, T->expn - 1, LIMB_BITS, BF_RNDZ);
|
|
bf_get_limb(&e, T, 0);
|
|
bf_set_ui(r, 1);
|
|
ret = bf_mul_2exp(r, e, prec, flags);
|
|
} else if (prec == BF_PREC_INF) {
|
|
slimb_t y1;
|
|
/* specific case for infinite precision (integer case) */
|
|
bf_get_limb(&y1, y, 0);
|
|
assert(!y->sign);
|
|
/* x must be an integer, so abs(x) >= 2 */
|
|
if (y1 >= ((slimb_t)1 << BF_EXP_BITS_MAX)) {
|
|
bf_delete(T);
|
|
return bf_set_overflow(r, 0, BF_PREC_INF, flags);
|
|
}
|
|
ret = bf_pow_ui(r, T, y1, BF_PREC_INF, BF_RNDZ);
|
|
} else {
|
|
if (y->expn <= 31) {
|
|
/* small enough power: use exponentiation in all cases */
|
|
} else if (y->sign) {
|
|
/* cannot be exact */
|
|
goto general_case;
|
|
} else {
|
|
if (rnd_mode == BF_RNDF)
|
|
goto general_case; /* no need to track exact results */
|
|
/* see if the result has a chance to be exact:
|
|
if x=a*2^b (a odd), x^y=a^y*2^(b*y)
|
|
x^y needs a precision of at least floor_log2(a)*y bits
|
|
*/
|
|
bf_mul_si(r, y, T_bits - 1, LIMB_BITS, BF_RNDZ);
|
|
bf_get_limb(&e, r, 0);
|
|
if (prec < e)
|
|
goto general_case;
|
|
}
|
|
ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_int, (void *)y);
|
|
}
|
|
} else {
|
|
if (rnd_mode != BF_RNDF) {
|
|
bf_t *y1;
|
|
if (y_emin < 0 && check_exact_power2n(r, T, -y_emin)) {
|
|
/* the problem is reduced to a power to an integer */
|
|
bf_set(T, r);
|
|
y1 = &ytmp_s;
|
|
y1->tab = y->tab;
|
|
y1->len = y->len;
|
|
y1->sign = y->sign;
|
|
y1->expn = y->expn - y_emin;
|
|
y = y1;
|
|
goto int_pow;
|
|
}
|
|
}
|
|
general_case:
|
|
ret = bf_ziv_rounding(r, T, prec, flags, bf_pow_generic, (void *)y);
|
|
}
|
|
}
|
|
done:
|
|
bf_delete(T);
|
|
r->sign = r_sign;
|
|
return ret;
|
|
}
|
|
|
|
/* compute sqrt(-2*x-x^2) to get |sin(x)| from cos(x) - 1. */
|
|
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_RNDF);
|
|
bf_delete(T);
|
|
}
|
|
|
|
static int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
|
|
{
|
|
bf_context_t *s1 = a->ctx;
|
|
bf_t T_s, *T = &T_s;
|
|
bf_t U_s, *U = &U_s;
|
|
bf_t r_s, *r = &r_s;
|
|
slimb_t K, prec1, i, l, mod, prec2;
|
|
int is_neg;
|
|
|
|
assert(c != a && s != a);
|
|
|
|
bf_init(s1, T);
|
|
bf_init(s1, U);
|
|
bf_init(s1, r);
|
|
|
|
/* XXX: precision analysis */
|
|
K = bf_isqrt(prec / 2);
|
|
l = prec / (2 * K) + 1;
|
|
prec1 = prec + 2 * K + l + 8;
|
|
|
|
/* after the modulo reduction, -pi/4 <= T <= pi/4 */
|
|
if (a->expn <= -1) {
|
|
/* abs(a) <= 0.25: no modulo reduction needed */
|
|
bf_set(T, a);
|
|
mod = 0;
|
|
} else {
|
|
slimb_t cancel;
|
|
cancel = 0;
|
|
for(;;) {
|
|
prec2 = prec1 + a->expn + cancel;
|
|
bf_const_pi(U, prec2, BF_RNDF);
|
|
bf_mul_2exp(U, -1, BF_PREC_INF, BF_RNDZ);
|
|
bf_remquo(&mod, T, a, U, prec2, BF_RNDN, BF_RNDN);
|
|
// printf("T.expn=%ld prec2=%ld\n", T->expn, prec2);
|
|
if (mod == 0 || (T->expn != BF_EXP_ZERO &&
|
|
(T->expn + prec2) >= (prec1 - 1)))
|
|
break;
|
|
/* increase the number of bits until the precision is good enough */
|
|
cancel = bf_max(-T->expn, (cancel + 1) * 3 / 2);
|
|
}
|
|
mod &= 3;
|
|
}
|
|
|
|
is_neg = T->sign;
|
|
|
|
/* compute cosm1(x) = cos(x) - 1 */
|
|
bf_mul(T, T, T, prec1, BF_RNDN);
|
|
bf_mul_2exp(T, -2 * K, BF_PREC_INF, BF_RNDZ);
|
|
|
|
/* Taylor expansion:
|
|
-x^2/2 + x^4/4! - x^6/6! + ...
|
|
*/
|
|
bf_set_ui(r, 1);
|
|
for(i = l ; i >= 1; i--) {
|
|
bf_set_ui(U, 2 * i - 1);
|
|
bf_mul_ui(U, U, 2 * i, BF_PREC_INF, BF_RNDZ);
|
|
bf_div(U, T, U, prec1, BF_RNDN);
|
|
bf_mul(r, r, U, prec1, BF_RNDN);
|
|
bf_neg(r);
|
|
if (i != 1)
|
|
bf_add_si(r, r, 1, prec1, BF_RNDN);
|
|
}
|
|
bf_delete(U);
|
|
|
|
/* undo argument reduction:
|
|
cosm1(2*x)= 2*(2*cosm1(x)+cosm1(x)^2)
|
|
*/
|
|
for(i = 0; i < K; i++) {
|
|
bf_mul(T, r, r, prec1, BF_RNDN);
|
|
bf_mul_2exp(r, 1, BF_PREC_INF, BF_RNDZ);
|
|
bf_add(r, r, T, prec1, BF_RNDN);
|
|
bf_mul_2exp(r, 1, BF_PREC_INF, BF_RNDZ);
|
|
}
|
|
bf_delete(T);
|
|
|
|
if (c) {
|
|
if ((mod & 1) == 0) {
|
|
bf_add_si(c, r, 1, prec1, BF_RNDN);
|
|
} else {
|
|
bf_sqrt_sin(c, r, prec1);
|
|
c->sign = is_neg ^ 1;
|
|
}
|
|
c->sign ^= mod >> 1;
|
|
}
|
|
if (s) {
|
|
if ((mod & 1) == 0) {
|
|
bf_sqrt_sin(s, r, prec1);
|
|
s->sign = is_neg;
|
|
} else {
|
|
bf_add_si(s, r, 1, prec1, BF_RNDN);
|
|
}
|
|
s->sign ^= mod >> 1;
|
|
}
|
|
bf_delete(r);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
static int bf_cos_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
|
|
{
|
|
return bf_sincos(NULL, r, a, prec);
|
|
}
|
|
|
|
int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_ui(r, 1);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* small argument case: result = 1+r(x) with r(x) = -x^2/2 +
|
|
O(X^4). We assume r(x) < 2^(2*EXP(x) - 1). */
|
|
if (a->expn < 0) {
|
|
slimb_t e;
|
|
e = 2 * a->expn - 1;
|
|
if (e < -(prec + 2)) {
|
|
bf_set_ui(r, 1);
|
|
return bf_add_epsilon(r, r, e, 1, prec, flags);
|
|
}
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_cos_internal, NULL);
|
|
}
|
|
|
|
static int bf_sin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
|
|
{
|
|
return bf_sincos(r, NULL, a, prec);
|
|
}
|
|
|
|
int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_zero(r, a->sign);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* small argument case: result = x+r(x) with r(x) = -x^3/6 +
|
|
O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
|
|
if (a->expn < 0) {
|
|
slimb_t e;
|
|
e = sat_add(2 * a->expn, a->expn - 2);
|
|
if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
|
|
bf_set(r, a);
|
|
return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
|
|
}
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
|
|
}
|
|
|
|
static int bf_tan_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;
|
|
limb_t prec1;
|
|
|
|
/* XXX: precision analysis */
|
|
prec1 = prec + 8;
|
|
bf_init(s, T);
|
|
bf_sincos(r, T, a, prec1);
|
|
bf_div(r, r, T, prec1, BF_RNDF);
|
|
bf_delete(T);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
assert(r != a);
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_zero(r, a->sign);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* small argument case: result = x+r(x) with r(x) = x^3/3 +
|
|
O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
|
|
if (a->expn < 0) {
|
|
slimb_t e;
|
|
e = sat_add(2 * a->expn, a->expn - 1);
|
|
if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
|
|
bf_set(r, a);
|
|
return bf_add_epsilon(r, r, e, a->sign, prec, flags);
|
|
}
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_tan_internal, NULL);
|
|
}
|
|
|
|
/* if add_pi2 is true, add pi/2 to the result (used for acos(x) to
|
|
avoid cancellation) */
|
|
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, K, l;
|
|
|
|
/* XXX: precision analysis */
|
|
K = bf_isqrt((prec + 1) / 2);
|
|
l = prec / (2 * K) + 1;
|
|
prec1 = prec + K + 2 * l + 32;
|
|
// printf("prec=%d K=%d l=%d prec1=%d\n", (int)prec, (int)K, (int)l, (int)prec1);
|
|
|
|
bf_init(s, T);
|
|
cmp_1 = (a->expn >= 1); /* a >= 1 */
|
|
if (cmp_1) {
|
|
bf_set_ui(T, 1);
|
|
bf_div(T, T, a, prec1, BF_RNDN);
|
|
} else {
|
|
bf_set(T, a);
|
|
}
|
|
|
|
/* abs(T) <= 1 */
|
|
|
|
/* argument reduction */
|
|
|
|
bf_init(s, U);
|
|
bf_init(s, V);
|
|
bf_init(s, X2);
|
|
for(i = 0; i < K; i++) {
|
|
/* T = T / (1 + sqrt(1 + T^2)) */
|
|
bf_mul(U, T, T, prec1, BF_RNDN);
|
|
bf_add_si(U, U, 1, prec1, BF_RNDN);
|
|
bf_sqrt(V, U, prec1, BF_RNDN);
|
|
bf_add_si(V, V, 1, prec1, BF_RNDN);
|
|
bf_div(T, T, V, prec1, BF_RNDN);
|
|
}
|
|
|
|
/* Taylor series:
|
|
x - x^3/3 + ... + (-1)^ l * y^(2*l + 1) / (2*l+1)
|
|
*/
|
|
bf_mul(X2, T, T, prec1, BF_RNDN);
|
|
bf_set_ui(r, 0);
|
|
for(i = l; i >= 1; i--) {
|
|
bf_set_si(U, 1);
|
|
bf_set_ui(V, 2 * i + 1);
|
|
bf_div(U, U, V, prec1, BF_RNDN);
|
|
bf_neg(r);
|
|
bf_add(r, r, U, prec1, BF_RNDN);
|
|
bf_mul(r, r, X2, prec1, BF_RNDN);
|
|
}
|
|
bf_neg(r);
|
|
bf_add_si(r, r, 1, prec1, BF_RNDN);
|
|
bf_mul(r, r, T, prec1, BF_RNDN);
|
|
|
|
/* undo the argument reduction */
|
|
bf_mul_2exp(r, K, BF_PREC_INF, BF_RNDZ);
|
|
|
|
bf_delete(U);
|
|
bf_delete(V);
|
|
bf_delete(X2);
|
|
|
|
i = add_pi2;
|
|
if (cmp_1 > 0) {
|
|
/* undo the inversion : r = sign(a)*PI/2 - r */
|
|
bf_neg(r);
|
|
i += 1 - 2 * a->sign;
|
|
}
|
|
/* add i*(pi/2) with -1 <= i <= 2 */
|
|
if (i != 0) {
|
|
bf_const_pi(T, prec1, BF_RNDF);
|
|
if (i != 2)
|
|
bf_mul_2exp(T, -1, BF_PREC_INF, BF_RNDZ);
|
|
T->sign = (i < 0);
|
|
bf_add(r, T, r, prec1, BF_RNDN);
|
|
}
|
|
|
|
bf_delete(T);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
bf_t T_s, *T = &T_s;
|
|
int res;
|
|
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
/* -PI/2 or PI/2 */
|
|
bf_const_pi_signed(r, a->sign, prec, flags);
|
|
bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
|
|
return BF_ST_INEXACT;
|
|
} else {
|
|
bf_set_zero(r, a->sign);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
bf_init(s, T);
|
|
bf_set_ui(T, 1);
|
|
res = bf_cmpu(a, T);
|
|
bf_delete(T);
|
|
if (res == 0) {
|
|
/* short cut: abs(a) == 1 -> +/-pi/4 */
|
|
bf_const_pi_signed(r, a->sign, prec, flags);
|
|
bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
/* small argument case: result = x+r(x) with r(x) = -x^3/3 +
|
|
O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
|
|
if (a->expn < 0) {
|
|
slimb_t e;
|
|
e = sat_add(2 * a->expn, a->expn - 1);
|
|
if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
|
|
bf_set(r, a);
|
|
return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
|
|
}
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_atan_internal, (void *)FALSE);
|
|
}
|
|
|
|
static int bf_atan2_internal(bf_t *r, const bf_t *y, limb_t prec, void *opaque)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
const bf_t *x = opaque;
|
|
bf_t T_s, *T = &T_s;
|
|
limb_t prec1;
|
|
int ret;
|
|
|
|
if (y->expn == BF_EXP_NAN || x->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
}
|
|
|
|
/* compute atan(y/x) assumming inf/inf = 1 and 0/0 = 0 */
|
|
bf_init(s, T);
|
|
prec1 = prec + 32;
|
|
if (y->expn == BF_EXP_INF && x->expn == BF_EXP_INF) {
|
|
bf_set_ui(T, 1);
|
|
T->sign = y->sign ^ x->sign;
|
|
} else if (y->expn == BF_EXP_ZERO && x->expn == BF_EXP_ZERO) {
|
|
bf_set_zero(T, y->sign ^ x->sign);
|
|
} else {
|
|
bf_div(T, y, x, prec1, BF_RNDF);
|
|
}
|
|
ret = bf_atan(r, T, prec1, BF_RNDF);
|
|
|
|
if (x->sign) {
|
|
/* if x < 0 (it includes -0), return sign(y)*pi + atan(y/x) */
|
|
bf_const_pi(T, prec1, BF_RNDF);
|
|
T->sign = y->sign;
|
|
bf_add(r, r, T, prec1, BF_RNDN);
|
|
ret |= BF_ST_INEXACT;
|
|
}
|
|
|
|
bf_delete(T);
|
|
return ret;
|
|
}
|
|
|
|
int bf_atan2(bf_t *r, const bf_t *y, const bf_t *x,
|
|
limb_t prec, bf_flags_t flags)
|
|
{
|
|
return bf_ziv_rounding(r, y, prec, flags, bf_atan2_internal, (void *)x);
|
|
}
|
|
|
|
static int bf_asin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
BOOL is_acos = (BOOL)(intptr_t)opaque;
|
|
bf_t T_s, *T = &T_s;
|
|
limb_t prec1, prec2;
|
|
|
|
/* asin(x) = atan(x/sqrt(1-x^2))
|
|
acos(x) = pi/2 - asin(x) */
|
|
prec1 = prec + 8;
|
|
/* increase the precision in x^2 to compensate the cancellation in
|
|
(1-x^2) if x is close to 1 */
|
|
/* XXX: use less precision when possible */
|
|
if (a->expn >= 0)
|
|
prec2 = BF_PREC_INF;
|
|
else
|
|
prec2 = prec1;
|
|
bf_init(s, T);
|
|
bf_mul(T, a, a, prec2, BF_RNDN);
|
|
bf_neg(T);
|
|
bf_add_si(T, T, 1, prec2, BF_RNDN);
|
|
|
|
bf_sqrt(r, T, prec1, BF_RNDN);
|
|
bf_div(T, a, r, prec1, BF_RNDN);
|
|
if (is_acos)
|
|
bf_neg(T);
|
|
bf_atan_internal(r, T, prec1, (void *)(intptr_t)is_acos);
|
|
bf_delete(T);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
|
|
int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
bf_t T_s, *T = &T_s;
|
|
int res;
|
|
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_set_zero(r, a->sign);
|
|
return 0;
|
|
}
|
|
}
|
|
bf_init(s, T);
|
|
bf_set_ui(T, 1);
|
|
res = bf_cmpu(a, T);
|
|
bf_delete(T);
|
|
if (res > 0) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
}
|
|
|
|
/* small argument case: result = x+r(x) with r(x) = x^3/6 +
|
|
O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
|
|
if (a->expn < 0) {
|
|
slimb_t e;
|
|
e = sat_add(2 * a->expn, a->expn - 2);
|
|
if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
|
|
bf_set(r, a);
|
|
return bf_add_epsilon(r, r, e, a->sign, prec, flags);
|
|
}
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)FALSE);
|
|
}
|
|
|
|
int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
bf_t T_s, *T = &T_s;
|
|
int res;
|
|
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bf_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bf_const_pi(r, prec, flags);
|
|
bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
|
|
return BF_ST_INEXACT;
|
|
}
|
|
}
|
|
bf_init(s, T);
|
|
bf_set_ui(T, 1);
|
|
res = bf_cmpu(a, T);
|
|
bf_delete(T);
|
|
if (res > 0) {
|
|
bf_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else if (res == 0 && a->sign == 0) {
|
|
bf_set_zero(r, 0);
|
|
return 0;
|
|
}
|
|
|
|
return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)TRUE);
|
|
}
|
|
|
|
/***************************************************************/
|
|
/* decimal floating point numbers */
|
|
|
|
#ifdef USE_BF_DEC
|
|
|
|
#define adddq(r1, r0, a1, a0) \
|
|
do { \
|
|
limb_t __t = r0; \
|
|
r0 += (a0); \
|
|
r1 += (a1) + (r0 < __t); \
|
|
} while (0)
|
|
|
|
#define subdq(r1, r0, a1, a0) \
|
|
do { \
|
|
limb_t __t = r0; \
|
|
r0 -= (a0); \
|
|
r1 -= (a1) + (r0 > __t); \
|
|
} while (0)
|
|
|
|
#if LIMB_BITS == 64
|
|
|
|
/* Note: we assume __int128 is available */
|
|
#define muldq(r1, r0, a, b) \
|
|
do { \
|
|
unsigned __int128 __t; \
|
|
__t = (unsigned __int128)(a) * (unsigned __int128)(b); \
|
|
r0 = __t; \
|
|
r1 = __t >> 64; \
|
|
} while (0)
|
|
|
|
#define divdq(q, r, a1, a0, b) \
|
|
do { \
|
|
unsigned __int128 __t; \
|
|
limb_t __b = (b); \
|
|
__t = ((unsigned __int128)(a1) << 64) | (a0); \
|
|
q = __t / __b; \
|
|
r = __t % __b; \
|
|
} while (0)
|
|
|
|
#else
|
|
|
|
#define muldq(r1, r0, a, b) \
|
|
do { \
|
|
uint64_t __t; \
|
|
__t = (uint64_t)(a) * (uint64_t)(b); \
|
|
r0 = __t; \
|
|
r1 = __t >> 32; \
|
|
} while (0)
|
|
|
|
#define divdq(q, r, a1, a0, b) \
|
|
do { \
|
|
uint64_t __t; \
|
|
limb_t __b = (b); \
|
|
__t = ((uint64_t)(a1) << 32) | (a0); \
|
|
q = __t / __b; \
|
|
r = __t % __b; \
|
|
} while (0)
|
|
|
|
#endif /* LIMB_BITS != 64 */
|
|
|
|
#if LIMB_DIGITS == 19
|
|
|
|
/* WARNING: hardcoded for b = 1e19. It is assumed that:
|
|
0 <= a1 < 2^63 */
|
|
#define divdq_base(q, r, a1, a0)\
|
|
do {\
|
|
uint64_t __a0, __a1, __t0, __t1, __b = BF_DEC_BASE; \
|
|
__a0 = a0;\
|
|
__a1 = a1;\
|
|
__t0 = __a1;\
|
|
__t0 = shld(__t0, __a0, 1);\
|
|
muldq(q, __t1, __t0, UINT64_C(17014118346046923173)); \
|
|
muldq(__t1, __t0, q, __b);\
|
|
subdq(__a1, __a0, __t1, __t0);\
|
|
subdq(__a1, __a0, 1, __b * 2); \
|
|
__t0 = (slimb_t)__a1 >> 1; \
|
|
q += 2 + __t0;\
|
|
adddq(__a1, __a0, 0, __b & __t0);\
|
|
q += __a1; \
|
|
__a0 += __b & __a1; \
|
|
r = __a0;\
|
|
} while(0)
|
|
|
|
#elif LIMB_DIGITS == 9
|
|
|
|
/* WARNING: hardcoded for b = 1e9. It is assumed that:
|
|
0 <= a1 < 2^29 */
|
|
#define divdq_base(q, r, a1, a0)\
|
|
do {\
|
|
uint32_t __t0, __t1, __b = BF_DEC_BASE; \
|
|
__t0 = a1;\
|
|
__t1 = a0;\
|
|
__t0 = (__t0 << 3) | (__t1 >> (32 - 3)); \
|
|
muldq(q, __t1, __t0, 2305843009U);\
|
|
r = a0 - q * __b;\
|
|
__t1 = (r >= __b);\
|
|
q += __t1;\
|
|
if (__t1)\
|
|
r -= __b;\
|
|
} while(0)
|
|
|
|
#endif
|
|
|
|
/* fast integer division by a fixed constant */
|
|
|
|
typedef struct FastDivData {
|
|
limb_t m1; /* multiplier */
|
|
int8_t shift1;
|
|
int8_t shift2;
|
|
} FastDivData;
|
|
|
|
/* From "Division by Invariant Integers using Multiplication" by
|
|
Torborn Granlund and Peter L. Montgomery */
|
|
/* d must be != 0 */
|
|
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 = m1;
|
|
s->shift1 = l;
|
|
if (s->shift1 > 1)
|
|
s->shift1 = 1;
|
|
s->shift2 = l - 1;
|
|
if (s->shift2 < 0)
|
|
s->shift2 = 0;
|
|
}
|
|
|
|
static inline limb_t fast_udiv(limb_t a, const FastDivData *s)
|
|
{
|
|
limb_t t0, t1;
|
|
muldq(t1, t0, s->m1, a);
|
|
t0 = (a - t1) >> s->shift1;
|
|
return (t1 + t0) >> s->shift2;
|
|
}
|
|
|
|
/* contains 10^i */
|
|
const limb_t mp_pow_dec[LIMB_DIGITS + 1] = {
|
|
1U,
|
|
10U,
|
|
100U,
|
|
1000U,
|
|
10000U,
|
|
100000U,
|
|
1000000U,
|
|
10000000U,
|
|
100000000U,
|
|
1000000000U,
|
|
#if LIMB_BITS == 64
|
|
10000000000U,
|
|
100000000000U,
|
|
1000000000000U,
|
|
10000000000000U,
|
|
100000000000000U,
|
|
1000000000000000U,
|
|
10000000000000000U,
|
|
100000000000000000U,
|
|
1000000000000000000U,
|
|
10000000000000000000U,
|
|
#endif
|
|
};
|
|
|
|
/* precomputed from fast_udiv_init(10^i) */
|
|
static const FastDivData mp_pow_div[LIMB_DIGITS + 1] = {
|
|
#if LIMB_BITS == 32
|
|
{ 0x00000001, 0, 0 },
|
|
{ 0x9999999a, 1, 3 },
|
|
{ 0x47ae147b, 1, 6 },
|
|
{ 0x0624dd30, 1, 9 },
|
|
{ 0xa36e2eb2, 1, 13 },
|
|
{ 0x4f8b588f, 1, 16 },
|
|
{ 0x0c6f7a0c, 1, 19 },
|
|
{ 0xad7f29ac, 1, 23 },
|
|
{ 0x5798ee24, 1, 26 },
|
|
{ 0x12e0be83, 1, 29 },
|
|
#else
|
|
{ 0x0000000000000001, 0, 0 },
|
|
{ 0x999999999999999a, 1, 3 },
|
|
{ 0x47ae147ae147ae15, 1, 6 },
|
|
{ 0x0624dd2f1a9fbe77, 1, 9 },
|
|
{ 0xa36e2eb1c432ca58, 1, 13 },
|
|
{ 0x4f8b588e368f0847, 1, 16 },
|
|
{ 0x0c6f7a0b5ed8d36c, 1, 19 },
|
|
{ 0xad7f29abcaf48579, 1, 23 },
|
|
{ 0x5798ee2308c39dfa, 1, 26 },
|
|
{ 0x12e0be826d694b2f, 1, 29 },
|
|
{ 0xb7cdfd9d7bdbab7e, 1, 33 },
|
|
{ 0x5fd7fe17964955fe, 1, 36 },
|
|
{ 0x19799812dea11198, 1, 39 },
|
|
{ 0xc25c268497681c27, 1, 43 },
|
|
{ 0x6849b86a12b9b01f, 1, 46 },
|
|
{ 0x203af9ee756159b3, 1, 49 },
|
|
{ 0xcd2b297d889bc2b7, 1, 53 },
|
|
{ 0x70ef54646d496893, 1, 56 },
|
|
{ 0x2725dd1d243aba0f, 1, 59 },
|
|
{ 0xd83c94fb6d2ac34d, 1, 63 },
|
|
#endif
|
|
};
|
|
|
|
/* divide by 10^shift with 0 <= shift <= LIMB_DIGITS */
|
|
static inline limb_t fast_shr_dec(limb_t a, int shift)
|
|
{
|
|
return fast_udiv(a, &mp_pow_div[shift]);
|
|
}
|
|
|
|
/* division and remainder by 10^shift */
|
|
#define fast_shr_rem_dec(q, r, a, shift) q = fast_shr_dec(a, shift), r = a - q * mp_pow_dec[shift]
|
|
|
|
limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2,
|
|
mp_size_t n, limb_t carry)
|
|
{
|
|
limb_t base = BF_DEC_BASE;
|
|
mp_size_t i;
|
|
limb_t k, a, v;
|
|
|
|
k=carry;
|
|
for(i=0;i<n;i++) {
|
|
/* XXX: reuse the trick in add_mod */
|
|
v = op1[i];
|
|
a = v + op2[i] + k - base;
|
|
k = a <= v;
|
|
if (!k)
|
|
a += base;
|
|
res[i]=a;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
|
|
{
|
|
limb_t base = BF_DEC_BASE;
|
|
mp_size_t i;
|
|
limb_t k, a, v;
|
|
|
|
k=b;
|
|
for(i=0;i<n;i++) {
|
|
v = tab[i];
|
|
a = v + k - base;
|
|
k = a <= v;
|
|
if (!k)
|
|
a += base;
|
|
tab[i] = a;
|
|
if (k == 0)
|
|
break;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
limb_t mp_sub_dec(limb_t *res, const limb_t *op1, const limb_t *op2,
|
|
mp_size_t n, limb_t carry)
|
|
{
|
|
limb_t base = BF_DEC_BASE;
|
|
mp_size_t i;
|
|
limb_t k, v, a;
|
|
|
|
k=carry;
|
|
for(i=0;i<n;i++) {
|
|
v = op1[i];
|
|
a = v - op2[i] - k;
|
|
k = a > v;
|
|
if (k)
|
|
a += base;
|
|
res[i] = a;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
limb_t mp_sub_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
|
|
{
|
|
limb_t base = BF_DEC_BASE;
|
|
mp_size_t i;
|
|
limb_t k, v, a;
|
|
|
|
k=b;
|
|
for(i=0;i<n;i++) {
|
|
v = tab[i];
|
|
a = v - k;
|
|
k = a > v;
|
|
if (k)
|
|
a += base;
|
|
tab[i]=a;
|
|
if (k == 0)
|
|
break;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
/* taba[] = taba[] * b + l. 0 <= b, l <= base - 1. Return the high carry */
|
|
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;
|
|
}
|
|
|
|
/* tabr[] += taba[] * b. 0 <= b <= base - 1. Return the value to add
|
|
to the high word */
|
|
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[i] = r;
|
|
}
|
|
return l;
|
|
}
|
|
|
|
/* tabr[] -= taba[] * b. 0 <= b <= base - 1. Return the value to
|
|
substract to the high word. */
|
|
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);
|
|
divdq_base(l, r, t1, t0);
|
|
v = tabr[i];
|
|
a = v - r;
|
|
c = a > v;
|
|
if (c)
|
|
a += base;
|
|
/* never bigger than base because r = 0 when l = base - 1 */
|
|
l += c;
|
|
tabr[i] = a;
|
|
}
|
|
return l;
|
|
}
|
|
|
|
/* size of the result : op1_size + op2_size. */
|
|
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 = mp_add_mul1_dec(result + i, op1, op1_size, op2[i]);
|
|
result[i + op1_size] = r;
|
|
}
|
|
}
|
|
|
|
/* taba[] = (taba[] + r*base^na) / b. 0 <= b < base. 0 <= r <
|
|
b. Return the remainder. */
|
|
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 */
|
|
base_div2 = base >> 1;
|
|
if (r)
|
|
r = base_div2;
|
|
for(i = na - 1; i >= 0; i--) {
|
|
t0 = taba[i];
|
|
tabr[i] = (t0 >> 1) + r;
|
|
r = 0;
|
|
if (t0 & 1)
|
|
r = base_div2;
|
|
}
|
|
if (r)
|
|
r = 1;
|
|
} else
|
|
#endif
|
|
if (na >= UDIV1NORM_THRESHOLD) {
|
|
shift = clz(b);
|
|
if (shift == 0) {
|
|
/* normalized case: b >= 2^(LIMB_BITS-1) */
|
|
limb_t b_inv;
|
|
b_inv = udiv1norm_init(b);
|
|
for(i = na - 1; i >= 0; i--) {
|
|
muldq(t1, t0, r, base);
|
|
adddq(t1, t0, 0, taba[i]);
|
|
q = udiv1norm(&r, t1, t0, b, b_inv);
|
|
tabr[i] = q;
|
|
}
|
|
} else {
|
|
limb_t b_inv;
|
|
b <<= shift;
|
|
b_inv = udiv1norm_init(b);
|
|
for(i = na - 1; i >= 0; i--) {
|
|
muldq(t1, t0, r, base);
|
|
adddq(t1, t0, 0, taba[i]);
|
|
t1 = (t1 << shift) | (t0 >> (LIMB_BITS - shift));
|
|
t0 <<= shift;
|
|
q = udiv1norm(&r, t1, t0, b, b_inv);
|
|
r >>= shift;
|
|
tabr[i] = q;
|
|
}
|
|
}
|
|
} else {
|
|
for(i = na - 1; i >= 0; i--) {
|
|
muldq(t1, t0, r, base);
|
|
adddq(t1, t0, 0, taba[i]);
|
|
divdq(q, r, t1, t0, b);
|
|
tabr[i] = q;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static __maybe_unused void mp_print_str_dec(const char *str,
|
|
const limb_t *tab, slimb_t n)
|
|
{
|
|
slimb_t i;
|
|
printf("%s=", str);
|
|
for(i = n - 1; i >= 0; i--) {
|
|
if (i != n - 1)
|
|
printf("_");
|
|
printf("%0*" PRIu_LIMB, LIMB_DIGITS, tab[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static __maybe_unused void mp_print_str_h_dec(const char *str,
|
|
const limb_t *tab, slimb_t n,
|
|
limb_t high)
|
|
{
|
|
slimb_t i;
|
|
printf("%s=", str);
|
|
printf("%0*" PRIu_LIMB, LIMB_DIGITS, high);
|
|
for(i = n - 1; i >= 0; i--) {
|
|
printf("_");
|
|
printf("%0*" PRIu_LIMB, LIMB_DIGITS, tab[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
//#define DEBUG_DIV_SLOW
|
|
|
|
#define DIV_STATIC_ALLOC_LEN 16
|
|
|
|
/* 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.
|
|
|
|
Running time of the standard method: (na - nb + 1) * nb
|
|
Return 0 if OK, -1 if memory alloc error
|
|
*/
|
|
/* XXX: optimize */
|
|
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 DEBUG_DIV_SLOW
|
|
mp_print_str_dec("a", taba, na);
|
|
mp_print_str_dec("b", tabb1, nb);
|
|
#endif
|
|
|
|
/* normalize tabb */
|
|
r = tabb1[nb - 1];
|
|
assert(r != 0);
|
|
i = na - nb;
|
|
if (r >= BF_DEC_BASE / 2) {
|
|
mult = 1;
|
|
tabb = (limb_t *)tabb1;
|
|
q = 1;
|
|
for(j = nb - 1; j >= 0; j--) {
|
|
if (taba[i + j] != tabb[j]) {
|
|
if (taba[i + j] < tabb[j])
|
|
q = 0;
|
|
break;
|
|
}
|
|
}
|
|
tabq[i] = q;
|
|
if (q) {
|
|
mp_sub_dec(taba + i, taba + i, tabb, nb, 0);
|
|
}
|
|
i--;
|
|
} else {
|
|
mult = base / (r + 1);
|
|
if (likely(nb <= DIV_STATIC_ALLOC_LEN)) {
|
|
tabb = static_tabb;
|
|
} else {
|
|
tabb = bf_malloc(s, sizeof(limb_t) * nb);
|
|
if (!tabb)
|
|
return -1;
|
|
}
|
|
mp_mul1_dec(tabb, tabb1, nb, mult, 0);
|
|
taba[na] = mp_mul1_dec(taba, taba, na, mult, 0);
|
|
}
|
|
|
|
#ifdef DEBUG_DIV_SLOW
|
|
printf("mult=" FMT_LIMB "\n", mult);
|
|
mp_print_str_dec("a_norm", taba, na + 1);
|
|
mp_print_str_dec("b_norm", tabb, nb);
|
|
#endif
|
|
|
|
for(; i >= 0; i--) {
|
|
if (unlikely(taba[i + nb] >= tabb[nb - 1])) {
|
|
/* XXX: check if it is really possible */
|
|
q = base - 1;
|
|
} else {
|
|
muldq(t1, t0, taba[i + nb], base);
|
|
adddq(t1, t0, 0, taba[i + nb - 1]);
|
|
divdq(q, r, t1, t0, tabb[nb - 1]);
|
|
}
|
|
// printf("i=%d q1=%ld\n", i, q);
|
|
|
|
r = mp_sub_mul1_dec(taba + i, tabb, nb, q);
|
|
// mp_dump("r1", taba + i, nb, bd);
|
|
// printf("r2=%ld\n", r);
|
|
|
|
v = taba[i + nb];
|
|
a = v - r;
|
|
c = a > v;
|
|
if (c)
|
|
a += base;
|
|
taba[i + nb] = a;
|
|
|
|
if (c != 0) {
|
|
/* negative result */
|
|
for(;;) {
|
|
q--;
|
|
c = mp_add_dec(taba + i, taba + i, tabb, nb, 0);
|
|
/* propagate carry and test if positive result */
|
|
if (c != 0) {
|
|
if (++taba[i + nb] == base) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tabq[i] = q;
|
|
}
|
|
|
|
#ifdef DEBUG_DIV_SLOW
|
|
mp_print_str_dec("q", tabq, na - nb + 1);
|
|
mp_print_str_dec("r", taba, nb);
|
|
#endif
|
|
|
|
/* remove the normalization */
|
|
if (mult != 1) {
|
|
mp_div1_dec(taba, taba, nb, mult, 0);
|
|
if (unlikely(tabb != static_tabb))
|
|
bf_free(s, tabb);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* divide by 10^shift */
|
|
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, shift);
|
|
tab_r[i] = q + l * mp_pow_dec[LIMB_DIGITS - shift];
|
|
l = r;
|
|
}
|
|
return l;
|
|
}
|
|
|
|
/* multiply by 10^shift */
|
|
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_DIGITS - shift);
|
|
tab_r[i] = r * mp_pow_dec[shift] + l;
|
|
l = q;
|
|
}
|
|
return l;
|
|
}
|
|
|
|
static limb_t mp_sqrtrem2_dec(limb_t *tabs, limb_t *taba)
|
|
{
|
|
int k;
|
|
dlimb_t a, b, r;
|
|
limb_t taba1[2], s, r0, r1;
|
|
|
|
/* convert to binary and normalize */
|
|
a = (dlimb_t)taba[1] * BF_DEC_BASE + taba[0];
|
|
k = clz(a >> LIMB_BITS) & ~1;
|
|
b = a << k;
|
|
taba1[0] = b;
|
|
taba1[1] = b >> LIMB_BITS;
|
|
mp_sqrtrem2(&s, taba1);
|
|
s >>= (k >> 1);
|
|
/* convert the remainder back to decimal */
|
|
r = a - (dlimb_t)s * (dlimb_t)s;
|
|
divdq_base(r1, r0, r >> LIMB_BITS, r);
|
|
taba[0] = r0;
|
|
tabs[0] = s;
|
|
return r1;
|
|
}
|
|
|
|
//#define DEBUG_SQRTREM_DEC
|
|
|
|
/* tmp_buf must contain (n / 2 + 1 limbs) */
|
|
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 - l;
|
|
qh = mp_sqrtrem_rec_dec(tabs + l, taba + 2 * l, h, tmp_buf);
|
|
#ifdef DEBUG_SQRTREM_DEC
|
|
mp_print_str_dec("s1", tabs + l, h);
|
|
mp_print_str_h_dec("r1", taba + 2 * l, h, qh);
|
|
mp_print_str_h_dec("r2", taba + l, n, qh);
|
|
#endif
|
|
|
|
/* the remainder is in taba + 2 * l. Its high bit is in qh */
|
|
if (qh) {
|
|
mp_sub_dec(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
|
|
}
|
|
/* instead of dividing by 2*s, divide by s (which is normalized)
|
|
and update q and r */
|
|
mp_div_dec(NULL, tmp_buf, taba + l, n, tabs + l, h);
|
|
qh += tmp_buf[l];
|
|
for(i = 0; i < l; i++)
|
|
tabs[i] = tmp_buf[i];
|
|
ql = mp_div1_dec(tabs, tabs, l, 2, qh & 1);
|
|
qh = qh >> 1; /* 0 or 1 */
|
|
if (ql)
|
|
rh = mp_add_dec(taba + l, taba + l, tabs + l, h, 0);
|
|
else
|
|
rh = 0;
|
|
#ifdef DEBUG_SQRTREM_DEC
|
|
mp_print_str_h_dec("q", tabs, l, qh);
|
|
mp_print_str_h_dec("u", taba + l, h, rh);
|
|
#endif
|
|
|
|
mp_add_ui_dec(tabs + l, qh, h);
|
|
#ifdef DEBUG_SQRTREM_DEC
|
|
mp_print_str_dec("s2", tabs, n);
|
|
#endif
|
|
|
|
/* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
|
|
/* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
|
|
if (qh) {
|
|
c = qh;
|
|
} else {
|
|
mp_mul_basecase_dec(taba + n, tabs, l, tabs, l);
|
|
c = mp_sub_dec(taba, taba, taba + n, 2 * l, 0);
|
|
}
|
|
rh -= mp_sub_ui_dec(taba + 2 * l, c, n - 2 * l);
|
|
if ((slimb_t)rh < 0) {
|
|
mp_sub_ui_dec(tabs, 1, n);
|
|
rh += mp_add_mul1_dec(taba, tabs, n, 2);
|
|
rh += mp_add_ui_dec(taba, 1, n);
|
|
}
|
|
return rh;
|
|
}
|
|
|
|
/* '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. */
|
|
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)
|
|
return -1;
|
|
}
|
|
taba[n] = mp_sqrtrem_rec_dec(tabs, taba, n, tmp_buf);
|
|
if (tmp_buf != tmp_buf1)
|
|
bf_free(s, tmp_buf);
|
|
return 0;
|
|
}
|
|
|
|
/* return the number of leading zero digits, from 0 to LIMB_DIGITS */
|
|
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 LIMB_DIGITS - 1;
|
|
else
|
|
return LIMB_DIGITS - 2;
|
|
case 4: /* 16-31 */
|
|
return LIMB_DIGITS - 2;
|
|
case 5: /* 32-63 */
|
|
return LIMB_DIGITS - 2;
|
|
case 6: /* 64-127 */
|
|
if (a < 100)
|
|
return LIMB_DIGITS - 2;
|
|
else
|
|
return LIMB_DIGITS - 3;
|
|
case 7: /* 128-255 */
|
|
return LIMB_DIGITS - 3;
|
|
case 8: /* 256-511 */
|
|
return LIMB_DIGITS - 3;
|
|
case 9: /* 512-1023 */
|
|
if (a < 1000)
|
|
return LIMB_DIGITS - 3;
|
|
else
|
|
return LIMB_DIGITS - 4;
|
|
case 10: /* 1024-2047 */
|
|
return LIMB_DIGITS - 4;
|
|
case 11: /* 2048-4095 */
|
|
return LIMB_DIGITS - 4;
|
|
case 12: /* 4096-8191 */
|
|
return LIMB_DIGITS - 4;
|
|
case 13: /* 8192-16383 */
|
|
if (a < 10000)
|
|
return LIMB_DIGITS - 4;
|
|
else
|
|
return LIMB_DIGITS - 5;
|
|
case 14: /* 16384-32767 */
|
|
return LIMB_DIGITS - 5;
|
|
case 15: /* 32768-65535 */
|
|
return LIMB_DIGITS - 5;
|
|
case 16: /* 65536-131071 */
|
|
if (a < 100000)
|
|
return LIMB_DIGITS - 5;
|
|
else
|
|
return LIMB_DIGITS - 6;
|
|
case 17: /* 131072-262143 */
|
|
return LIMB_DIGITS - 6;
|
|
case 18: /* 262144-524287 */
|
|
return LIMB_DIGITS - 6;
|
|
case 19: /* 524288-1048575 */
|
|
if (a < 1000000)
|
|
return LIMB_DIGITS - 6;
|
|
else
|
|
return LIMB_DIGITS - 7;
|
|
case 20: /* 1048576-2097151 */
|
|
return LIMB_DIGITS - 7;
|
|
case 21: /* 2097152-4194303 */
|
|
return LIMB_DIGITS - 7;
|
|
case 22: /* 4194304-8388607 */
|
|
return LIMB_DIGITS - 7;
|
|
case 23: /* 8388608-16777215 */
|
|
if (a < 10000000)
|
|
return LIMB_DIGITS - 7;
|
|
else
|
|
return LIMB_DIGITS - 8;
|
|
case 24: /* 16777216-33554431 */
|
|
return LIMB_DIGITS - 8;
|
|
case 25: /* 33554432-67108863 */
|
|
return LIMB_DIGITS - 8;
|
|
case 26: /* 67108864-134217727 */
|
|
if (a < 100000000)
|
|
return LIMB_DIGITS - 8;
|
|
else
|
|
return LIMB_DIGITS - 9;
|
|
#if LIMB_BITS == 64
|
|
case 27: /* 134217728-268435455 */
|
|
return LIMB_DIGITS - 9;
|
|
case 28: /* 268435456-536870911 */
|
|
return LIMB_DIGITS - 9;
|
|
case 29: /* 536870912-1073741823 */
|
|
if (a < 1000000000)
|
|
return LIMB_DIGITS - 9;
|
|
else
|
|
return LIMB_DIGITS - 10;
|
|
case 30: /* 1073741824-2147483647 */
|
|
return LIMB_DIGITS - 10;
|
|
case 31: /* 2147483648-4294967295 */
|
|
return LIMB_DIGITS - 10;
|
|
case 32: /* 4294967296-8589934591 */
|
|
return LIMB_DIGITS - 10;
|
|
case 33: /* 8589934592-17179869183 */
|
|
if (a < 10000000000)
|
|
return LIMB_DIGITS - 10;
|
|
else
|
|
return LIMB_DIGITS - 11;
|
|
case 34: /* 17179869184-34359738367 */
|
|
return LIMB_DIGITS - 11;
|
|
case 35: /* 34359738368-68719476735 */
|
|
return LIMB_DIGITS - 11;
|
|
case 36: /* 68719476736-137438953471 */
|
|
if (a < 100000000000)
|
|
return LIMB_DIGITS - 11;
|
|
else
|
|
return LIMB_DIGITS - 12;
|
|
case 37: /* 137438953472-274877906943 */
|
|
return LIMB_DIGITS - 12;
|
|
case 38: /* 274877906944-549755813887 */
|
|
return LIMB_DIGITS - 12;
|
|
case 39: /* 549755813888-1099511627775 */
|
|
if (a < 1000000000000)
|
|
return LIMB_DIGITS - 12;
|
|
else
|
|
return LIMB_DIGITS - 13;
|
|
case 40: /* 1099511627776-2199023255551 */
|
|
return LIMB_DIGITS - 13;
|
|
case 41: /* 2199023255552-4398046511103 */
|
|
return LIMB_DIGITS - 13;
|
|
case 42: /* 4398046511104-8796093022207 */
|
|
return LIMB_DIGITS - 13;
|
|
case 43: /* 8796093022208-17592186044415 */
|
|
if (a < 10000000000000)
|
|
return LIMB_DIGITS - 13;
|
|
else
|
|
return LIMB_DIGITS - 14;
|
|
case 44: /* 17592186044416-35184372088831 */
|
|
return LIMB_DIGITS - 14;
|
|
case 45: /* 35184372088832-70368744177663 */
|
|
return LIMB_DIGITS - 14;
|
|
case 46: /* 70368744177664-140737488355327 */
|
|
if (a < 100000000000000)
|
|
return LIMB_DIGITS - 14;
|
|
else
|
|
return LIMB_DIGITS - 15;
|
|
case 47: /* 140737488355328-281474976710655 */
|
|
return LIMB_DIGITS - 15;
|
|
case 48: /* 281474976710656-562949953421311 */
|
|
return LIMB_DIGITS - 15;
|
|
case 49: /* 562949953421312-1125899906842623 */
|
|
if (a < 1000000000000000)
|
|
return LIMB_DIGITS - 15;
|
|
else
|
|
return LIMB_DIGITS - 16;
|
|
case 50: /* 1125899906842624-2251799813685247 */
|
|
return LIMB_DIGITS - 16;
|
|
case 51: /* 2251799813685248-4503599627370495 */
|
|
return LIMB_DIGITS - 16;
|
|
case 52: /* 4503599627370496-9007199254740991 */
|
|
return LIMB_DIGITS - 16;
|
|
case 53: /* 9007199254740992-18014398509481983 */
|
|
if (a < 10000000000000000)
|
|
return LIMB_DIGITS - 16;
|
|
else
|
|
return LIMB_DIGITS - 17;
|
|
case 54: /* 18014398509481984-36028797018963967 */
|
|
return LIMB_DIGITS - 17;
|
|
case 55: /* 36028797018963968-72057594037927935 */
|
|
return LIMB_DIGITS - 17;
|
|
case 56: /* 72057594037927936-144115188075855871 */
|
|
if (a < 100000000000000000)
|
|
return LIMB_DIGITS - 17;
|
|
else
|
|
return LIMB_DIGITS - 18;
|
|
case 57: /* 144115188075855872-288230376151711743 */
|
|
return LIMB_DIGITS - 18;
|
|
case 58: /* 288230376151711744-576460752303423487 */
|
|
return LIMB_DIGITS - 18;
|
|
case 59: /* 576460752303423488-1152921504606846975 */
|
|
if (a < 1000000000000000000)
|
|
return LIMB_DIGITS - 18;
|
|
else
|
|
return LIMB_DIGITS - 19;
|
|
#endif
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* for debugging */
|
|
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) {
|
|
printf("Inf");
|
|
} else {
|
|
printf("0.");
|
|
for(i = a->len - 1; i >= 0; i--)
|
|
printf("%0*" PRIu_LIMB, LIMB_DIGITS, a->tab[i]);
|
|
printf("e%" PRId_LIMB, a->expn);
|
|
}
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
/* return != 0 if one digit between 0 and bit_pos inclusive is not zero. */
|
|
static inline limb_t scan_digit_nz(const bfdec_t *r, slimb_t bit_pos)
|
|
{
|
|
slimb_t pos;
|
|
limb_t v, q;
|
|
int shift;
|
|
|
|
if (bit_pos < 0)
|
|
return 0;
|
|
pos = (limb_t)bit_pos / LIMB_DIGITS;
|
|
shift = (limb_t)bit_pos % LIMB_DIGITS;
|
|
fast_shr_rem_dec(q, v, r->tab[pos], shift + 1);
|
|
(void)q;
|
|
if (v != 0)
|
|
return 1;
|
|
pos--;
|
|
while (pos >= 0) {
|
|
if (r->tab[pos] != 0)
|
|
return 1;
|
|
pos--;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static limb_t get_digit(const limb_t *tab, limb_t len, slimb_t pos)
|
|
{
|
|
slimb_t i;
|
|
int shift;
|
|
i = floor_div(pos, LIMB_DIGITS);
|
|
if (i < 0 || i >= len)
|
|
return 0;
|
|
shift = pos - i * LIMB_DIGITS;
|
|
return fast_shr_dec(tab[i], shift) % 10;
|
|
}
|
|
|
|
/* return the addend for rounding. Note that prec can be <= 0 for bf_rint() */
|
|
static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
|
|
slimb_t prec, int rnd_mode)
|
|
{
|
|
int add_one, inexact;
|
|
limb_t digit1, digit0;
|
|
|
|
// bfdec_print_str("get_rnd_add", r);
|
|
if (rnd_mode == BF_RNDF) {
|
|
digit0 = 1; /* faithful rounding does not honor the INEXACT flag */
|
|
} else {
|
|
/* starting limb for bit 'prec + 1' */
|
|
digit0 = scan_digit_nz(r, l * LIMB_DIGITS - 1 - bf_max(0, prec + 1));
|
|
}
|
|
|
|
/* get the digit at 'prec' */
|
|
digit1 = get_digit(r->tab, l, l * LIMB_DIGITS - 1 - prec);
|
|
inexact = (digit1 | digit0) != 0;
|
|
|
|
add_one = 0;
|
|
switch(rnd_mode) {
|
|
case BF_RNDZ:
|
|
break;
|
|
case BF_RNDN:
|
|
if (digit1 == 5) {
|
|
if (digit0) {
|
|
add_one = 1;
|
|
} else {
|
|
/* round to even */
|
|
add_one =
|
|
get_digit(r->tab, l, l * LIMB_DIGITS - 1 - (prec - 1)) & 1;
|
|
}
|
|
} else if (digit1 > 5) {
|
|
add_one = 1;
|
|
}
|
|
break;
|
|
case BF_RNDD:
|
|
case BF_RNDU:
|
|
if (r->sign == (rnd_mode == BF_RNDD))
|
|
add_one = inexact;
|
|
break;
|
|
case BF_RNDNA:
|
|
case BF_RNDF:
|
|
add_one = (digit1 >= 5);
|
|
break;
|
|
case BF_RNDA:
|
|
add_one = inexact;
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
|
|
if (inexact)
|
|
*pret |= BF_ST_INEXACT;
|
|
return add_one;
|
|
}
|
|
|
|
/* round to prec1 bits assuming 'r' is non zero and finite. 'r' is
|
|
assumed to have length 'l' (1 <= l <= r->len). prec1 can be
|
|
BF_PREC_INF. BF_FLAG_SUBNORMAL is not supported. Cannot fail with
|
|
BF_ST_MEM_ERROR.
|
|
*/
|
|
static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
|
|
{
|
|
int shift, add_one, rnd_mode, ret;
|
|
slimb_t i, bit_pos, pos, e_min, e_max, e_range, prec;
|
|
|
|
/* XXX: align to IEEE 754 2008 for decimal numbers ? */
|
|
e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
|
|
e_min = -e_range + 3;
|
|
e_max = e_range;
|
|
|
|
if (flags & BF_FLAG_RADPNT_PREC) {
|
|
/* 'prec' is the precision after the decimal point */
|
|
if (prec1 != BF_PREC_INF)
|
|
prec = r->expn + prec1;
|
|
else
|
|
prec = prec1;
|
|
} else if (unlikely(r->expn < e_min) && (flags & BF_FLAG_SUBNORMAL)) {
|
|
/* restrict the precision in case of potentially subnormal
|
|
result */
|
|
assert(prec1 != BF_PREC_INF);
|
|
prec = prec1 - (e_min - r->expn);
|
|
} else {
|
|
prec = prec1;
|
|
}
|
|
|
|
/* round to prec bits */
|
|
rnd_mode = flags & BF_RND_MASK;
|
|
ret = 0;
|
|
add_one = bfdec_get_rnd_add(&ret, r, l, prec, rnd_mode);
|
|
|
|
if (prec <= 0) {
|
|
if (add_one) {
|
|
bfdec_resize(r, 1); /* cannot fail because r is non zero */
|
|
r->tab[0] = BF_DEC_BASE / 10;
|
|
r->expn += 1 - prec;
|
|
ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
|
|
return ret;
|
|
} else {
|
|
goto underflow;
|
|
}
|
|
} else if (add_one) {
|
|
limb_t carry;
|
|
|
|
/* add one starting at digit 'prec - 1' */
|
|
bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
|
|
pos = bit_pos / LIMB_DIGITS;
|
|
carry = mp_pow_dec[bit_pos % LIMB_DIGITS];
|
|
carry = mp_add_ui_dec(r->tab + pos, carry, l - pos);
|
|
if (carry) {
|
|
/* shift right by one digit */
|
|
mp_shr_dec(r->tab + pos, r->tab + pos, l - pos, 1, 1);
|
|
r->expn++;
|
|
}
|
|
}
|
|
|
|
/* check underflow */
|
|
if (unlikely(r->expn < e_min)) {
|
|
if (flags & BF_FLAG_SUBNORMAL) {
|
|
/* if inexact, also set the underflow flag */
|
|
if (ret & BF_ST_INEXACT)
|
|
ret |= BF_ST_UNDERFLOW;
|
|
} else {
|
|
underflow:
|
|
bfdec_set_zero(r, r->sign);
|
|
ret |= BF_ST_UNDERFLOW | BF_ST_INEXACT;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* check overflow */
|
|
if (unlikely(r->expn > e_max)) {
|
|
bfdec_set_inf(r, r->sign);
|
|
ret |= BF_ST_OVERFLOW | BF_ST_INEXACT;
|
|
return ret;
|
|
}
|
|
|
|
/* keep the bits starting at 'prec - 1' */
|
|
bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
|
|
i = floor_div(bit_pos, LIMB_DIGITS);
|
|
if (i >= 0) {
|
|
shift = smod(bit_pos, LIMB_DIGITS);
|
|
if (shift != 0) {
|
|
r->tab[i] = fast_shr_dec(r->tab[i], shift) *
|
|
mp_pow_dec[shift];
|
|
}
|
|
} else {
|
|
i = 0;
|
|
}
|
|
/* remove trailing zeros */
|
|
while (r->tab[i] == 0)
|
|
i++;
|
|
if (i > 0) {
|
|
l -= i;
|
|
memmove(r->tab, r->tab + i, l * sizeof(limb_t));
|
|
}
|
|
bfdec_resize(r, l); /* cannot fail */
|
|
return ret;
|
|
}
|
|
|
|
/* Cannot fail with BF_ST_MEM_ERROR. */
|
|
int bfdec_round(bfdec_t *r, limb_t prec, bf_flags_t flags)
|
|
{
|
|
if (r->len == 0)
|
|
return 0;
|
|
return __bfdec_round(r, prec, flags, r->len);
|
|
}
|
|
|
|
/* 'r' must be a finite number. Cannot fail with BF_ST_MEM_ERROR. */
|
|
int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags)
|
|
{
|
|
limb_t l, v;
|
|
int shift, ret;
|
|
|
|
// bfdec_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;
|
|
bfdec_resize(r, 0); /* cannot fail */
|
|
ret = 0;
|
|
} else {
|
|
r->expn -= (r->len - l) * LIMB_DIGITS;
|
|
/* shift to have the MSB set to '1' */
|
|
v = r->tab[l - 1];
|
|
shift = clz_dec(v);
|
|
if (shift != 0) {
|
|
mp_shl_dec(r->tab, r->tab, l, shift, 0);
|
|
r->expn -= shift;
|
|
}
|
|
ret = __bfdec_round(r, prec1, flags, l);
|
|
}
|
|
// bf_print_str("r_final", r);
|
|
return ret;
|
|
}
|
|
|
|
int bfdec_set_ui(bfdec_t *r, uint64_t v)
|
|
{
|
|
#if LIMB_BITS == 32
|
|
if (v >= BF_DEC_BASE * BF_DEC_BASE) {
|
|
if (bfdec_resize(r, 3))
|
|
goto fail;
|
|
r->tab[0] = v % BF_DEC_BASE;
|
|
v /= BF_DEC_BASE;
|
|
r->tab[1] = v % BF_DEC_BASE;
|
|
r->tab[2] = v / BF_DEC_BASE;
|
|
r->expn = 3 * LIMB_DIGITS;
|
|
} else
|
|
#endif
|
|
if (v >= BF_DEC_BASE) {
|
|
if (bfdec_resize(r, 2))
|
|
goto fail;
|
|
r->tab[0] = v % BF_DEC_BASE;
|
|
r->tab[1] = v / BF_DEC_BASE;
|
|
r->expn = 2 * LIMB_DIGITS;
|
|
} else {
|
|
if (bfdec_resize(r, 1))
|
|
goto fail;
|
|
r->tab[0] = v;
|
|
r->expn = LIMB_DIGITS;
|
|
}
|
|
r->sign = 0;
|
|
return bfdec_normalize_and_round(r, BF_PREC_INF, 0);
|
|
fail:
|
|
bfdec_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
int bfdec_set_si(bfdec_t *r, int64_t v)
|
|
{
|
|
int ret;
|
|
if (v < 0) {
|
|
ret = bfdec_set_ui(r, -v);
|
|
r->sign = 1;
|
|
} else {
|
|
ret = bfdec_set_ui(r, v);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int bfdec_add_internal(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec, bf_flags_t flags, int b_neg)
|
|
{
|
|
bf_context_t *s = r->ctx;
|
|
int is_sub, cmp_res, a_sign, b_sign, ret;
|
|
|
|
a_sign = a->sign;
|
|
b_sign = b->sign ^ b_neg;
|
|
is_sub = a_sign ^ b_sign;
|
|
cmp_res = bfdec_cmpu(a, b);
|
|
if (cmp_res < 0) {
|
|
const bfdec_t *tmp;
|
|
tmp = a;
|
|
a = b;
|
|
b = tmp;
|
|
a_sign = b_sign; /* b_sign is never used later */
|
|
}
|
|
/* abs(a) >= abs(b) */
|
|
if (cmp_res == 0 && is_sub && a->expn < BF_EXP_INF) {
|
|
/* zero result */
|
|
bfdec_set_zero(r, (flags & BF_RND_MASK) == BF_RNDD);
|
|
ret = 0;
|
|
} else if (a->len == 0 || b->len == 0) {
|
|
ret = 0;
|
|
if (a->expn >= BF_EXP_INF) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
/* at least one operand is NaN */
|
|
bfdec_set_nan(r);
|
|
ret = 0;
|
|
} else if (b->expn == BF_EXP_INF && is_sub) {
|
|
/* infinities with different signs */
|
|
bfdec_set_nan(r);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
bfdec_set_inf(r, a_sign);
|
|
}
|
|
} else {
|
|
/* at least one zero and not subtract */
|
|
if (bfdec_set(r, a))
|
|
return BF_ST_MEM_ERROR;
|
|
r->sign = a_sign;
|
|
goto renorm;
|
|
}
|
|
} else {
|
|
slimb_t d, a_offset, b_offset, i, r_len;
|
|
limb_t carry;
|
|
limb_t *b1_tab;
|
|
int b_shift;
|
|
mp_size_t b1_len;
|
|
|
|
d = a->expn - b->expn;
|
|
|
|
/* XXX: not efficient in time and memory if the precision is
|
|
not infinite */
|
|
r_len = bf_max(a->len, b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
|
|
if (bfdec_resize(r, r_len))
|
|
goto fail;
|
|
r->sign = a_sign;
|
|
r->expn = a->expn;
|
|
|
|
a_offset = r_len - a->len;
|
|
for(i = 0; i < a_offset; i++)
|
|
r->tab[i] = 0;
|
|
for(i = 0; i < a->len; i++)
|
|
r->tab[a_offset + i] = a->tab[i];
|
|
|
|
b_shift = d % LIMB_DIGITS;
|
|
if (b_shift == 0) {
|
|
b1_len = b->len;
|
|
b1_tab = (limb_t *)b->tab;
|
|
} else {
|
|
b1_len = b->len + 1;
|
|
b1_tab = bf_malloc(s, sizeof(limb_t) * b1_len);
|
|
if (!b1_tab)
|
|
goto fail;
|
|
b1_tab[0] = mp_shr_dec(b1_tab + 1, b->tab, b->len, b_shift, 0) *
|
|
mp_pow_dec[LIMB_DIGITS - b_shift];
|
|
}
|
|
b_offset = r_len - (b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
|
|
|
|
if (is_sub) {
|
|
carry = mp_sub_dec(r->tab + b_offset, r->tab + b_offset,
|
|
b1_tab, b1_len, 0);
|
|
if (carry != 0) {
|
|
carry = mp_sub_ui_dec(r->tab + b_offset + b1_len, carry,
|
|
r_len - (b_offset + b1_len));
|
|
assert(carry == 0);
|
|
}
|
|
} else {
|
|
carry = mp_add_dec(r->tab + b_offset, r->tab + b_offset,
|
|
b1_tab, b1_len, 0);
|
|
if (carry != 0) {
|
|
carry = mp_add_ui_dec(r->tab + b_offset + b1_len, carry,
|
|
r_len - (b_offset + b1_len));
|
|
}
|
|
if (carry != 0) {
|
|
if (bfdec_resize(r, r_len + 1)) {
|
|
if (b_shift != 0)
|
|
bf_free(s, b1_tab);
|
|
goto fail;
|
|
}
|
|
r->tab[r_len] = 1;
|
|
r->expn += LIMB_DIGITS;
|
|
}
|
|
}
|
|
if (b_shift != 0)
|
|
bf_free(s, b1_tab);
|
|
renorm:
|
|
ret = bfdec_normalize_and_round(r, prec, flags);
|
|
}
|
|
return ret;
|
|
fail:
|
|
bfdec_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
static int __bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bfdec_add_internal(r, a, b, prec, flags, 0);
|
|
}
|
|
|
|
static int __bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bfdec_add_internal(r, a, b, prec, flags, 1);
|
|
}
|
|
|
|
int bfdec_add(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
|
|
(bf_op2_func_t *)__bfdec_add);
|
|
}
|
|
|
|
int bfdec_sub(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
|
|
(bf_op2_func_t *)__bfdec_sub);
|
|
}
|
|
|
|
int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
int ret, r_sign;
|
|
|
|
if (a->len < b->len) {
|
|
const bfdec_t *tmp = a;
|
|
a = b;
|
|
b = tmp;
|
|
}
|
|
r_sign = a->sign ^ b->sign;
|
|
/* here b->len <= a->len */
|
|
if (b->len == 0) {
|
|
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
|
|
bfdec_set_nan(r);
|
|
ret = 0;
|
|
} else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_INF) {
|
|
if ((a->expn == BF_EXP_INF && b->expn == BF_EXP_ZERO) ||
|
|
(a->expn == BF_EXP_ZERO && b->expn == BF_EXP_INF)) {
|
|
bfdec_set_nan(r);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
bfdec_set_inf(r, r_sign);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
bfdec_set_zero(r, r_sign);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
bfdec_t tmp, *r1 = NULL;
|
|
limb_t a_len, b_len;
|
|
limb_t *a_tab, *b_tab;
|
|
|
|
a_len = a->len;
|
|
b_len = b->len;
|
|
a_tab = a->tab;
|
|
b_tab = b->tab;
|
|
|
|
if (r == a || r == b) {
|
|
bfdec_init(r->ctx, &tmp);
|
|
r1 = r;
|
|
r = &tmp;
|
|
}
|
|
if (bfdec_resize(r, a_len + b_len)) {
|
|
bfdec_set_nan(r);
|
|
ret = BF_ST_MEM_ERROR;
|
|
goto done;
|
|
}
|
|
mp_mul_basecase_dec(r->tab, a_tab, a_len, b_tab, b_len);
|
|
r->sign = r_sign;
|
|
r->expn = a->expn + b->expn;
|
|
ret = bfdec_normalize_and_round(r, prec, flags);
|
|
done:
|
|
if (r == &tmp)
|
|
bfdec_move(r1, &tmp);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int bfdec_mul_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
bfdec_t b;
|
|
int ret;
|
|
bfdec_init(r->ctx, &b);
|
|
ret = bfdec_set_si(&b, b1);
|
|
ret |= bfdec_mul(r, a, &b, prec, flags);
|
|
bfdec_delete(&b);
|
|
return ret;
|
|
}
|
|
|
|
int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
bfdec_t b;
|
|
int ret;
|
|
|
|
bfdec_init(r->ctx, &b);
|
|
ret = bfdec_set_si(&b, b1);
|
|
ret |= bfdec_add(r, a, &b, prec, flags);
|
|
bfdec_delete(&b);
|
|
return ret;
|
|
}
|
|
|
|
static int __bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
|
|
limb_t prec, bf_flags_t flags)
|
|
{
|
|
int ret, r_sign;
|
|
limb_t n, nb, precl;
|
|
|
|
r_sign = a->sign ^ b->sign;
|
|
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
|
|
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
|
|
bfdec_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
|
|
bfdec_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else if (a->expn == BF_EXP_INF) {
|
|
bfdec_set_inf(r, r_sign);
|
|
return 0;
|
|
} else {
|
|
bfdec_set_zero(r, r_sign);
|
|
return 0;
|
|
}
|
|
} else if (a->expn == BF_EXP_ZERO) {
|
|
if (b->expn == BF_EXP_ZERO) {
|
|
bfdec_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bfdec_set_zero(r, r_sign);
|
|
return 0;
|
|
}
|
|
} else if (b->expn == BF_EXP_ZERO) {
|
|
bfdec_set_inf(r, r_sign);
|
|
return BF_ST_DIVIDE_ZERO;
|
|
}
|
|
|
|
nb = b->len;
|
|
if (prec == BF_PREC_INF) {
|
|
/* infinite precision: return BF_ST_INVALID_OP if not an exact
|
|
result */
|
|
/* XXX: check */
|
|
precl = nb + 1;
|
|
} else if (flags & BF_FLAG_RADPNT_PREC) {
|
|
/* number of digits after the decimal point */
|
|
/* XXX: check (2 extra digits for rounding + 2 digits) */
|
|
precl = (bf_max(a->expn - b->expn, 0) + 2 +
|
|
prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
|
|
} else {
|
|
/* number of limbs of the quotient (2 extra digits for rounding) */
|
|
precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
|
|
}
|
|
n = bf_max(a->len, precl);
|
|
|
|
{
|
|
limb_t *taba, na, i;
|
|
slimb_t d;
|
|
|
|
na = n + nb;
|
|
taba = bf_malloc(r->ctx, (na + 1) * sizeof(limb_t));
|
|
if (!taba)
|
|
goto fail;
|
|
d = na - a->len;
|
|
memset(taba, 0, d * sizeof(limb_t));
|
|
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
|
|
if (bfdec_resize(r, n + 1))
|
|
goto fail1;
|
|
if (mp_div_dec(r->ctx, r->tab, taba, na, b->tab, nb)) {
|
|
fail1:
|
|
bf_free(r->ctx, taba);
|
|
goto fail;
|
|
}
|
|
/* see if non zero remainder */
|
|
for(i = 0; i < nb; i++) {
|
|
if (taba[i] != 0)
|
|
break;
|
|
}
|
|
bf_free(r->ctx, taba);
|
|
if (i != nb) {
|
|
if (prec == BF_PREC_INF) {
|
|
bfdec_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
r->tab[0] |= 1;
|
|
}
|
|
}
|
|
r->expn = a->expn - b->expn + LIMB_DIGITS;
|
|
r->sign = r_sign;
|
|
ret = bfdec_normalize_and_round(r, prec, flags);
|
|
}
|
|
return ret;
|
|
fail:
|
|
bfdec_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
int bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags)
|
|
{
|
|
return bf_op2((bf_t *)r, (bf_t *)a, (bf_t *)b, prec, flags,
|
|
(bf_op2_func_t *)__bfdec_div);
|
|
}
|
|
|
|
/* 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. */
|
|
static void bfdec_tdivremu(bf_context_t *s, bfdec_t *q, bfdec_t *r,
|
|
const bfdec_t *a, const bfdec_t *b)
|
|
{
|
|
if (bfdec_cmpu(a, b) < 0) {
|
|
bfdec_set_ui(q, 0);
|
|
bfdec_set(r, a);
|
|
} else {
|
|
bfdec_div(q, a, b, 0, BF_RNDZ | BF_FLAG_RADPNT_PREC);
|
|
bfdec_mul(r, q, b, BF_PREC_INF, BF_RNDZ);
|
|
bfdec_sub(r, a, r, BF_PREC_INF, BF_RNDZ);
|
|
}
|
|
}
|
|
|
|
/* 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).
|
|
*/
|
|
int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
|
|
limb_t prec, bf_flags_t flags, int rnd_mode)
|
|
{
|
|
bf_context_t *s = q->ctx;
|
|
bfdec_t a1_s, *a1 = &a1_s;
|
|
bfdec_t b1_s, *b1 = &b1_s;
|
|
bfdec_t r1_s, *r1 = &r1_s;
|
|
int q_sign, res;
|
|
BOOL is_ceil, is_rndn;
|
|
|
|
assert(q != a && q != b);
|
|
assert(r != a && r != b);
|
|
assert(q != r);
|
|
|
|
if (a->len == 0 || b->len == 0) {
|
|
bfdec_set_zero(q, 0);
|
|
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
|
|
bfdec_set_nan(r);
|
|
return 0;
|
|
} else if (a->expn == BF_EXP_INF || b->expn == BF_EXP_ZERO) {
|
|
bfdec_set_nan(r);
|
|
return BF_ST_INVALID_OP;
|
|
} else {
|
|
bfdec_set(r, a);
|
|
return bfdec_round(r, prec, flags);
|
|
}
|
|
}
|
|
|
|
q_sign = a->sign ^ b->sign;
|
|
is_rndn = (rnd_mode == BF_RNDN || rnd_mode == BF_RNDNA);
|
|
switch(rnd_mode) {
|
|
default:
|
|
case BF_RNDZ:
|
|
case BF_RNDN:
|
|
case BF_RNDNA:
|
|
is_ceil = FALSE;
|
|
break;
|
|
case BF_RNDD:
|
|
is_ceil = q_sign;
|
|
break;
|
|
case BF_RNDU:
|
|
is_ceil = q_sign ^ 1;
|
|
break;
|
|
case BF_RNDA:
|
|
is_ceil = TRUE;
|
|
break;
|
|
case BF_DIVREM_EUCLIDIAN:
|
|
is_ceil = a->sign;
|
|
break;
|
|
}
|
|
|
|
a1->expn = a->expn;
|
|
a1->tab = a->tab;
|
|
a1->len = a->len;
|
|
a1->sign = 0;
|
|
|
|
b1->expn = b->expn;
|
|
b1->tab = b->tab;
|
|
b1->len = b->len;
|
|
b1->sign = 0;
|
|
|
|
// bfdec_print_str("a1", a1);
|
|
// bfdec_print_str("b1", b1);
|
|
/* XXX: could improve to avoid having a large 'q' */
|
|
bfdec_tdivremu(s, q, r, a1, b1);
|
|
if (bfdec_is_nan(q) || bfdec_is_nan(r))
|
|
goto fail;
|
|
// bfdec_print_str("q", q);
|
|
// bfdec_print_str("r", r);
|
|
|
|
if (r->len != 0) {
|
|
if (is_rndn) {
|
|
bfdec_init(s, r1);
|
|
if (bfdec_set(r1, r))
|
|
goto fail;
|
|
if (bfdec_mul_si(r1, r1, 2, BF_PREC_INF, BF_RNDZ)) {
|
|
bfdec_delete(r1);
|
|
goto fail;
|
|
}
|
|
res = bfdec_cmpu(r1, b);
|
|
bfdec_delete(r1);
|
|
if (res > 0 ||
|
|
(res == 0 &&
|
|
(rnd_mode == BF_RNDNA ||
|
|
(get_digit(q->tab, q->len, q->len * LIMB_DIGITS - q->expn) & 1) != 0))) {
|
|
goto do_sub_r;
|
|
}
|
|
} else if (is_ceil) {
|
|
do_sub_r:
|
|
res = bfdec_add_si(q, q, 1, BF_PREC_INF, BF_RNDZ);
|
|
res |= bfdec_sub(r, r, b1, BF_PREC_INF, BF_RNDZ);
|
|
if (res & BF_ST_MEM_ERROR)
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
r->sign ^= a->sign;
|
|
q->sign = q_sign;
|
|
return bfdec_round(r, prec, flags);
|
|
fail:
|
|
bfdec_set_nan(q);
|
|
bfdec_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
|
|
bf_flags_t flags, int rnd_mode)
|
|
{
|
|
bfdec_t q_s, *q = &q_s;
|
|
int ret;
|
|
|
|
bfdec_init(r->ctx, q);
|
|
ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
|
|
bfdec_delete(q);
|
|
return ret;
|
|
}
|
|
|
|
/* convert to integer (infinite precision) */
|
|
int bfdec_rint(bfdec_t *r, int rnd_mode)
|
|
{
|
|
return bfdec_round(r, 0, rnd_mode | BF_FLAG_RADPNT_PREC);
|
|
}
|
|
|
|
int bfdec_sqrt(bfdec_t *r, const bfdec_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
bf_context_t *s = a->ctx;
|
|
int ret, k;
|
|
limb_t *a1, v;
|
|
slimb_t n, n1, prec1;
|
|
limb_t res;
|
|
|
|
assert(r != a);
|
|
|
|
if (a->len == 0) {
|
|
if (a->expn == BF_EXP_NAN) {
|
|
bfdec_set_nan(r);
|
|
} else if (a->expn == BF_EXP_INF && a->sign) {
|
|
goto invalid_op;
|
|
} else {
|
|
bfdec_set(r, a);
|
|
}
|
|
ret = 0;
|
|
} else if (a->sign || prec == BF_PREC_INF) {
|
|
invalid_op:
|
|
bfdec_set_nan(r);
|
|
ret = BF_ST_INVALID_OP;
|
|
} else {
|
|
if (flags & BF_FLAG_RADPNT_PREC) {
|
|
prec1 = bf_max(floor_div(a->expn + 1, 2) + prec, 1);
|
|
} else {
|
|
prec1 = prec;
|
|
}
|
|
/* convert the mantissa to an integer with at least 2 *
|
|
prec + 4 digits */
|
|
n = (2 * (prec1 + 2) + 2 * LIMB_DIGITS - 1) / (2 * LIMB_DIGITS);
|
|
if (bfdec_resize(r, n))
|
|
goto fail;
|
|
a1 = bf_malloc(s, sizeof(limb_t) * 2 * n);
|
|
if (!a1)
|
|
goto fail;
|
|
n1 = bf_min(2 * n, a->len);
|
|
memset(a1, 0, (2 * n - n1) * sizeof(limb_t));
|
|
memcpy(a1 + 2 * n - n1, a->tab + a->len - n1, n1 * sizeof(limb_t));
|
|
if (a->expn & 1) {
|
|
res = mp_shr_dec(a1, a1, 2 * n, 1, 0);
|
|
} else {
|
|
res = 0;
|
|
}
|
|
/* normalize so that a1 >= B^(2*n)/4. Not need for n = 1
|
|
because mp_sqrtrem2_dec already does it */
|
|
k = 0;
|
|
if (n > 1) {
|
|
v = a1[2 * n - 1];
|
|
while (v < BF_DEC_BASE / 4) {
|
|
k++;
|
|
v *= 4;
|
|
}
|
|
if (k != 0)
|
|
mp_mul1_dec(a1, a1, 2 * n, 1 << (2 * k), 0);
|
|
}
|
|
if (mp_sqrtrem_dec(s, r->tab, a1, n)) {
|
|
bf_free(s, a1);
|
|
goto fail;
|
|
}
|
|
if (k != 0)
|
|
mp_div1_dec(r->tab, r->tab, n, 1 << k, 0);
|
|
if (!res) {
|
|
res = mp_scan_nz(a1, n + 1);
|
|
}
|
|
bf_free(s, a1);
|
|
if (!res) {
|
|
res = mp_scan_nz(a->tab, a->len - n1);
|
|
}
|
|
if (res != 0)
|
|
r->tab[0] |= 1;
|
|
r->sign = 0;
|
|
r->expn = (a->expn + 1) >> 1;
|
|
ret = bfdec_round(r, prec, flags);
|
|
}
|
|
return ret;
|
|
fail:
|
|
bfdec_set_nan(r);
|
|
return BF_ST_MEM_ERROR;
|
|
}
|
|
|
|
/* The rounding mode is always BF_RNDZ. Return BF_ST_OVERFLOW if there
|
|
is an overflow and 0 otherwise. No memory error is possible. */
|
|
int bfdec_get_int32(int *pres, const bfdec_t *a)
|
|
{
|
|
uint32_t v;
|
|
int ret;
|
|
if (a->expn >= BF_EXP_INF) {
|
|
ret = 0;
|
|
if (a->expn == BF_EXP_INF) {
|
|
v = (uint32_t)INT32_MAX + a->sign;
|
|
/* XXX: return overflow ? */
|
|
} else {
|
|
v = INT32_MAX;
|
|
}
|
|
} else if (a->expn <= 0) {
|
|
v = 0;
|
|
ret = 0;
|
|
} else if (a->expn <= 9) {
|
|
v = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
|
|
if (a->sign)
|
|
v = -v;
|
|
ret = 0;
|
|
} else if (a->expn == 10) {
|
|
uint64_t v1;
|
|
uint32_t v_max;
|
|
#if LIMB_BITS == 64
|
|
v1 = fast_shr_dec(a->tab[a->len - 1], LIMB_DIGITS - a->expn);
|
|
#else
|
|
v1 = (uint64_t)a->tab[a->len - 1] * 10 +
|
|
get_digit(a->tab, a->len, (a->len - 1) * LIMB_DIGITS - 1);
|
|
#endif
|
|
v_max = (uint32_t)INT32_MAX + a->sign;
|
|
if (v1 > v_max) {
|
|
v = v_max;
|
|
ret = BF_ST_OVERFLOW;
|
|
} else {
|
|
v = v1;
|
|
if (a->sign)
|
|
v = -v;
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
v = (uint32_t)INT32_MAX + a->sign;
|
|
ret = BF_ST_OVERFLOW;
|
|
}
|
|
*pres = v;
|
|
return ret;
|
|
}
|
|
|
|
/* power to an integer with infinite precision */
|
|
int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b)
|
|
{
|
|
int ret, n_bits, i;
|
|
|
|
assert(r != a);
|
|
if (b == 0)
|
|
return bfdec_set_ui(r, 1);
|
|
ret = bfdec_set(r, a);
|
|
n_bits = LIMB_BITS - clz(b);
|
|
for(i = n_bits - 2; i >= 0; i--) {
|
|
ret |= bfdec_mul(r, r, r, BF_PREC_INF, BF_RNDZ);
|
|
if ((b >> i) & 1)
|
|
ret |= bfdec_mul(r, r, a, BF_PREC_INF, BF_RNDZ);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
char *bfdec_ftoa(size_t *plen, const bfdec_t *a, limb_t prec, bf_flags_t flags)
|
|
{
|
|
return bf_ftoa_internal(plen, (const bf_t *)a, 10, prec, flags, TRUE);
|
|
}
|
|
|
|
int bfdec_atof(bfdec_t *r, const char *str, const char **pnext,
|
|
limb_t prec, bf_flags_t flags)
|
|
{
|
|
slimb_t dummy_exp;
|
|
return bf_atof_internal((bf_t *)r, &dummy_exp, str, pnext, 10, prec,
|
|
flags, TRUE);
|
|
}
|
|
|
|
#endif /* USE_BF_DEC */
|
|
|
|
#ifdef USE_FFT_MUL
|
|
/***************************************************************/
|
|
/* Integer multiplication with FFT */
|
|
|
|
/* or LIMB_BITS at bit position 'pos' in tab */
|
|
static inline void put_bits(limb_t *tab, limb_t len, slimb_t pos, limb_t val)
|
|
{
|
|
limb_t i;
|
|
int p;
|
|
|
|
i = pos >> LIMB_LOG2_BITS;
|
|
p = pos & (LIMB_BITS - 1);
|
|
if (i < len)
|
|
tab[i] |= val << p;
|
|
if (p != 0) {
|
|
i++;
|
|
if (i < len) {
|
|
tab[i] |= val >> (LIMB_BITS - p);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(__AVX2__)
|
|
|
|
typedef double NTTLimb;
|
|
|
|
/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
|
|
#define NTT_MOD_LOG2_MIN 50
|
|
#define NTT_MOD_LOG2_MAX 51
|
|
#define NB_MODS 5
|
|
#define NTT_PROOT_2EXP 39
|
|
static const int ntt_int_bits[NB_MODS] = { 254, 203, 152, 101, 50, };
|
|
|
|
static const limb_t ntt_mods[NB_MODS] = { 0x00073a8000000001, 0x0007858000000001, 0x0007a38000000001, 0x0007a68000000001, 0x0007fd8000000001,
|
|
};
|
|
|
|
static const limb_t ntt_proot[2][NB_MODS] = {
|
|
{ 0x00056198d44332c8, 0x0002eb5d640aad39, 0x00047e31eaa35fd0, 0x0005271ac118a150, 0x00075e0ce8442bd5, },
|
|
{ 0x000461169761bcc5, 0x0002dac3cb2da688, 0x0004abc97751e3bf, 0x000656778fc8c485, 0x0000dc6469c269fa, },
|
|
};
|
|
|
|
static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
|
|
0x00020e4da740da8e, 0x0004c3dc09c09c1d, 0x000063bd097b4271, 0x000799d8f18f18fd,
|
|
0x0005384222222264, 0x000572b07c1f07fe, 0x00035cd08888889a,
|
|
0x00066015555557e3, 0x000725960b60b623,
|
|
0x0002fc1fa1d6ce12,
|
|
};
|
|
|
|
#else
|
|
|
|
typedef limb_t NTTLimb;
|
|
|
|
#if LIMB_BITS == 64
|
|
|
|
#define NTT_MOD_LOG2_MIN 61
|
|
#define NTT_MOD_LOG2_MAX 62
|
|
#define NB_MODS 5
|
|
#define NTT_PROOT_2EXP 51
|
|
static const int ntt_int_bits[NB_MODS] = { 307, 246, 185, 123, 61, };
|
|
|
|
static const limb_t ntt_mods[NB_MODS] = { 0x28d8000000000001, 0x2a88000000000001, 0x2ed8000000000001, 0x3508000000000001, 0x3aa8000000000001,
|
|
};
|
|
|
|
static const limb_t ntt_proot[2][NB_MODS] = {
|
|
{ 0x1b8ea61034a2bea7, 0x21a9762de58206fb, 0x02ca782f0756a8ea, 0x278384537a3e50a1, 0x106e13fee74ce0ab, },
|
|
{ 0x233513af133e13b8, 0x1d13140d1c6f75f1, 0x12cde57f97e3eeda, 0x0d6149e23cbe654f, 0x36cd204f522a1379, },
|
|
};
|
|
|
|
static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
|
|
0x08a9ed097b425eea, 0x18a44aaaaaaaaab3, 0x2493f57f57f57f5d, 0x126b8d0649a7f8d4,
|
|
0x09d80ed7303b5ccc, 0x25b8bcf3cf3cf3d5, 0x2ce6ce63398ce638,
|
|
0x0e31fad40a57eb59, 0x02a3529fd4a7f52f,
|
|
0x3a5493e93e93e94a,
|
|
};
|
|
|
|
#elif LIMB_BITS == 32
|
|
|
|
/* we must have: modulo >= 1 << NTT_MOD_LOG2_MIN */
|
|
#define NTT_MOD_LOG2_MIN 29
|
|
#define NTT_MOD_LOG2_MAX 30
|
|
#define NB_MODS 5
|
|
#define NTT_PROOT_2EXP 20
|
|
static const int ntt_int_bits[NB_MODS] = { 148, 119, 89, 59, 29, };
|
|
|
|
static const limb_t ntt_mods[NB_MODS] = { 0x0000000032b00001, 0x0000000033700001, 0x0000000036d00001, 0x0000000037300001, 0x000000003e500001,
|
|
};
|
|
|
|
static const limb_t ntt_proot[2][NB_MODS] = {
|
|
{ 0x0000000032525f31, 0x0000000005eb3b37, 0x00000000246eda9f, 0x0000000035f25901, 0x00000000022f5768, },
|
|
{ 0x00000000051eba1a, 0x00000000107be10e, 0x000000001cd574e0, 0x00000000053806e6, 0x000000002cd6bf98, },
|
|
};
|
|
|
|
static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
|
|
0x000000000449559a, 0x000000001eba6ca9, 0x000000002ec18e46, 0x000000000860160b,
|
|
0x000000000d321307, 0x000000000bf51120, 0x000000000f662938,
|
|
0x000000000932ab3e, 0x000000002f40eef8,
|
|
0x000000002e760905,
|
|
};
|
|
|
|
#endif /* LIMB_BITS */
|
|
|
|
#endif /* !AVX2 */
|
|
|
|
#if defined(__AVX2__)
|
|
#define NTT_TRIG_K_MAX 18
|
|
#else
|
|
#define NTT_TRIG_K_MAX 19
|
|
#endif
|
|
|
|
typedef struct BFNTTState {
|
|
bf_context_t *ctx;
|
|
|
|
/* used for mul_mod_fast() */
|
|
limb_t ntt_mods_div[NB_MODS];
|
|
|
|
limb_t ntt_proot_pow[NB_MODS][2][NTT_PROOT_2EXP + 1];
|
|
limb_t ntt_proot_pow_inv[NB_MODS][2][NTT_PROOT_2EXP + 1];
|
|
NTTLimb *ntt_trig[NB_MODS][2][NTT_TRIG_K_MAX + 1];
|
|
/* 1/2^n mod m */
|
|
limb_t ntt_len_inv[NB_MODS][NTT_PROOT_2EXP + 1][2];
|
|
#if defined(__AVX2__)
|
|
__m256d ntt_mods_cr_vec[NB_MODS * (NB_MODS - 1) / 2];
|
|
__m256d ntt_mods_vec[NB_MODS];
|
|
__m256d ntt_mods_inv_vec[NB_MODS];
|
|
#else
|
|
limb_t ntt_mods_cr_inv[NB_MODS * (NB_MODS - 1) / 2];
|
|
#endif
|
|
} BFNTTState;
|
|
|
|
static NTTLimb *get_trig(BFNTTState *s, int k, int inverse, int m_idx);
|
|
|
|
/* add modulo with up to (LIMB_BITS-1) bit modulo */
|
|
static inline limb_t add_mod(limb_t a, limb_t b, limb_t m)
|
|
{
|
|
limb_t r;
|
|
r = a + b;
|
|
if (r >= m)
|
|
r -= m;
|
|
return r;
|
|
}
|
|
|
|
/* sub modulo with up to LIMB_BITS bit modulo */
|
|
static inline limb_t sub_mod(limb_t a, limb_t b, limb_t m)
|
|
{
|
|
limb_t r;
|
|
r = a - b;
|
|
if (r > a)
|
|
r += m;
|
|
return r;
|
|
}
|
|
|
|
/* return (r0+r1*B) mod m
|
|
precondition: 0 <= r0+r1*B < 2^(64+NTT_MOD_LOG2_MIN)
|
|
*/
|
|
static inline limb_t mod_fast(dlimb_t r,
|
|
limb_t m, limb_t m_inv)
|
|
{
|
|
limb_t a1, q, t0, r1, r0;
|
|
|
|
a1 = r >> NTT_MOD_LOG2_MIN;
|
|
|
|
q = ((dlimb_t)a1 * m_inv) >> LIMB_BITS;
|
|
r = r - (dlimb_t)q * m - m * 2;
|
|
r1 = r >> LIMB_BITS;
|
|
t0 = (slimb_t)r1 >> 1;
|
|
r += m & t0;
|
|
r0 = r;
|
|
r1 = r >> LIMB_BITS;
|
|
r0 += m & r1;
|
|
return r0;
|
|
}
|
|
|
|
/* faster version using precomputed modulo inverse.
|
|
precondition: 0 <= a * b < 2^(64+NTT_MOD_LOG2_MIN) */
|
|
static inline limb_t mul_mod_fast(limb_t a, limb_t b,
|
|
limb_t m, limb_t m_inv)
|
|
{
|
|
dlimb_t r;
|
|
r = (dlimb_t)a * (dlimb_t)b;
|
|
return mod_fast(r, m, m_inv);
|
|
}
|
|
|
|
static inline limb_t init_mul_mod_fast(limb_t m)
|
|
{
|
|
dlimb_t t;
|
|
assert(m < (limb_t)1 << NTT_MOD_LOG2_MAX);
|
|
assert(m >= (limb_t)1 << NTT_MOD_LOG2_MIN);
|
|
t = (dlimb_t)1 << (LIMB_BITS + NTT_MOD_LOG2_MIN);
|
|
return t / m;
|
|
}
|
|
|
|
/* Faster version used when the multiplier is constant. 0 <= a < 2^64,
|
|
0 <= b < m. */
|
|
static inline limb_t mul_mod_fast2(limb_t a, limb_t b,
|
|
limb_t m, limb_t b_inv)
|
|
{
|
|
limb_t r, q;
|
|
|
|
q = ((dlimb_t)a * (dlimb_t)b_inv) >> LIMB_BITS;
|
|
r = a * b - q * m;
|
|
if (r >= m)
|
|
r -= m;
|
|
return r;
|
|
}
|
|
|
|
/* Faster version used when the multiplier is constant. 0 <= a < 2^64,
|
|
0 <= b < m. Let r = a * b mod m. The return value is 'r' or 'r +
|
|
m'. */
|
|
static inline limb_t mul_mod_fast3(limb_t a, limb_t b,
|
|
limb_t m, limb_t b_inv)
|
|
{
|
|
limb_t r, q;
|
|
|
|
q = ((dlimb_t)a * (dlimb_t)b_inv) >> LIMB_BITS;
|
|
r = a * b - q * m;
|
|
return r;
|
|
}
|
|
|
|
static inline limb_t init_mul_mod_fast2(limb_t b, limb_t m)
|
|
{
|
|
return ((dlimb_t)b << LIMB_BITS) / m;
|
|
}
|
|
|
|
#ifdef __AVX2__
|
|
|
|
static inline limb_t ntt_limb_to_int(NTTLimb a, limb_t m)
|
|
{
|
|
slimb_t v;
|
|
v = a;
|
|
if (v < 0)
|
|
v += m;
|
|
if (v >= m)
|
|
v -= m;
|
|
return v;
|
|
}
|
|
|
|
static inline NTTLimb int_to_ntt_limb(limb_t a, limb_t m)
|
|
{
|
|
return (slimb_t)a;
|
|
}
|
|
|
|
static inline NTTLimb int_to_ntt_limb2(limb_t a, limb_t m)
|
|
{
|
|
if (a >= (m / 2))
|
|
a -= m;
|
|
return (slimb_t)a;
|
|
}
|
|
|
|
/* return r + m if r < 0 otherwise r. */
|
|
static inline __m256d ntt_mod1(__m256d r, __m256d m)
|
|
{
|
|
return _mm256_blendv_pd(r, r + m, r);
|
|
}
|
|
|
|
/* input: abs(r) < 2 * m. Output: abs(r) < m */
|
|
static inline __m256d ntt_mod(__m256d r, __m256d mf, __m256d m2f)
|
|
{
|
|
return _mm256_blendv_pd(r, r + m2f, r) - mf;
|
|
}
|
|
|
|
/* input: abs(a*b) < 2 * m^2, output: abs(r) < m */
|
|
static inline __m256d ntt_mul_mod(__m256d a, __m256d b, __m256d mf,
|
|
__m256d m_inv)
|
|
{
|
|
__m256d r, q, ab1, ab0, qm0, qm1;
|
|
ab1 = a * b;
|
|
q = _mm256_round_pd(ab1 * m_inv, 0); /* round to nearest */
|
|
qm1 = q * mf;
|
|
qm0 = _mm256_fmsub_pd(q, mf, qm1); /* low part */
|
|
ab0 = _mm256_fmsub_pd(a, b, ab1); /* low part */
|
|
r = (ab1 - qm1) + (ab0 - qm0);
|
|
return r;
|
|
}
|
|
|
|
static void *bf_aligned_malloc(bf_context_t *s, size_t size, size_t align)
|
|
{
|
|
void *ptr;
|
|
void **ptr1;
|
|
ptr = bf_malloc(s, size + sizeof(void *) + align - 1);
|
|
if (!ptr)
|
|
return NULL;
|
|
ptr1 = (void **)(((uintptr_t)ptr + sizeof(void *) + align - 1) &
|
|
~(align - 1));
|
|
ptr1[-1] = ptr;
|
|
return ptr1;
|
|
}
|
|
|
|
static void bf_aligned_free(bf_context_t *s, void *ptr)
|
|
{
|
|
if (!ptr)
|
|
return;
|
|
bf_free(s, ((void **)ptr)[-1]);
|
|
}
|
|
|
|
static void *ntt_malloc(BFNTTState *s, size_t size)
|
|
{
|
|
return bf_aligned_malloc(s->ctx, size, 64);
|
|
}
|
|
|
|
static void ntt_free(BFNTTState *s, void *ptr)
|
|
{
|
|
bf_aligned_free(s->ctx, ptr);
|
|
}
|
|
|
|
static no_inline int ntt_fft(BFNTTState *s,
|
|
NTTLimb *out_buf, NTTLimb *in_buf,
|
|
NTTLimb *tmp_buf, int fft_len_log2,
|
|
int inverse, int m_idx)
|
|
{
|
|
limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j;
|
|
NTTLimb *tab_in, *tab_out, *tmp, *trig;
|
|
__m256d m_inv, mf, m2f, c, a0, a1, b0, b1;
|
|
limb_t m;
|
|
int l;
|
|
|
|
m = ntt_mods[m_idx];
|
|
|
|
m_inv = _mm256_set1_pd(1.0 / (double)m);
|
|
mf = _mm256_set1_pd(m);
|
|
m2f = _mm256_set1_pd(m * 2);
|
|
|
|
n = (limb_t)1 << fft_len_log2;
|
|
assert(n >= 8);
|
|
stride_in = n / 2;
|
|
|
|
tab_in = in_buf;
|
|
tab_out = tmp_buf;
|
|
trig = get_trig(s, fft_len_log2, inverse, m_idx);
|
|
if (!trig)
|
|
return -1;
|
|
p = 0;
|
|
for(k = 0; k < stride_in; k += 4) {
|
|
a0 = _mm256_load_pd(&tab_in[k]);
|
|
a1 = _mm256_load_pd(&tab_in[k + stride_in]);
|
|
c = _mm256_load_pd(trig);
|
|
trig += 4;
|
|
b0 = ntt_mod(a0 + a1, mf, m2f);
|
|
b1 = ntt_mul_mod(a0 - a1, c, mf, m_inv);
|
|
a0 = _mm256_permute2f128_pd(b0, b1, 0x20);
|
|
a1 = _mm256_permute2f128_pd(b0, b1, 0x31);
|
|
a0 = _mm256_permute4x64_pd(a0, 0xd8);
|
|
a1 = _mm256_permute4x64_pd(a1, 0xd8);
|
|
_mm256_store_pd(&tab_out[p], a0);
|
|
_mm256_store_pd(&tab_out[p + 4], a1);
|
|
p += 2 * 4;
|
|
}
|
|
tmp = tab_in;
|
|
tab_in = tab_out;
|
|
tab_out = tmp;
|
|
|
|
trig = get_trig(s, fft_len_log2 - 1, inverse, m_idx);
|
|
if (!trig)
|
|
return -1;
|
|
p = 0;
|
|
for(k = 0; k < stride_in; k += 4) {
|
|
a0 = _mm256_load_pd(&tab_in[k]);
|
|
a1 = _mm256_load_pd(&tab_in[k + stride_in]);
|
|
c = _mm256_setr_pd(trig[0], trig[0], trig[1], trig[1]);
|
|
trig += 2;
|
|
b0 = ntt_mod(a0 + a1, mf, m2f);
|
|
b1 = ntt_mul_mod(a0 - a1, c, mf, m_inv);
|
|
a0 = _mm256_permute2f128_pd(b0, b1, 0x20);
|
|
a1 = _mm256_permute2f128_pd(b0, b1, 0x31);
|
|
_mm256_store_pd(&tab_out[p], a0);
|
|
_mm256_store_pd(&tab_out[p + 4], a1);
|
|
p += 2 * 4;
|
|
}
|
|
tmp = tab_in;
|
|
tab_in = tab_out;
|
|
tab_out = tmp;
|
|
|
|
nb_blocks = n / 4;
|
|
fft_per_block = 4;
|
|
|
|
l = fft_len_log2 - 2;
|
|
while (nb_blocks != 2) {
|
|
nb_blocks >>= 1;
|
|
p = 0;
|
|
k = 0;
|
|
trig = get_trig(s, l, inverse, m_idx);
|
|
if (!trig)
|
|
return -1;
|
|
for(i = 0; i < nb_blocks; i++) {
|
|
c = _mm256_set1_pd(trig[0]);
|
|
trig++;
|
|
for(j = 0; j < fft_per_block; j += 4) {
|
|
a0 = _mm256_load_pd(&tab_in[k + j]);
|
|
a1 = _mm256_load_pd(&tab_in[k + j + stride_in]);
|
|
b0 = ntt_mod(a0 + a1, mf, m2f);
|
|
b1 = ntt_mul_mod(a0 - a1, c, mf, m_inv);
|
|
_mm256_store_pd(&tab_out[p + j], b0);
|
|
_mm256_store_pd(&tab_out[p + j + fft_per_block], b1);
|
|
}
|
|
k += fft_per_block;
|
|
p += 2 * fft_per_block;
|
|
}
|
|
fft_per_block <<= 1;
|
|
l--;
|
|
tmp = tab_in;
|
|
tab_in = tab_out;
|
|
tab_out = tmp;
|
|
}
|
|
|
|
tab_out = out_buf;
|
|
for(k = 0; k < stride_in; k += 4) {
|
|
a0 = _mm256_load_pd(&tab_in[k]);
|
|
a1 = _mm256_load_pd(&tab_in[k + stride_in]);
|
|
b0 = ntt_mod(a0 + a1, mf, m2f);
|
|
b1 = ntt_mod(a0 - a1, mf, m2f);
|
|
_mm256_store_pd(&tab_out[k], b0);
|
|
_mm256_store_pd(&tab_out[k + stride_in], b1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void ntt_vec_mul(BFNTTState *s,
|
|
NTTLimb *tab1, NTTLimb *tab2, limb_t fft_len_log2,
|
|
int k_tot, int m_idx)
|
|
{
|
|
limb_t i, c_inv, n, m;
|
|
__m256d m_inv, mf, a, b, c;
|
|
|
|
m = ntt_mods[m_idx];
|
|
c_inv = s->ntt_len_inv[m_idx][k_tot][0];
|
|
m_inv = _mm256_set1_pd(1.0 / (double)m);
|
|
mf = _mm256_set1_pd(m);
|
|
c = _mm256_set1_pd(int_to_ntt_limb(c_inv, m));
|
|
n = (limb_t)1 << fft_len_log2;
|
|
for(i = 0; i < n; i += 4) {
|
|
a = _mm256_load_pd(&tab1[i]);
|
|
b = _mm256_load_pd(&tab2[i]);
|
|
a = ntt_mul_mod(a, b, mf, m_inv);
|
|
a = ntt_mul_mod(a, c, mf, m_inv);
|
|
_mm256_store_pd(&tab1[i], a);
|
|
}
|
|
}
|
|
|
|
static no_inline void mul_trig(NTTLimb *buf,
|
|
limb_t n, limb_t c1, limb_t m, limb_t m_inv1)
|
|
{
|
|
limb_t i, c2, c3, c4;
|
|
__m256d c, c_mul, a0, mf, m_inv;
|
|
assert(n >= 2);
|
|
|
|
mf = _mm256_set1_pd(m);
|
|
m_inv = _mm256_set1_pd(1.0 / (double)m);
|
|
|
|
c2 = mul_mod_fast(c1, c1, m, m_inv1);
|
|
c3 = mul_mod_fast(c2, c1, m, m_inv1);
|
|
c4 = mul_mod_fast(c2, c2, m, m_inv1);
|
|
c = _mm256_setr_pd(1, int_to_ntt_limb(c1, m),
|
|
int_to_ntt_limb(c2, m), int_to_ntt_limb(c3, m));
|
|
c_mul = _mm256_set1_pd(int_to_ntt_limb(c4, m));
|
|
for(i = 0; i < n; i += 4) {
|
|
a0 = _mm256_load_pd(&buf[i]);
|
|
a0 = ntt_mul_mod(a0, c, mf, m_inv);
|
|
_mm256_store_pd(&buf[i], a0);
|
|
c = ntt_mul_mod(c, c_mul, mf, m_inv);
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
static void *ntt_malloc(BFNTTState *s, size_t size)
|
|
{
|
|
return bf_malloc(s->ctx, size);
|
|
}
|
|
|
|
static void ntt_free(BFNTTState *s, void *ptr)
|
|
{
|
|
bf_free(s->ctx, ptr);
|
|
}
|
|
|
|
static inline limb_t ntt_limb_to_int(NTTLimb a, limb_t m)
|
|
{
|
|
if (a >= m)
|
|
a -= m;
|
|
return a;
|
|
}
|
|
|
|
static inline NTTLimb int_to_ntt_limb(slimb_t a, limb_t m)
|
|
{
|
|
return a;
|
|
}
|
|
|
|
static no_inline int ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
|
|
NTTLimb *tmp_buf, int fft_len_log2,
|
|
int inverse, int m_idx)
|
|
{
|
|
limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j, m, m2;
|
|
NTTLimb *tab_in, *tab_out, *tmp, a0, a1, b0, b1, c, *trig, c_inv;
|
|
int l;
|
|
|
|
m = ntt_mods[m_idx];
|
|
m2 = 2 * m;
|
|
n = (limb_t)1 << fft_len_log2;
|
|
nb_blocks = n;
|
|
fft_per_block = 1;
|
|
stride_in = n / 2;
|
|
tab_in = in_buf;
|
|
tab_out = tmp_buf;
|
|
l = fft_len_log2;
|
|
while (nb_blocks != 2) {
|
|
nb_blocks >>= 1;
|
|
p = 0;
|
|
k = 0;
|
|
trig = get_trig(s, l, inverse, m_idx);
|
|
if (!trig)
|
|
return -1;
|
|
for(i = 0; i < nb_blocks; i++) {
|
|
c = trig[0];
|
|
c_inv = trig[1];
|
|
trig += 2;
|
|
for(j = 0; j < fft_per_block; j++) {
|
|
a0 = tab_in[k + j];
|
|
a1 = tab_in[k + j + stride_in];
|
|
b0 = add_mod(a0, a1, m2);
|
|
b1 = a0 - a1 + m2;
|
|
b1 = mul_mod_fast3(b1, c, m, c_inv);
|
|
tab_out[p + j] = b0;
|
|
tab_out[p + j + fft_per_block] = b1;
|
|
}
|
|
k += fft_per_block;
|
|
p += 2 * fft_per_block;
|
|
}
|
|
fft_per_block <<= 1;
|
|
l--;
|
|
tmp = tab_in;
|
|
tab_in = tab_out;
|
|
tab_out = tmp;
|
|
}
|
|
/* no twiddle in last step */
|
|
tab_out = out_buf;
|
|
for(k = 0; k < stride_in; k++) {
|
|
a0 = tab_in[k];
|
|
a1 = tab_in[k + stride_in];
|
|
b0 = add_mod(a0, a1, m2);
|
|
b1 = sub_mod(a0, a1, m2);
|
|
tab_out[k] = b0;
|
|
tab_out[k + stride_in] = b1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void ntt_vec_mul(BFNTTState *s,
|
|
NTTLimb *tab1, NTTLimb *tab2, int fft_len_log2,
|
|
int k_tot, int m_idx)
|
|
{
|
|
limb_t i, norm, norm_inv, a, n, m, m_inv;
|
|
|
|
m = ntt_mods[m_idx];
|
|
m_inv = s->ntt_mods_div[m_idx];
|
|
norm = s->ntt_len_inv[m_idx][k_tot][0];
|
|
norm_inv = s->ntt_len_inv[m_idx][k_tot][1];
|
|
n = (limb_t)1 << fft_len_log2;
|
|
for(i = 0; i < n; i++) {
|
|
a = tab1[i];
|
|
/* need to reduce the range so that the product is <
|
|
2^(LIMB_BITS+NTT_MOD_LOG2_MIN) */
|
|
if (a >= m)
|
|
a -= m;
|
|
a = mul_mod_fast(a, tab2[i], m, m_inv);
|
|
a = mul_mod_fast3(a, norm, m, norm_inv);
|
|
tab1[i] = a;
|
|
}
|
|
}
|
|
|
|
static no_inline void mul_trig(NTTLimb *buf,
|
|
limb_t n, limb_t c_mul, limb_t m, limb_t m_inv)
|
|
{
|
|
limb_t i, c0, c_mul_inv;
|
|
|
|
c0 = 1;
|
|
c_mul_inv = init_mul_mod_fast2(c_mul, m);
|
|
for(i = 0; i < n; i++) {
|
|
buf[i] = mul_mod_fast(buf[i], c0, m, m_inv);
|
|
c0 = mul_mod_fast2(c0, c_mul, m, c_mul_inv);
|
|
}
|
|
}
|
|
|
|
#endif /* !AVX2 */
|
|
|
|
static no_inline NTTLimb *get_trig(BFNTTState *s,
|
|
int k, int inverse, int m_idx)
|
|
{
|
|
NTTLimb *tab;
|
|
limb_t i, n2, c, c_mul, m, c_mul_inv;
|
|
|
|
if (k > NTT_TRIG_K_MAX)
|
|
return NULL;
|
|
|
|
tab = s->ntt_trig[m_idx][inverse][k];
|
|
if (tab)
|
|
return tab;
|
|
n2 = (limb_t)1 << (k - 1);
|
|
m = ntt_mods[m_idx];
|
|
#ifdef __AVX2__
|
|
tab = ntt_malloc(s, sizeof(NTTLimb) * n2);
|
|
#else
|
|
tab = ntt_malloc(s, sizeof(NTTLimb) * n2 * 2);
|
|
#endif
|
|
if (!tab)
|
|
return NULL;
|
|
c = 1;
|
|
c_mul = s->ntt_proot_pow[m_idx][inverse][k];
|
|
c_mul_inv = s->ntt_proot_pow_inv[m_idx][inverse][k];
|
|
for(i = 0; i < n2; i++) {
|
|
#ifdef __AVX2__
|
|
tab[i] = int_to_ntt_limb2(c, m);
|
|
#else
|
|
tab[2 * i] = int_to_ntt_limb(c, m);
|
|
tab[2 * i + 1] = init_mul_mod_fast2(c, m);
|
|
#endif
|
|
c = mul_mod_fast2(c, c_mul, m, c_mul_inv);
|
|
}
|
|
s->ntt_trig[m_idx][inverse][k] = tab;
|
|
return tab;
|
|
}
|
|
|
|
void fft_clear_cache(bf_context_t *s1)
|
|
{
|
|
int m_idx, inverse, k;
|
|
BFNTTState *s = s1->ntt_state;
|
|
if (s) {
|
|
for(m_idx = 0; m_idx < NB_MODS; m_idx++) {
|
|
for(inverse = 0; inverse < 2; inverse++) {
|
|
for(k = 0; k < NTT_TRIG_K_MAX + 1; k++) {
|
|
if (s->ntt_trig[m_idx][inverse][k]) {
|
|
ntt_free(s, s->ntt_trig[m_idx][inverse][k]);
|
|
s->ntt_trig[m_idx][inverse][k] = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#if defined(__AVX2__)
|
|
bf_aligned_free(s1, s);
|
|
#else
|
|
bf_free(s1, s);
|
|
#endif
|
|
s1->ntt_state = NULL;
|
|
}
|
|
}
|
|
|
|
#define STRIP_LEN 16
|
|
|
|
/* dst = buf1, src = buf2 */
|
|
static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
|
|
int k1, int k2, limb_t n1, limb_t n2, int inverse,
|
|
limb_t m_idx)
|
|
{
|
|
limb_t i, j, c_mul, c0, m, m_inv, strip_len, l;
|
|
NTTLimb *buf2, *buf3;
|
|
|
|
buf2 = NULL;
|
|
buf3 = ntt_malloc(s, sizeof(NTTLimb) * n1);
|
|
if (!buf3)
|
|
goto fail;
|
|
if (k2 == 0) {
|
|
if (ntt_fft(s, buf1, buf1, buf3, k1, inverse, m_idx))
|
|
goto fail;
|
|
} else {
|
|
strip_len = STRIP_LEN;
|
|
buf2 = ntt_malloc(s, sizeof(NTTLimb) * n1 * strip_len);
|
|
if (!buf2)
|
|
goto fail;
|
|
m = ntt_mods[m_idx];
|
|
m_inv = s->ntt_mods_div[m_idx];
|
|
c0 = s->ntt_proot_pow[m_idx][inverse][k1 + k2];
|
|
c_mul = 1;
|
|
assert((n2 % strip_len) == 0);
|
|
for(j = 0; j < n2; j += strip_len) {
|
|
for(i = 0; i < n1; i++) {
|
|
for(l = 0; l < strip_len; l++) {
|
|
buf2[i + l * n1] = buf1[i * n2 + (j + l)];
|
|
}
|
|
}
|
|
for(l = 0; l < strip_len; l++) {
|
|
if (inverse)
|
|
mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
|
|
if (ntt_fft(s, buf2 + l * n1, buf2 + l * n1, buf3, k1, inverse, m_idx))
|
|
goto fail;
|
|
if (!inverse)
|
|
mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
|
|
c_mul = mul_mod_fast(c_mul, c0, m, m_inv);
|
|
}
|
|
|
|
for(i = 0; i < n1; i++) {
|
|
for(l = 0; l < strip_len; l++) {
|
|
buf1[i * n2 + (j + l)] = buf2[i + l *n1];
|
|
}
|
|
}
|
|
}
|
|
ntt_free(s, buf2);
|
|
}
|
|
ntt_free(s, buf3);
|
|
return 0;
|
|
fail:
|
|
ntt_free(s, buf2);
|
|
ntt_free(s, buf3);
|
|
return -1;
|
|
}
|
|
|
|
|
|
/* dst = buf1, src = buf2, tmp = buf3 */
|
|
static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
|
|
int k, int k_tot, limb_t m_idx)
|
|
{
|
|
limb_t n1, n2, i;
|
|
int k1, k2;
|
|
|
|
if (k <= NTT_TRIG_K_MAX) {
|
|
k1 = k;
|
|
} else {
|
|
/* recursive split of the FFT */
|
|
k1 = bf_min(k / 2, NTT_TRIG_K_MAX);
|
|
}
|
|
k2 = k - k1;
|
|
n1 = (limb_t)1 << k1;
|
|
n2 = (limb_t)1 << k2;
|
|
|
|
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
|
|
return -1;
|
|
if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
|
|
return -1;
|
|
if (k2 == 0) {
|
|
ntt_vec_mul(s, buf1, buf2, k, k_tot, m_idx);
|
|
} else {
|
|
for(i = 0; i < n1; i++) {
|
|
ntt_conv(s, buf1 + i * n2, buf2 + i * n2, k2, k_tot, m_idx);
|
|
}
|
|
}
|
|
if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 1, m_idx))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static no_inline void limb_to_ntt(BFNTTState *s,
|
|
NTTLimb *tabr, limb_t fft_len,
|
|
const limb_t *taba, limb_t a_len, int dpl,
|
|
int first_m_idx, int nb_mods)
|
|
{
|
|
slimb_t i, n;
|
|
dlimb_t a, b;
|
|
int j, shift;
|
|
limb_t base_mask1, a0, a1, a2, r, m, m_inv;
|
|
|
|
memset(tabr, 0, sizeof(NTTLimb) * fft_len * nb_mods);
|
|
shift = dpl & (LIMB_BITS - 1);
|
|
if (shift == 0)
|
|
base_mask1 = -1;
|
|
else
|
|
base_mask1 = ((limb_t)1 << shift) - 1;
|
|
n = bf_min(fft_len, (a_len * LIMB_BITS + dpl - 1) / dpl);
|
|
for(i = 0; i < n; i++) {
|
|
a0 = get_bits(taba, a_len, i * dpl);
|
|
if (dpl <= LIMB_BITS) {
|
|
a0 &= base_mask1;
|
|
a = a0;
|
|
} else {
|
|
a1 = get_bits(taba, a_len, i * dpl + LIMB_BITS);
|
|
if (dpl <= (LIMB_BITS + NTT_MOD_LOG2_MIN)) {
|
|
a = a0 | ((dlimb_t)(a1 & base_mask1) << LIMB_BITS);
|
|
} else {
|
|
if (dpl > 2 * LIMB_BITS) {
|
|
a2 = get_bits(taba, a_len, i * dpl + LIMB_BITS * 2) &
|
|
base_mask1;
|
|
} else {
|
|
a1 &= base_mask1;
|
|
a2 = 0;
|
|
}
|
|
// printf("a=0x%016lx%016lx%016lx\n", a2, a1, a0);
|
|
a = (a0 >> (LIMB_BITS - NTT_MOD_LOG2_MAX + NTT_MOD_LOG2_MIN)) |
|
|
((dlimb_t)a1 << (NTT_MOD_LOG2_MAX - NTT_MOD_LOG2_MIN)) |
|
|
((dlimb_t)a2 << (LIMB_BITS + NTT_MOD_LOG2_MAX - NTT_MOD_LOG2_MIN));
|
|
a0 &= ((limb_t)1 << (LIMB_BITS - NTT_MOD_LOG2_MAX + NTT_MOD_LOG2_MIN)) - 1;
|
|
}
|
|
}
|
|
for(j = 0; j < nb_mods; j++) {
|
|
m = ntt_mods[first_m_idx + j];
|
|
m_inv = s->ntt_mods_div[first_m_idx + j];
|
|
r = mod_fast(a, m, m_inv);
|
|
if (dpl > (LIMB_BITS + NTT_MOD_LOG2_MIN)) {
|
|
b = ((dlimb_t)r << (LIMB_BITS - NTT_MOD_LOG2_MAX + NTT_MOD_LOG2_MIN)) | a0;
|
|
r = mod_fast(b, m, m_inv);
|
|
}
|
|
tabr[i + j * fft_len] = int_to_ntt_limb(r, m);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(__AVX2__)
|
|
|
|
#define VEC_LEN 4
|
|
|
|
typedef union {
|
|
__m256d v;
|
|
double d[4];
|
|
} VecUnion;
|
|
|
|
static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
|
|
const NTTLimb *buf, int fft_len_log2, int dpl,
|
|
int nb_mods)
|
|
{
|
|
const limb_t *mods = ntt_mods + NB_MODS - nb_mods;
|
|
const __m256d *mods_cr_vec, *mf, *m_inv;
|
|
VecUnion y[NB_MODS];
|
|
limb_t u[NB_MODS], carry[NB_MODS], fft_len, base_mask1, r;
|
|
slimb_t i, len, pos;
|
|
int j, k, l, shift, n_limb1, p;
|
|
dlimb_t t;
|
|
|
|
j = NB_MODS * (NB_MODS - 1) / 2 - nb_mods * (nb_mods - 1) / 2;
|
|
mods_cr_vec = s->ntt_mods_cr_vec + j;
|
|
mf = s->ntt_mods_vec + NB_MODS - nb_mods;
|
|
m_inv = s->ntt_mods_inv_vec + NB_MODS - nb_mods;
|
|
|
|
shift = dpl & (LIMB_BITS - 1);
|
|
if (shift == 0)
|
|
base_mask1 = -1;
|
|
else
|
|
base_mask1 = ((limb_t)1 << shift) - 1;
|
|
n_limb1 = ((unsigned)dpl - 1) / LIMB_BITS;
|
|
for(j = 0; j < NB_MODS; j++)
|
|
carry[j] = 0;
|
|
for(j = 0; j < NB_MODS; j++)
|
|
u[j] = 0; /* avoid warnings */
|
|
memset(tabr, 0, sizeof(limb_t) * r_len);
|
|
fft_len = (limb_t)1 << fft_len_log2;
|
|
len = bf_min(fft_len, (r_len * LIMB_BITS + dpl - 1) / dpl);
|
|
len = (len + VEC_LEN - 1) & ~(VEC_LEN - 1);
|
|
i = 0;
|
|
while (i < len) {
|
|
for(j = 0; j < nb_mods; j++)
|
|
y[j].v = *(__m256d *)&buf[i + fft_len * j];
|
|
|
|
/* Chinese remainder to get mixed radix representation */
|
|
l = 0;
|
|
for(j = 0; j < nb_mods - 1; j++) {
|
|
y[j].v = ntt_mod1(y[j].v, mf[j]);
|
|
for(k = j + 1; k < nb_mods; k++) {
|
|
y[k].v = ntt_mul_mod(y[k].v - y[j].v,
|
|
mods_cr_vec[l], mf[k], m_inv[k]);
|
|
l++;
|
|
}
|
|
}
|
|
y[j].v = ntt_mod1(y[j].v, mf[j]);
|
|
|
|
for(p = 0; p < VEC_LEN; p++) {
|
|
/* back to normal representation */
|
|
u[0] = (int64_t)y[nb_mods - 1].d[p];
|
|
l = 1;
|
|
for(j = nb_mods - 2; j >= 1; j--) {
|
|
r = (int64_t)y[j].d[p];
|
|
for(k = 0; k < l; k++) {
|
|
t = (dlimb_t)u[k] * mods[j] + r;
|
|
r = t >> LIMB_BITS;
|
|
u[k] = t;
|
|
}
|
|
u[l] = r;
|
|
l++;
|
|
}
|
|
/* XXX: for nb_mods = 5, l should be 4 */
|
|
|
|
/* last step adds the carry */
|
|
r = (int64_t)y[0].d[p];
|
|
for(k = 0; k < l; k++) {
|
|
t = (dlimb_t)u[k] * mods[j] + r + carry[k];
|
|
r = t >> LIMB_BITS;
|
|
u[k] = t;
|
|
}
|
|
u[l] = r + carry[l];
|
|
|
|
/* write the digits */
|
|
pos = i * dpl;
|
|
for(j = 0; j < n_limb1; j++) {
|
|
put_bits(tabr, r_len, pos, u[j]);
|
|
pos += LIMB_BITS;
|
|
}
|
|
put_bits(tabr, r_len, pos, u[n_limb1] & base_mask1);
|
|
/* shift by dpl digits and set the carry */
|
|
if (shift == 0) {
|
|
for(j = n_limb1 + 1; j < nb_mods; j++)
|
|
carry[j - (n_limb1 + 1)] = u[j];
|
|
} else {
|
|
for(j = n_limb1; j < nb_mods - 1; j++) {
|
|
carry[j - n_limb1] = (u[j] >> shift) |
|
|
(u[j + 1] << (LIMB_BITS - shift));
|
|
}
|
|
carry[nb_mods - 1 - n_limb1] = u[nb_mods - 1] >> shift;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
|
|
const NTTLimb *buf, int fft_len_log2, int dpl,
|
|
int nb_mods)
|
|
{
|
|
const limb_t *mods = ntt_mods + NB_MODS - nb_mods;
|
|
const limb_t *mods_cr, *mods_cr_inv;
|
|
limb_t y[NB_MODS], u[NB_MODS], carry[NB_MODS], fft_len, base_mask1, r;
|
|
slimb_t i, len, pos;
|
|
int j, k, l, shift, n_limb1;
|
|
dlimb_t t;
|
|
|
|
j = NB_MODS * (NB_MODS - 1) / 2 - nb_mods * (nb_mods - 1) / 2;
|
|
mods_cr = ntt_mods_cr + j;
|
|
mods_cr_inv = s->ntt_mods_cr_inv + j;
|
|
|
|
shift = dpl & (LIMB_BITS - 1);
|
|
if (shift == 0)
|
|
base_mask1 = -1;
|
|
else
|
|
base_mask1 = ((limb_t)1 << shift) - 1;
|
|
n_limb1 = ((unsigned)dpl - 1) / LIMB_BITS;
|
|
for(j = 0; j < NB_MODS; j++)
|
|
carry[j] = 0;
|
|
for(j = 0; j < NB_MODS; j++)
|
|
u[j] = 0; /* avoid warnings */
|
|
memset(tabr, 0, sizeof(limb_t) * r_len);
|
|
fft_len = (limb_t)1 << fft_len_log2;
|
|
len = bf_min(fft_len, (r_len * LIMB_BITS + dpl - 1) / dpl);
|
|
for(i = 0; i < len; i++) {
|
|
for(j = 0; j < nb_mods; j++) {
|
|
y[j] = ntt_limb_to_int(buf[i + fft_len * j], mods[j]);
|
|
}
|
|
|
|
/* Chinese remainder to get mixed radix representation */
|
|
l = 0;
|
|
for(j = 0; j < nb_mods - 1; j++) {
|
|
for(k = j + 1; k < nb_mods; k++) {
|
|
limb_t m;
|
|
m = mods[k];
|
|
/* Note: there is no overflow in the sub_mod() because
|
|
the modulos are sorted by increasing order */
|
|
y[k] = mul_mod_fast2(y[k] - y[j] + m,
|
|
mods_cr[l], m, mods_cr_inv[l]);
|
|
l++;
|
|
}
|
|
}
|
|
|
|
/* back to normal representation */
|
|
u[0] = y[nb_mods - 1];
|
|
l = 1;
|
|
for(j = nb_mods - 2; j >= 1; j--) {
|
|
r = y[j];
|
|
for(k = 0; k < l; k++) {
|
|
t = (dlimb_t)u[k] * mods[j] + r;
|
|
r = t >> LIMB_BITS;
|
|
u[k] = t;
|
|
}
|
|
u[l] = r;
|
|
l++;
|
|
}
|
|
|
|
/* last step adds the carry */
|
|
r = y[0];
|
|
for(k = 0; k < l; k++) {
|
|
t = (dlimb_t)u[k] * mods[j] + r + carry[k];
|
|
r = t >> LIMB_BITS;
|
|
u[k] = t;
|
|
}
|
|
u[l] = r + carry[l];
|
|
|
|
/* write the digits */
|
|
pos = i * dpl;
|
|
for(j = 0; j < n_limb1; j++) {
|
|
put_bits(tabr, r_len, pos, u[j]);
|
|
pos += LIMB_BITS;
|
|
}
|
|
put_bits(tabr, r_len, pos, u[n_limb1] & base_mask1);
|
|
/* shift by dpl digits and set the carry */
|
|
if (shift == 0) {
|
|
for(j = n_limb1 + 1; j < nb_mods; j++)
|
|
carry[j - (n_limb1 + 1)] = u[j];
|
|
} else {
|
|
for(j = n_limb1; j < nb_mods - 1; j++) {
|
|
carry[j - n_limb1] = (u[j] >> shift) |
|
|
(u[j + 1] << (LIMB_BITS - shift));
|
|
}
|
|
carry[nb_mods - 1 - n_limb1] = u[nb_mods - 1] >> shift;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static int ntt_static_init(bf_context_t *s1)
|
|
{
|
|
BFNTTState *s;
|
|
int inverse, i, j, k, l;
|
|
limb_t c, c_inv, c_inv2, m, m_inv;
|
|
|
|
if (s1->ntt_state)
|
|
return 0;
|
|
#if defined(__AVX2__)
|
|
s = bf_aligned_malloc(s1, sizeof(*s), 64);
|
|
#else
|
|
s = bf_malloc(s1, sizeof(*s));
|
|
#endif
|
|
if (!s)
|
|
return -1;
|
|
memset(s, 0, sizeof(*s));
|
|
s1->ntt_state = s;
|
|
s->ctx = s1;
|
|
|
|
for(j = 0; j < NB_MODS; j++) {
|
|
m = ntt_mods[j];
|
|
m_inv = init_mul_mod_fast(m);
|
|
s->ntt_mods_div[j] = m_inv;
|
|
#if defined(__AVX2__)
|
|
s->ntt_mods_vec[j] = _mm256_set1_pd(m);
|
|
s->ntt_mods_inv_vec[j] = _mm256_set1_pd(1.0 / (double)m);
|
|
#endif
|
|
c_inv2 = (m + 1) / 2; /* 1/2 */
|
|
c_inv = 1;
|
|
for(i = 0; i <= NTT_PROOT_2EXP; i++) {
|
|
s->ntt_len_inv[j][i][0] = c_inv;
|
|
s->ntt_len_inv[j][i][1] = init_mul_mod_fast2(c_inv, m);
|
|
c_inv = mul_mod_fast(c_inv, c_inv2, m, m_inv);
|
|
}
|
|
|
|
for(inverse = 0; inverse < 2; inverse++) {
|
|
c = ntt_proot[inverse][j];
|
|
for(i = 0; i < NTT_PROOT_2EXP; i++) {
|
|
s->ntt_proot_pow[j][inverse][NTT_PROOT_2EXP - i] = c;
|
|
s->ntt_proot_pow_inv[j][inverse][NTT_PROOT_2EXP - i] =
|
|
init_mul_mod_fast2(c, m);
|
|
c = mul_mod_fast(c, c, m, m_inv);
|
|
}
|
|
}
|
|
}
|
|
|
|
l = 0;
|
|
for(j = 0; j < NB_MODS - 1; j++) {
|
|
for(k = j + 1; k < NB_MODS; k++) {
|
|
#if defined(__AVX2__)
|
|
s->ntt_mods_cr_vec[l] = _mm256_set1_pd(int_to_ntt_limb2(ntt_mods_cr[l],
|
|
ntt_mods[k]));
|
|
#else
|
|
s->ntt_mods_cr_inv[l] = init_mul_mod_fast2(ntt_mods_cr[l],
|
|
ntt_mods[k]);
|
|
#endif
|
|
l++;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len)
|
|
{
|
|
int dpl, fft_len_log2, n_bits, nb_mods, dpl_found, fft_len_log2_found;
|
|
int int_bits, nb_mods_found;
|
|
limb_t cost, min_cost;
|
|
|
|
min_cost = -1;
|
|
dpl_found = 0;
|
|
nb_mods_found = 4;
|
|
fft_len_log2_found = 0;
|
|
for(nb_mods = 3; nb_mods <= NB_MODS; nb_mods++) {
|
|
int_bits = ntt_int_bits[NB_MODS - nb_mods];
|
|
dpl = bf_min((int_bits - 4) / 2,
|
|
2 * LIMB_BITS + 2 * NTT_MOD_LOG2_MIN - NTT_MOD_LOG2_MAX);
|
|
for(;;) {
|
|
fft_len_log2 = ceil_log2((len * LIMB_BITS + dpl - 1) / dpl);
|
|
if (fft_len_log2 > NTT_PROOT_2EXP)
|
|
goto next;
|
|
n_bits = fft_len_log2 + 2 * dpl;
|
|
if (n_bits <= int_bits) {
|
|
cost = ((limb_t)(fft_len_log2 + 1) << fft_len_log2) * nb_mods;
|
|
// printf("n=%d dpl=%d: cost=%" PRId64 "\n", nb_mods, dpl, (int64_t)cost);
|
|
if (cost < min_cost) {
|
|
min_cost = cost;
|
|
dpl_found = dpl;
|
|
nb_mods_found = nb_mods;
|
|
fft_len_log2_found = fft_len_log2;
|
|
}
|
|
break;
|
|
}
|
|
dpl--;
|
|
if (dpl == 0)
|
|
break;
|
|
}
|
|
next: ;
|
|
}
|
|
if (!dpl_found)
|
|
abort();
|
|
/* limit dpl if possible to reduce fixed cost of limb/NTT conversion */
|
|
if (dpl_found > (LIMB_BITS + NTT_MOD_LOG2_MIN) &&
|
|
((limb_t)(LIMB_BITS + NTT_MOD_LOG2_MIN) << fft_len_log2_found) >=
|
|
len * LIMB_BITS) {
|
|
dpl_found = LIMB_BITS + NTT_MOD_LOG2_MIN;
|
|
}
|
|
*pnb_mods = nb_mods_found;
|
|
*pdpl = dpl_found;
|
|
return fft_len_log2_found;
|
|
}
|
|
|
|
/* return 0 if OK, -1 if memory error */
|
|
static no_inline int fft_mul(bf_context_t *s1,
|
|
bf_t *res, limb_t *a_tab, limb_t a_len,
|
|
limb_t *b_tab, limb_t b_len, int mul_flags)
|
|
{
|
|
BFNTTState *s;
|
|
int dpl, fft_len_log2, j, nb_mods, reduced_mem;
|
|
slimb_t len, fft_len;
|
|
NTTLimb *buf1, *buf2, *ptr;
|
|
#if defined(USE_MUL_CHECK)
|
|
limb_t ha, hb, hr, h_ref;
|
|
#endif
|
|
|
|
if (ntt_static_init(s1))
|
|
return -1;
|
|
s = s1->ntt_state;
|
|
|
|
/* find the optimal number of digits per limb (dpl) */
|
|
len = a_len + b_len;
|
|
fft_len_log2 = bf_get_fft_size(&dpl, &nb_mods, len);
|
|
fft_len = (uint64_t)1 << fft_len_log2;
|
|
// printf("len=%" PRId64 " fft_len_log2=%d dpl=%d\n", len, fft_len_log2, dpl);
|
|
#if defined(USE_MUL_CHECK)
|
|
ha = mp_mod1(a_tab, a_len, BF_CHKSUM_MOD, 0);
|
|
hb = mp_mod1(b_tab, b_len, BF_CHKSUM_MOD, 0);
|
|
#endif
|
|
if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) == 0) {
|
|
if (!(mul_flags & FFT_MUL_R_NORESIZE))
|
|
bf_resize(res, 0);
|
|
} else if (mul_flags & FFT_MUL_R_OVERLAP_B) {
|
|
limb_t *tmp_tab, tmp_len;
|
|
/* it is better to free 'b' first */
|
|
tmp_tab = a_tab;
|
|
a_tab = b_tab;
|
|
b_tab = tmp_tab;
|
|
tmp_len = a_len;
|
|
a_len = b_len;
|
|
b_len = tmp_len;
|
|
}
|
|
buf1 = ntt_malloc(s, sizeof(NTTLimb) * fft_len * nb_mods);
|
|
if (!buf1)
|
|
return -1;
|
|
limb_to_ntt(s, buf1, fft_len, a_tab, a_len, dpl,
|
|
NB_MODS - nb_mods, nb_mods);
|
|
if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) ==
|
|
FFT_MUL_R_OVERLAP_A) {
|
|
if (!(mul_flags & FFT_MUL_R_NORESIZE))
|
|
bf_resize(res, 0);
|
|
}
|
|
reduced_mem = (fft_len_log2 >= 14);
|
|
if (!reduced_mem) {
|
|
buf2 = ntt_malloc(s, sizeof(NTTLimb) * fft_len * nb_mods);
|
|
if (!buf2)
|
|
goto fail;
|
|
limb_to_ntt(s, buf2, fft_len, b_tab, b_len, dpl,
|
|
NB_MODS - nb_mods, nb_mods);
|
|
if (!(mul_flags & FFT_MUL_R_NORESIZE))
|
|
bf_resize(res, 0); /* in case res == b */
|
|
} else {
|
|
buf2 = ntt_malloc(s, sizeof(NTTLimb) * fft_len);
|
|
if (!buf2)
|
|
goto fail;
|
|
}
|
|
for(j = 0; j < nb_mods; j++) {
|
|
if (reduced_mem) {
|
|
limb_to_ntt(s, buf2, fft_len, b_tab, b_len, dpl,
|
|
NB_MODS - nb_mods + j, 1);
|
|
ptr = buf2;
|
|
} else {
|
|
ptr = buf2 + fft_len * j;
|
|
}
|
|
if (ntt_conv(s, buf1 + fft_len * j, ptr,
|
|
fft_len_log2, fft_len_log2, j + NB_MODS - nb_mods))
|
|
goto fail;
|
|
}
|
|
if (!(mul_flags & FFT_MUL_R_NORESIZE))
|
|
bf_resize(res, 0); /* in case res == b and reduced mem */
|
|
ntt_free(s, buf2);
|
|
buf2 = NULL;
|
|
if (!(mul_flags & FFT_MUL_R_NORESIZE)) {
|
|
if (bf_resize(res, len))
|
|
goto fail;
|
|
}
|
|
ntt_to_limb(s, res->tab, len, buf1, fft_len_log2, dpl, nb_mods);
|
|
ntt_free(s, buf1);
|
|
#if defined(USE_MUL_CHECK)
|
|
hr = mp_mod1(res->tab, len, BF_CHKSUM_MOD, 0);
|
|
h_ref = mul_mod(ha, hb, BF_CHKSUM_MOD);
|
|
if (hr != h_ref) {
|
|
printf("ntt_mul_error: len=%" PRId_LIMB " fft_len_log2=%d dpl=%d nb_mods=%d\n",
|
|
len, fft_len_log2, dpl, nb_mods);
|
|
// printf("ha=0x" FMT_LIMB" hb=0x" FMT_LIMB " hr=0x" FMT_LIMB " expected=0x" FMT_LIMB "\n", ha, hb, hr, h_ref);
|
|
exit(1);
|
|
}
|
|
#endif
|
|
return 0;
|
|
fail:
|
|
ntt_free(s, buf1);
|
|
ntt_free(s, buf2);
|
|
return -1;
|
|
}
|
|
|
|
#else /* USE_FFT_MUL */
|
|
|
|
int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif /* !USE_FFT_MUL */
|