static void
check_large (void)
{
mpz_t z;
mpfr_t x, y;
mpfr_exp_t emax, emin;
mpz_init (z);
mpfr_init2 (x, 160);
mpfr_init2 (y, 160);
mpz_set_str (z, "77031627725494291259359895954016675357279104942148788042", 10);
mpfr_set_z (x, z, MPFR_RNDN);
mpfr_set_str_binary (y, "0.1100100100001111110110101010001000100001011010001100001000110100110001001100011001100010100010111000000011011100000111001101000100101001000000100100111000001001E186");
if (mpfr_cmp (x, y))
{
printf ("Error in mpfr_set_z on large input\n");
exit (1);
}
/* check overflow */
emax = mpfr_get_emax ();
set_emax (2);
mpz_set_str (z, "7", 10);
mpfr_set_z (x, z, MPFR_RNDU);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (3);
mpfr_set_prec (x, 2);
mpz_set_str (z, "7", 10);
mpfr_set_z (x, z, MPFR_RNDU);
MPFR_ASSERTN(mpfr_inf_p (x) && mpfr_sgn (x) > 0);
set_emax (emax);
/* check underflow */
emin = mpfr_get_emin ();
set_emin (3);
mpz_set_str (z, "1", 10);
mpfr_set_z (x, z, MPFR_RNDZ);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_POS(x));
set_emin (2);
mpfr_set_z (x, z, MPFR_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (x, 0) == 0 && MPFR_IS_POS(x));
set_emin (emin);
mpz_clear (z);
mpfr_clear (x);
mpfr_clear (y);
}
void
ovm_q_le(oregister_t *l, oregister_t *r)
{
l->t = t_word;
switch (r->t) {
case t_void:
l->v.w = mpq_sgn(oqr(l)) <= 0;
break;
case t_word:
l->v.w = mpq_cmp_si(oqr(l), r->v.w, 1) <= 0;
break;
case t_float:
l->v.w = mpq_get_d(oqr(l)) <= r->v.d;
break;
case t_mpz:
mpq_set_z(oqr(r), ozr(r));
l->v.w = mpq_cmp(oqr(l), oqr(r)) <= 0;
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
l->v.w = mpq_cmp(oqr(l), oqr(r)) <= 0;
break;
case t_mpq:
l->v.w = mpq_cmp(oqr(l), oqr(r)) <= 0;
break;
case t_mpr:
mpfr_set_z(orr(l), ozr(l), thr_rnd);
l->v.w = mpfr_lessequal_p(orr(l), orr(r));
break;
default:
ovm_raise(except_not_a_real_number);
}
}
/* test gamma on some integral values (from Christopher Creutzig). */
static void
gamma_integer (void)
{
mpz_t n;
mpfr_t x, y;
unsigned int i;
mpz_init (n);
mpfr_init2 (x, 149);
mpfr_init2 (y, 149);
for (i = 0; i < 100; i++)
{
mpz_fac_ui (n, i);
mpfr_set_ui (x, i+1, GMP_RNDN);
mpfr_gamma (y, x, GMP_RNDN);
mpfr_set_z (x, n, GMP_RNDN);
if (!mpfr_equal_p (x, y))
{
printf ("Error for gamma(%d)\n", i+1);
printf ("expected "); mpfr_dump (x);
printf ("got "); mpfr_dump (y);
exit (1);
}
}
mpfr_clear (y);
mpfr_clear (x);
mpz_clear (n);
}
/* Convert an mpz_t to an mpfr_exp_t, restricted to
the interval [MPFR_EXP_MIN,MPFR_EXP_MAX]. */
mpfr_exp_t
mpfr_ubf_zexp2exp (mpz_ptr ez)
{
mp_size_t n;
mpfr_eexp_t e;
mpfr_t d;
int inex;
MPFR_SAVE_EXPO_DECL (expo);
n = ABSIZ (ez); /* limb size of ez */
if (n == 0)
return 0;
MPFR_SAVE_EXPO_MARK (expo);
mpfr_init2 (d, n * GMP_NUMB_BITS);
MPFR_DBGRES (inex = mpfr_set_z (d, ez, MPFR_RNDN));
MPFR_ASSERTD (inex == 0);
e = mpfr_get_exp_t (d, MPFR_RNDZ);
mpfr_clear (d);
MPFR_SAVE_EXPO_FREE (expo);
if (MPFR_UNLIKELY (e < MPFR_EXP_MIN))
return MPFR_EXP_MIN;
if (MPFR_UNLIKELY (e > MPFR_EXP_MAX))
return MPFR_EXP_MAX;
return e;
}
/* set f to the rational q */
int
mpfr_set_q (mpfr_ptr f, mpq_srcptr q, mp_rnd_t rnd)
{
mpz_srcptr num, den;
mpfr_t n, d;
int inexact;
mp_prec_t prec;
MPFR_CLEAR_FLAGS (f);
num = mpq_numref (q);
if (mpz_cmp_ui (num, 0) == 0)
{
MPFR_SET_ZERO (f);
MPFR_SET_POS (f);
MPFR_RET (0);
}
den = mpq_denref (q);
mpfr_save_emin_emax ();
prec = mpz_sizeinbase (num, 2);
if (prec < MPFR_PREC_MIN)
prec = MPFR_PREC_MIN;
mpfr_init2 (n, prec);
if (mpfr_set_z (n, num, GMP_RNDZ)) /* result is exact unless overflow */
{
mpfr_clear (n);
mpfr_restore_emin_emax ();
MPFR_SET_NAN (f);
MPFR_RET_NAN;
}
prec = mpz_sizeinbase(den, 2);
if (prec < MPFR_PREC_MIN)
prec = MPFR_PREC_MIN;
mpfr_init2 (d, prec);
if (mpfr_set_z (d, den, GMP_RNDZ)) /* result is exact unless overflow */
{
mpfr_clear (d);
mpfr_clear (n);
mpfr_restore_emin_emax ();
MPFR_SET_NAN (f);
MPFR_RET_NAN;
}
inexact = mpfr_div (f, n, d, rnd);
mpfr_clear (n);
mpfr_clear (d);
MPFR_RESTORE_RET (inexact, f, rnd);
}
/**
* Wrapper function to find the log of a number of type mpz_t.
*/
void compute_logn(mpz_t rop, mpz_t n) {
mpfr_t tmp;
mpfr_init(tmp);
mpfr_set_z(tmp, n, MPFR_RNDN);
mpfr_log(tmp, tmp, MPFR_RNDN);
mpfr_get_z(rop, tmp, MPFR_RNDN);
mpfr_clear(tmp);
}
void printx(char *s, mpz_t x, int prec)
{
mpfr_t y;
mpfr_init2(y, 53);
mpfr_set_z(y, x, GMP_RNDN);
mpfr_div_2ui(y, y, prec, GMP_RNDN);
mpfr_printf("%s: %Rf\n", s, y);
mpfr_clear(y);
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("dlog....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz_t x;
mpz_t z;
mpfr_t r;
double y, w;
fmpz_init(x);
mpz_init(z);
mpfr_init2(r, 53);
fmpz_randtest_not_zero(x, state, 10000);
fmpz_abs(x, x);
y = fmpz_dlog(x);
fmpz_get_mpz(z, x);
mpfr_set_z(r, z, MPFR_RNDN);
mpfr_log(r, r, MPFR_RNDN);
w = mpfr_get_d(r, MPFR_RNDN);
result = (FLINT_ABS(y - w) <= w * 1e-13);
if (!result)
{
printf("FAIL:\n");
printf("x = "), fmpz_print(x), printf("\n");
printf("y = %.20g\n", y);
printf("w = %.20g\n", w);
abort();
}
fmpz_clear(x);
mpz_clear(z);
mpfr_clear(r);
}
mpfr_free_cache();
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
static void
check_one (mpz_ptr z)
{
int inex;
int sh, neg;
mpfr_t f;
mpz_t got;
mpfr_init2 (f, MAX( mpz_sizeinbase (z, 2), MPFR_PREC_MIN) );
mpz_init (got);
for (sh = -2*GMP_NUMB_BITS ; sh < 2*GMP_NUMB_BITS ; sh++)
{
for (neg = 0; neg <= 1; neg++)
{
mpz_neg (z, z);
mpfr_set_z (f, z, MPFR_RNDN);
if (sh < 0)
{
mpz_tdiv_q_2exp (z, z, -sh);
mpfr_div_2exp (f, f, -sh, MPFR_RNDN);
}
else
{
mpz_mul_2exp (z, z, sh);
mpfr_mul_2exp (f, f, sh, MPFR_RNDN);
}
inex = mpfr_get_z (got, f, MPFR_RNDZ);
if (mpz_cmp (got, z) != 0)
{
printf ("Wrong result for shift=%d\n", sh);
printf (" f "); mpfr_dump (f);
printf (" got "); mpz_dump (got);
printf (" want "); mpz_dump (z);
exit (1);
}
if (! SAME_SIGN (inex, - mpfr_cmp_z (f, z)))
{
printf ("Wrong inexact value for shift=%d\n", sh);
printf (" f "); mpfr_dump (f);
printf (" got %+d\n", inex);
printf (" want %+d\n", -mpfr_cmp_z (f, z));
exit (1);
}
}
}
mpfr_clear (f);
mpz_clear (got);
}
/**
* Wrapper function to find the square of the log of a number of type mpz_t.
*/
void compute_logn2(mpz_t rop, mpz_t n) {
mpfr_t tmp;
mpfr_init(tmp);
mpfr_set_z(tmp, n, MPFR_RNDN);
mpfr_log(tmp, tmp, MPFR_RNDA);
mpfr_pow_ui(tmp, tmp, 2, MPFR_RNDA);
mpfr_ceil(tmp, tmp);
mpfr_get_z(rop, tmp, MPFR_RNDA);
mpfr_clear(tmp);
}
void _arith_euler_number_zeta(fmpz_t res, ulong n)
{
mpz_t r;
mpfr_t t, z, pi;
mp_bitcnt_t prec, pi_prec;
if (n % 2)
{
fmpz_zero(res);
return;
}
if (n < SMALL_EULER_LIMIT)
{
fmpz_set_ui(res, euler_number_small[n / 2]);
if (n % 4 == 2)
fmpz_neg(res, res);
return;
}
prec = arith_euler_number_size(n) + 10;
pi_prec = prec + FLINT_BIT_COUNT(n);
mpz_init(r);
mpfr_init2(t, prec);
mpfr_init2(z, prec);
mpfr_init2(pi, pi_prec);
flint_mpz_fac_ui(r, n);
mpfr_set_z(t, r, GMP_RNDN);
mpfr_mul_2exp(t, t, n + 2, GMP_RNDN);
/* pi^(n + 1) * L(n+1) */
mpfr_zeta_inv_euler_product(z, n + 1, 1);
mpfr_const_pi(pi, GMP_RNDN);
mpfr_pow_ui(pi, pi, n + 1, GMP_RNDN);
mpfr_mul(z, z, pi, GMP_RNDN);
mpfr_div(t, t, z, GMP_RNDN);
/* round */
mpfr_round(t, t);
mpfr_get_z(r, t, GMP_RNDN);
fmpz_set_mpz(res, r);
if (n % 4 == 2)
fmpz_neg(res, res);
mpz_clear(r);
mpfr_clear(t);
mpfr_clear(z);
mpfr_clear(pi);
}
static VALUE r_gmpz_to_fr(int argc, VALUE *argv, VALUE self)
{
mp_rnd_t rnd;
mp_prec_t prec;
MP_INT *ptr_self;
VALUE ptr_return;
MPFR *ptr_mpfr;
r_mpfr_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
mpz_get_struct(self, ptr_self);
r_mpfr_make_struct_init2(ptr_return, ptr_mpfr, prec);
mpfr_set_z(ptr_mpfr, ptr_self, rnd);
return ptr_return;
}
void tostring ()
{
int i;
char sstr[20000];
tempstring = g_string_new(NULL);
uarray = g_array_index (intervals, GArray *, 0);
if (uarray->len!=0) //EMPTY INTERVAL LOOP
{
for (i=0; i<=uarray->len-1; i++)
{
temp1 = g_array_index (uarray, struct interval, i);
if (temp1.openleft == TRUE) {g_string_append(tempstring,"]");} else {g_string_append(tempstring,"[");}
if (mpz_cmp (&temp1.left, &ocon1e100) == 0) {g_string_append(tempstring,"-inf");} else
{
mpfr_set_z (&temp, &temp1.left, 0);
mpfr_div (&temp, &temp, &con1e30, 0);
mpfr_sprintf(sstr, "%.30RNf", &temp);
g_string_append(tempstring,sstr);
};
g_string_append(tempstring,";");
if (mpz_cmp (&temp1.right, &pcon1e100) == 0) {g_string_append(tempstring,"+inf");} else
{
mpfr_set_z (&temp, &temp1.right, 0);
mpfr_div (&temp, &temp, &con1e30, 0);
mpfr_sprintf(sstr, "%.30RNf", &temp);
g_string_append(tempstring,sstr);
};
if (temp1.openright == TRUE) {g_string_append(tempstring,"[");} else {g_string_append(tempstring,"]");}
if (i!=uarray->len-1) {g_string_append(tempstring,"U"); }
}
} //EMPTY INTERVAL LOOP
else
{
static Obj MPD_INT(Obj self, Obj i)
{
Obj g;
if (IS_INTOBJ(i)) {
g = NEW_MPD(8*sizeof(long));
mpd_set_si(MPD_OBJ(g), INT_INTOBJ(i), MPD_RNDNN);
} else {
Obj f = MPZ_LONGINT(i);
g = NEW_MPD(8*sizeof(mp_limb_t)*SIZE_INT(i));
mpfr_set_z(MPD_OBJ(g)->re, mpz_MPZ(f), GMP_RNDN);
mpfr_set_ui(MPD_OBJ(g)->im, 0, GMP_RNDN);
}
return g;
}
/* computes S(n) = sum(n^k*(-1)^(k-1)/k!/k, k=1..ceil(4.319136566 * n))
using binary splitting.
We have S(n) = sum(f(k), k=1..N) with N=ceil(4.319136566 * n)
and f(k) = n^k*(-1)*(k-1)/k!/k,
thus f(k)/f(k-1) = -n*(k-1)/k^2
*/
static void
mpfr_const_euler_S2 (mpfr_t x, unsigned long n)
{
mpz_t P, Q, T;
unsigned long N = (unsigned long) (ALPHA * (double) n + 1.0);
mpz_init (P);
mpz_init (Q);
mpz_init (T);
mpfr_const_euler_S2_aux (P, Q, T, n, 1, N + 1, 0);
mpfr_set_z (x, T, MPFR_RNDN);
mpfr_div_z (x, x, Q, MPFR_RNDN);
mpz_clear (P);
mpz_clear (Q);
mpz_clear (T);
}
/* computes R(n) = exp(-n)/n * sum(k!/(-n)^k, k=0..n-2)
with error at most 4*ulp(x). Assumes n>=2.
Since x <= exp(-n)/n <= 1/8, then 4*ulp(x) <= ulp(1).
*/
static void
mpfr_const_euler_R (mpfr_t x, unsigned long n)
{
unsigned long k, m;
mpz_t a, s;
mpfr_t y;
MPFR_ASSERTN (n >= 2); /* ensures sum(k!/(-n)^k, k=0..n-2) >= 2/3 */
/* as we multiply the sum by exp(-n), we need only PREC(x) - n/LOG2 bits */
m = MPFR_PREC(x) - (unsigned long) ((double) n / LOG2);
mpz_init_set_ui (a, 1);
mpz_mul_2exp (a, a, m);
mpz_init_set (s, a);
for (k = 1; k <= n; k++)
{
mpz_mul_ui (a, a, k);
mpz_fdiv_q_ui (a, a, n);
/* the error e(k) on a is e(k) <= 1 + k/n*e(k-1) with e(0)=0,
i.e. e(k) <= k */
if (k % 2)
mpz_sub (s, s, a);
else
mpz_add (s, s, a);
}
/* the error on s is at most 1+2+...+n = n*(n+1)/2 */
mpz_fdiv_q_ui (s, s, n); /* err <= 1 + (n+1)/2 */
MPFR_ASSERTN (MPFR_PREC(x) >= mpz_sizeinbase(s, 2));
mpfr_set_z (x, s, MPFR_RNDD); /* exact */
mpfr_div_2ui (x, x, m, MPFR_RNDD);
/* now x = 1/n * sum(k!/(-n)^k, k=0..n-2) <= 1/n */
/* err(x) <= (n+1)/2^m <= (n+1)*exp(n)/2^PREC(x) */
mpfr_init2 (y, m);
mpfr_set_si (y, -(long)n, MPFR_RNDD); /* assumed exact */
mpfr_exp (y, y, MPFR_RNDD); /* err <= ulp(y) <= exp(-n)*2^(1-m) */
mpfr_mul (x, x, y, MPFR_RNDD);
/* err <= ulp(x) + (n + 1 + 2/n) / 2^prec(x)
<= ulp(x) + (n + 1 + 2/n) ulp(x)/x since x*2^(-prec(x)) < ulp(x)
<= ulp(x) + (n + 1 + 2/n) 3/(2n) ulp(x) since x >= 2/3*n for n >= 2
<= 4 * ulp(x) for n >= 2 */
mpfr_clear (y);
mpz_clear (a);
mpz_clear (s);
}
static void
test_int (void)
{
unsigned long n0 = 1, n1 = 80, n;
mpz_t f;
mpfr_t x, y;
mp_prec_t prec_f, p;
int r;
int inex1, inex2;
mpz_init (f);
mpfr_init (x);
mpfr_init (y);
mpz_fac_ui (f, n0 - 1);
for (n = n0; n <= n1; n++)
{
mpz_mul_ui (f, f, n); /* f = n! */
prec_f = mpz_sizeinbase (f, 2) - mpz_scan1 (f, 0);
for (p = MPFR_PREC_MIN; p <= prec_f; p++)
{
mpfr_set_prec (x, p);
mpfr_set_prec (y, p);
for (r = 0; r < GMP_RND_MAX; r++)
{
inex1 = mpfr_fac_ui (x, n, (mp_rnd_t) r);
inex2 = mpfr_set_z (y, f, (mp_rnd_t) r);
if (mpfr_cmp (x, y))
{
printf ("Error for n=%lu prec=%lu rnd=%s\n",
n, (unsigned long) p, mpfr_print_rnd_mode ((mp_rnd_t) r));
exit (1);
}
if ((inex1 < 0 && inex2 >= 0) || (inex1 == 0 && inex2 != 0)
|| (inex1 > 0 && inex2 <= 0))
{
printf ("Wrong inexact flag for n=%lu prec=%lu rnd=%s\n",
n, (unsigned long) p, mpfr_print_rnd_mode ((mp_rnd_t) r));
exit (1);
}
}
}
}
mpz_clear (f);
mpfr_clear (x);
mpfr_clear (y);
}
APLVFP PrimFnMonQuoteDotVisV
(APLVFP aplVfpRht,
LPPRIMSPEC lpPrimSpec)
{
APLMPI mpzRes = {0};
APLVFP mpfRes = {0};
// Check for indeterminates: !N for integer N < 0
if (mpfr_integer_p (&aplVfpRht)
&& mpfr_cmp_ui (&aplVfpRht, 0) < 0)
return *mpfr_QuadICValue (&aplVfpRht, // No left arg
ICNDX_QDOTn,
&aplVfpRht,
&mpfRes,
FALSE);
// Check for PosInfinity
if (IsMpfPosInfinity (&aplVfpRht))
return mpfPosInfinity;
// If the arg is an integer,
// and it fits in a ULONG, ...
if (mpfr_integer_p (&aplVfpRht)
&& mpfr_fits_uint_p (&aplVfpRht, MPFR_RNDN))
{
mpz_init (&mpzRes);
mpfr_init0 (&mpfRes);
mpz_fac_ui (&mpzRes, mpfr_get_ui (&aplVfpRht, MPFR_RNDN));
mpfr_set_z (&mpfRes, &mpzRes, MPFR_RNDN);
Myz_clear (&mpzRes);
} else
{
// Initialize the result
mpfr_init_set (&mpfRes, &aplVfpRht, MPFR_RNDN);
mpfr_add_ui (&mpfRes, &mpfRes, 1, MPFR_RNDN);
// Let MPFR handle it
mpfr_gamma (&mpfRes, &mpfRes, MPFR_RNDN);
#ifdef DEBUG
mpfr_free_cache ();
#endif
} // End IF/ELSE
return mpfRes;
} // End PrimFnMonQuoteDotVisV
//-----------------------------------------------------------
// base <- exp((1/2) sqrt(ln(n) ln(ln(n))))
//-----------------------------------------------------------
void get_smoothness_base(mpz_t base, mpz_t n) {
mpfr_t fN, lnN, lnlnN;
mpfr_init(fN), mpfr_init(lnN), mpfr_init(lnlnN);
mpfr_set_z(fN, n, MPFR_RNDU);
mpfr_log(lnN, fN, MPFR_RNDU);
mpfr_log(lnlnN, lnN, MPFR_RNDU);
mpfr_mul(fN, lnN, lnlnN, MPFR_RNDU);
mpfr_sqrt(fN, fN, MPFR_RNDU);
mpfr_div_ui(fN, fN, 2, MPFR_RNDU);
mpfr_exp(fN, fN, MPFR_RNDU);
mpfr_get_z(base, fN, MPFR_RNDU);
mpfr_clears(fN, lnN, lnlnN, NULL);
}
__inline__ static void
log2_L2_norm_4arg(mpfr_t tgt, const mpz_square_mat_t A, slong k, slong n)
// log2(L2 norm) rounded down. tgt initialized by caller
{
mpz_t norm; mpz_init(norm);
slong i;
square_L2_mpz(norm,A->rows[k],n);
i=mpz_size(norm);
if(i>2)
i=2;
mpfr_t normF; mpfr_init2(normF,i*FLINT_BITS);
mpfr_set_z(normF,norm,MPFR_RNDU);
mpz_clear(norm);
mpfr_log2(tgt, normF, MPFR_RNDU);
mpfr_div_ui(tgt,tgt,2,MPFR_RNDU);
mpfr_clear(normF);
}
static Obj MPD_INTPREC(Obj self, Obj i, Obj prec)
{
Obj g;
TEST_IS_INTOBJ("MPD_INTPREC",prec);
if (IS_INTOBJ(i)) {
g = NEW_MPD(INT_INTOBJ(prec));
mpd_set_si(MPD_OBJ(g), INT_INTOBJ(i), MPD_RNDNN);
} else {
Obj f = MPZ_LONGINT(i);
g = NEW_MPD(INT_INTOBJ(prec));
mpfr_set_z(MPD_OBJ(g)->re, mpz_MPZ(f), GMP_RNDN);
mpfr_set_ui(MPD_OBJ(g)->im, 0, GMP_RNDN);
}
return g;
}
static void
check (long i, mpfr_rnd_t rnd)
{
mpfr_t f;
mpz_t z;
mpfr_init2 (f, 8 * sizeof(long));
mpz_init (z);
mpz_set_ui (z, i);
mpfr_set_z (f, z, rnd);
if (mpfr_get_si (f, MPFR_RNDZ) != i)
{
printf ("Error in mpfr_set_z for i=%ld rnd_mode=%d\n", i, rnd);
exit (1);
}
mpfr_clear (f);
mpz_clear (z);
}
static void
check_one (mpz_ptr z)
{
int sh, neg;
mpfr_t f;
mpz_t got;
mpfr_init2 (f, MAX( mpz_sizeinbase (z, 2), MPFR_PREC_MIN) );
mpz_init (got);
for (sh = -2*BITS_PER_MP_LIMB ; sh < 2*BITS_PER_MP_LIMB ; sh++)
{
for (neg = 0; neg <= 1; neg++)
{
mpz_neg (z, z);
mpfr_set_z (f, z, GMP_RNDN);
if (sh < 0)
{
mpz_tdiv_q_2exp (z, z, -sh);
mpfr_div_2exp (f, f, -sh, GMP_RNDN);
}
else
{
mpz_mul_2exp (z, z, sh);
mpfr_mul_2exp (f, f, sh, GMP_RNDN);
}
mpfr_get_z (got, f, GMP_RNDZ);
if (mpz_cmp (got, z) != 0)
{
printf ("Wrong result for shift=%d\n", sh);
printf (" f "); mpfr_dump (f);
printf (" got "); mpz_dump (got);
printf (" want "); mpz_dump (z);
exit (1);
}
}
}
mpfr_clear (f);
mpz_clear (got);
}
int
gghlite_enc_is_zero(const gghlite_params_t self, const fmpz_mod_poly_t op)
{
gghlite_clr_t t;
mpfr_t norm, bound;
int r;
gghlite_clr_init(t);
_gghlite_enc_extract_raw(t, self, op);
mpfr_init2(norm, _gghlite_prec(self));
mpfr_init2(bound, _gghlite_prec(self));
fmpz_poly_2norm_mpfr(norm, t, MPFR_RNDN);
{
/* Set bound = q */
mpz_t q_z;
mpz_init(q_z);
fmpz_get_mpz(q_z, self->q);
mpfr_set_z(bound, q_z, MPFR_RNDN);
mpz_clear(q_z);
}
{
/* compute q^{1-xi} */
mpfr_t ex;
mpfr_init2(ex, _gghlite_prec(self));
mpfr_set_ui(ex, 1, MPFR_RNDN);
mpfr_sub(ex, ex, self->xi, MPFR_RNDN);
mpfr_pow(bound, bound, ex, MPFR_RNDN);
mpfr_clear(ex);
}
r = mpfr_cmp(norm, bound);
mpfr_clear(bound);
mpfr_clear(norm);
gghlite_clr_clear(t);
if (r <= 0)
return 1;
else
return 0;
}
void HOTBM::emulate(TestCase* tc)
{
/* Get inputs / outputs */
mpz_class sx = tc->getInputValue ("X");
// int outSign = 0;
mpfr_t mpX, mpR;
mpfr_inits(mpX, mpR, 0, NULL);
/* Convert a random signal to an mpfr_t in [0,1[ */
mpfr_set_z(mpX, sx.get_mpz_t(), GMP_RNDN);
mpfr_div_2si(mpX, mpX, wI, GMP_RNDN);
/* Compute the function */
f.eval(mpR, mpX);
/* Compute the signal value */
if (mpfr_signbit(mpR))
{
// outSign = 1;
mpfr_abs(mpR, mpR, GMP_RNDN);
}
mpfr_mul_2si(mpR, mpR, wO, GMP_RNDN);
/* NOT A TYPO. HOTBM only guarantees faithful
* rounding, so we will round down here,
* add both the upper and lower neighbor.
*/
mpz_t rd_t;
mpz_init (rd_t);
mpfr_get_z(rd_t, mpR, GMP_RNDD);
mpz_class rd (rd_t), ru = rd + 1;
tc->addExpectedOutput ("R", rd);
tc->addExpectedOutput ("R", ru);
mpz_clear (rd_t);
mpfr_clear (mpX);
mpfr_clear (mpR);
}
/*Function to precompute all binomial coefficients
inpdf:
mpz_bin_ui(bcnum,n,i);
hypergeometricpdf:
mpz_bin_ui(bc_beta_active_inputs,beta,ai_cnt);
mpz_bin_ui(bc_sub,mu_sub_beta,di-ai_cnt);
mpz_bin_ui(bc_mu_d,mu,di);
uniquecodes:
mpz_bin_ui(bcnum,n,i);
scjoint:
mpz_bin_ui(bc_gamma_sy,gamp,(unsigned long int)sy);
1) mu,sx;
2) gamma,sy;
3) mu,d; (always subset of 1)
4) mu_sub_beta,di-ai_cnt; (for all mu, find all coeffs for
less than or equal to d draws)
5) beta,ai_cnt; (always a subset of 2)
Function finds binomial coefficient for all (N,m) between Nini,
Nend and mini mend. Wrties to mpfr variables. */
void tabulate_bins_fr(mpfr_t *bcs, int Nini, int Nend, int mini, int mend, mpfr_prec_t prec)
{
int N;
int m;
int done=mend-mini+1;
mpz_t bc;
mpz_init(bc);
mpz_t Nz;
mpz_init(Nz);
for(N=Nini;N<=Nend;N++)
{
mpz_set_ui(Nz,N);
for(m=mini;m<=mend;m++)
{
mpz_bin_ui(bc,Nz,m);
mpfr_set_z(*(bcs+(N-Nini)*done+(m-mini)),bc,MPFR_RNDN);
}
}
mpz_clear(bc);
mpz_clear(Nz);
}
num_t
num_new_fp(int flags, num_t b)
{
num_t r;
r = num_new(flags);
r->num_type = NUM_FP;
mpfr_init(F(r));
if (b != NULL) {
mpfr_prec_t prec_b = num_prec(b);
if (prec_b > mpfr_get_default_prec())
mpfr_set_prec(F(r), prec_b);
if (b->num_type == NUM_INT)
mpfr_set_z(F(r), Z(b), round_mode);
else if (b->num_type == NUM_FP)
mpfr_set(F(r), F(b), round_mode);
}
return r;
}
void MathUtils::GetSmoothnessBase(mpz_class& ret_base, mpz_class& N)
{
mpfr_t f_N, log_N, log_log_N;
mpz_t base_mpz;
mpz_init(base_mpz);
mpfr_init(f_N); mpfr_init(log_N); mpfr_init(log_log_N);
mpfr_set_z(f_N, N.get_mpz_t(), MPFR_RNDU); //f_N = N
mpfr_log(log_N, f_N, MPFR_RNDU); //log_N = log(N)
mpfr_log(log_log_N, log_N, MPFR_RNDU); //log_log_N = log(log(N))
mpfr_mul(f_N, log_N, log_log_N, MPFR_RNDU); //f_N = log(N) * log(log(N))
mpfr_sqrt(f_N, f_N, MPFR_RNDU); //f_N = sqrt(f_N)
mpfr_div_ui(f_N, f_N, 2, MPFR_RNDU); //f_N = f_N/2
mpfr_exp(f_N, f_N, MPFR_RNDU); //f_N = e^f_N
mpfr_get_z(base_mpz, f_N, MPFR_RNDU);
ret_base = mpz_class(base_mpz);
mpfr_clears(f_N, log_N, log_log_N, NULL);
}
static void check0(void)
{
mpz_t y;
mpfr_t x;
int inexact, r;
/* Check for +0 */
mpfr_init (x);
mpz_init (y);
mpz_set_si (y, 0);
for(r = 0; r < MPFR_RND_MAX; r++)
{
inexact = mpfr_set_z (x, y, (mpfr_rnd_t) r);
if (!MPFR_IS_ZERO(x) || !MPFR_IS_POS(x) || inexact)
{
printf("mpfr_set_z(x,0) failed for %s\n",
mpfr_print_rnd_mode ((mpfr_rnd_t) r));
exit(1);
}
}
mpfr_clear(x);
mpz_clear(y);
}
int dgsl_mp_call_coset(fmpz *rop, const dgsl_mp_t *self, gmp_randstate_t state) {
assert(rop); assert(self);
const long n = fmpz_mat_ncols(self->B);
_fmpz_vec_zero(rop, n);
mpfr_t *c = _mpfr_vec_init(n, mpfr_get_prec(self->sigma));
_mpfr_vec_set(c, self->c, n, MPFR_RNDN);
mpfr_t c_prime;
mpfr_init2(c_prime, mpfr_get_prec(self->sigma));
mpfr_t tmp;
mpfr_init2(tmp, mpfr_get_prec(self->sigma));
mpfr_t sigma_prime;
mpfr_init2(sigma_prime, mpfr_get_prec(self->sigma));
mpz_t z;
mpz_init(z);
mpfr_t z_mpfr;
mpfr_init2(z_mpfr, mpfr_get_prec(self->sigma));
fmpz_t z_fmpz;
fmpz_init(z_fmpz);
size_t tau = 3;
if (ceil(sqrt(log2((double)n))) > tau)
tau = ceil(sqrt(log2((double)n)));
mpfr_t *b = _mpfr_vec_init(n, mpfr_get_prec(self->sigma));
const long m = fmpz_mat_nrows(self->B);
for(long j=0; j<m; j++) {
long i = m-j-1;
_mpfr_vec_dot_product(c_prime, c, self->G->rows[i], n, MPFR_RNDN);
_mpfr_vec_dot_product(tmp, self->G->rows[i], self->G->rows[i], n, MPFR_RNDN);
mpfr_div(c_prime, c_prime, tmp, MPFR_RNDN);
mpfr_sqrt(tmp, tmp, MPFR_RNDN);
mpfr_div(sigma_prime, self->sigma, tmp, MPFR_RNDN);
assert(mpfr_cmp_d(sigma_prime, 0.0) > 0);
dgs_disc_gauss_mp_t *D = dgs_disc_gauss_mp_init(sigma_prime, c_prime, tau, DGS_DISC_GAUSS_UNIFORM_ONLINE);
D->call(z, D, state);
dgs_disc_gauss_mp_clear(D);
mpfr_set_z(z_mpfr, z, MPFR_RNDN);
mpfr_neg(z_mpfr, z_mpfr, MPFR_RNDN);
_mpfr_vec_set_fmpz_vec(b, self->B->rows[i], n, MPFR_RNDN);
_mpfr_vec_scalar_addmul_mpfr(c, b, n, z_mpfr, MPFR_RNDN);
fmpz_set_mpz(z_fmpz, z);
_fmpz_vec_scalar_addmul_fmpz(rop, self->B->rows[i], n, z_fmpz);
}
fmpz_clear(z_fmpz);
mpfr_clear(z_mpfr);
mpfr_clear(sigma_prime);
mpfr_clear(tmp);
mpfr_clear(c_prime);
_mpfr_vec_clear(c, n);
_mpfr_vec_clear(b, n);
return 0;
}
