static void precision_clear(void) {
mpf_clear(eulere);
mpf_clear(recipeulere);
mpf_clear(pi);
mpf_clear(epsilon);
mpf_clear(negepsilon);
}
static void mpf_exp(mpf_t res, mpf_t pwr) {
mpf_t a;
mpf_t f0;
int i;
mpf_init(a); mpf_set(a, pwr);
mpf_init(f0);
mpf_set(f0, a);
mpf_add_ui(res, a, 1);
for (i=2;;i++) {
mpf_mul(f0, f0, a);
mpf_div_ui(f0, f0, i);
if (mpf_sgn(f0) > 0) {
if (mpf_cmp(f0, epsilon) < 0) break;
} else {
if (mpf_cmp(f0, negepsilon) > 0) break;
}
mpf_add(res, res, f0);
}
mpf_clear(f0);
mpf_clear(a);
}
void
check_various (void)
{
mpf_t got, u, v;
mpf_init (got);
mpf_init (u);
mpf_init (v);
/* 100/4 == 25 */
mpf_set_prec (got, 20L);
mpf_set_ui (u, 100L);
mpf_set_ui (v, 4L);
mpf_div (got, u, v);
MPF_CHECK_FORMAT (got);
ASSERT_ALWAYS (mpf_cmp_ui (got, 25L) == 0);
/* 1/(2^n+1), a case where truncating the divisor would be wrong */
mpf_set_prec (got, 500L);
mpf_set_prec (v, 900L);
mpf_set_ui (v, 1L);
mpf_mul_2exp (v, v, 800L);
mpf_add_ui (v, v, 1L);
mpf_div (got, u, v);
check_one ("1/2^n+1, separate", got, u, v);
mpf_clear (got);
mpf_clear (u);
mpf_clear (v);
}
/**
* rasqal_xsd_decimal_round:
* @result: result variable
* @a: argment decimal
*
* Return the number with no fractional part closes to argument for an XSD Decimal
*
* Return value: non-0 on failure
**/
int
rasqal_xsd_decimal_round(rasqal_xsd_decimal* result, rasqal_xsd_decimal* a)
{
int rc = 0;
#ifdef RASQAL_DECIMAL_GMP
mpf_t b;
mpf_t c;
#endif
rasqal_xsd_decimal_clear_string(result);
#if defined(RASQAL_DECIMAL_C99) || defined(RASQAL_DECIMAL_NONE)
result->raw = round(a->raw);
#endif
#ifdef RASQAL_DECIMAL_MPFR
mpfr_round(result->raw, a->raw);
#endif
#ifdef RASQAL_DECIMAL_GMP
/* GMP has no mpf_round so use result := floor(a + 0.5) */
mpf_init2(b, a->precision_bits);
mpf_init2(c, a->precision_bits);
mpf_set_d(b, 0.5);
mpf_add(c, a->raw, b);
mpf_floor(result->raw, c);
mpf_clear(b);
mpf_clear(c);
#endif
return rc;
}
void extrapolate(index_t num_samples, mpf_t *samples, mpf_t ans) {
// The Richardson extrapolation recursive formula is
//
// A_n+1(x) = (2^n A_n(2x) - A_n(x)) / (2^n - 1)
mpf_t mult; // mult = 2^n
mpf_init_set_d(mult, 1);
mpf_t denom; // denom = 1 / (mult - 1)
mp_bitcnt_t precision = mpf_get_prec(ans);
mpf_init2(denom, precision);
mpf_t *end = samples + num_samples;
for (mpf_t *lim = samples; lim < end; lim++) { // lim - samples = n
mpf_mul_ui(mult, mult, 2);
mpf_set(denom, mult);
mpf_sub_ui(denom, denom, 1);
mpf_ui_div(denom, 1, denom);
// evaluate all extrapolations
for (mpf_t *ptr = end; --ptr > lim; ) {
// A_n+1(x) = (mult A_n(2x) - A_n(x)) * denom
mpf_mul(*ptr, *ptr, mult);
mpf_sub(*ptr, *ptr, *(ptr - 1));
mpf_mul(*ptr, *ptr, denom);
}
}
mpf_set(ans, *(end - 1)); // move to ans
// Clean
mpf_clear(mult);
mpf_clear(denom);
}
static void destructor(render_t* handle)
{
mpf_clear(handle->center.real_part);
mpf_clear(handle->center.imaginary_part);
mpf_clear(handle->scale);
free(handle);
}
void my_clear()
{
mpf_clear(t1);
mpf_clear(t2);
mpf_clear(d1);
mpf_clear(d2);
}
/*
* Evaluate the series 1/0! + 1/1! + 1/2! + 1/3! + 1/4! ...
* On input, 'bits' is the desired precision in bits.
* On output, e' contains the calculated value.
*/
static void calculateE(
unsigned bits,
mpf_t e)
{
mpf_t lastE;
mpf_t invFact; /* 1/2!, 1/3!, 1/4!, etc. */
unsigned term; /* 2, 3, 4... */
/* initial conditions, including the first two terms */
mpf_init_set_ui(lastE, 0);
mpf_set_ui(e, 2);
mpf_init_set_ui(invFact, 1); /* 1/1! */
term = 2;
for(;;) {
/* invFact /= (term) */
mpf_div_ui(invFact, invFact, term);
/* e += 1 / (term!) */
mpf_add(e, e, invFact);
/* if e == lastE, within the requested precision, we're done */
if(mpf_eq(e, lastE, bits)) {
break;
}
mpf_set(lastE, e);
term++;
}
/* free memory associated with mpf_t's we allocated */
mpf_clear(lastE);
mpf_clear(invFact);
}
void freeMem() {
stopThreads();
mpf_clear(mandelRange.minRe);
mpf_clear(mandelRange.maxRe);
mpf_clear(mandelRange.minIm);
mpf_clear(mandelRange.maxIm);
cleanMemory();
}
void
check_rand (void)
{
unsigned long min_prec = __GMPF_BITS_TO_PREC (1);
gmp_randstate_t rands;
mpf_t got, u;
unsigned long prec, v;
int i;
/* The nails code in mpf_mul_ui currently isn't exact, so suppress these
tests for now. */
if (BITS_PER_UI > GMP_NUMB_BITS)
return;
mpf_init (got);
mpf_init (u);
gmp_randinit_default(rands);
for (i = 0; i < 200; i++)
{
/* got precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (got, prec);
/* u precision */
prec = min_prec + gmp_urandomm_ui (rands, 15L);
refmpf_set_prec_limbs (u, prec);
/* u, possibly negative */
mpf_rrandomb (u, rands, PREC(u), (mp_exp_t) 20);
if (gmp_urandomb_ui (rands, 1L))
mpf_neg (u, u);
/* v, 0 to BITS_PER_ULONG bits (inclusive) */
prec = gmp_urandomm_ui (rands, BITS_PER_ULONG+1);
v = gmp_urandomb_ui (rands, prec);
if ((i % 2) == 0)
{
/* separate */
mpf_mul_ui (got, u, v);
check_one ("separate", got, u, v);
}
else
{
/* overlap */
prec = refmpf_set_overlap (got, u);
mpf_mul_ui (got, got, v);
check_one ("overlap src==dst", got, u, v);
mpf_set_prec_raw (got, prec);
}
}
mpf_clear (got);
mpf_clear (u);
gmp_randclear(rands);
}
void mpfr_bench(mpfr_prec_t prec_a, mpfr_prec_t prec_b, mpfr_prec_t prec_c,
const char *b_str, const char *c_str, unsigned long seed)
{
mpfr_t a,b,c;
mpf_t x,y,z;
mpz_t zz;
gmp_randstate_t state;
gmp_randinit_lc_2exp_size (state, 128);
gmp_randseed_ui (state, seed);
mpfr_init2(a, prec_a);
mpfr_init2(b, prec_b);
mpfr_init2(c, prec_c);
mpf_init2(x, prec_a);
mpf_init2(y, prec_b);
mpf_init2(z, prec_c);
if (b_str)
mpf_set_str(y, b_str, 10);
else
mpf_urandomb(y, state, prec_b);
if (c_str)
mpf_set_str(z, c_str, 10);
else
mpf_urandomb(z, state, prec_c);
mpfr_set_f(b, y, MPFR_RNDN);
mpfr_set_f(c, z, MPFR_RNDN);
mpz_init (zz);
mpz_urandomb (zz, state, 2*prec_b);
if (verbose)
{
printf("B="); mpfr_out_str(stdout, 10, 0, b, MPFR_RNDD);
printf("\nC="); mpfr_out_str(stdout, 10, 0, c, MPFR_RNDD);
putchar('\n');
}
TIMP_OVERHEAD ();
#undef BENCH
#define BENCH(TEST_STR, TEST) printf(" "TEST_STR": %Lu\n", TIMP_MEASURE(TEST))
TEST_LIST;
mpz_clear (zz);
mpfr_clear (a);
mpfr_clear (b);
mpfr_clear (c);
mpf_clear (x);
mpf_clear (y);
mpf_clear (z);
gmp_randclear (state);
}
/**
* @brief Print a float to stdout (or whatever the output stream is
* atm) respecting the given options, and only with the significant
* digits.
*
* @param s A pointer to the current mps_context.
* @param f The float approximation that should be printed.
* @param rad The current inclusion radius for that approximation.
* @param out_digit The number of output digits required.
* @param sign The sign of the approximation.
*/
MPS_PRIVATE void
mps_outfloat (mps_context * s, mpf_t f, rdpe_t rad, long out_digit,
mps_boolean sign)
{
mpf_t t;
rdpe_t r, ro;
double d;
long l, digit, true_digit;
if (s->output_config->format == MPS_OUTPUT_FORMAT_FULL)
{
mpf_init2 (t, mpf_get_prec (f));
mpf_set (t, f);
mpf_out_str (s->outstr, 10, 0, t);
mpf_clear (t);
return;
}
mpf_init2 (t, s->output_config->prec);
mpf_get_rdpe (ro, f);
if (s->output_config->format == MPS_OUTPUT_FORMAT_GNUPLOT ||
s->output_config->format == MPS_OUTPUT_FORMAT_GNUPLOT_FULL)
rdpe_out_str_u (s->outstr, ro);
else
{
rdpe_abs_eq (ro);
if (rdpe_ne (ro, rdpe_zero))
rdpe_div (r, rad, ro);
else
rdpe_set_d (r, 1.0e-10);
digit = (long)(-rdpe_log10 (r) - 0.5);
if (digit <= 0)
{
rdpe_get_dl (&d, &l, ro);
fprintf (s->outstr, "0.e%ld", l);
}
else
{
true_digit = (long)(LOG10_2 * mpf_get_prec (f));
true_digit = MIN (digit, true_digit);
true_digit = MIN (true_digit, out_digit);
if (sign)
mpf_set (t, f);
else
mpf_abs (t, f);
mpf_out_str (s->outstr, 10, true_digit, t);
}
}
mpf_clear (t);
}
/* New calculate function. */
ordinal_number_t cache_calculator(render_t* handle,const view_position_t render_position)
{
/* Volatile data. */
ordinal_number_t* help;
complex_number_t complex_position;
view_position_t shift;
real_number_t scaling_factor;
mpf_t help_mpf;
mpf_t help_two;
mpf_set_default_prec(sizeof(char)*handle->prec);
mpf_init(help_mpf);
mpf_init(Re(complex_position));
mpf_init(Im(complex_position));
mpf_init(scaling_factor);
mpf_init(help_two);
/* Check if the point has been calculated already. */
help=handle->points+render_position.y*handle->geometry.width+render_position.x;
if(*help==0)
{
/* Has not been calculated till now, calculate the iteration. */
/* Precalculate scaling factor and center shift for speed reasons. */
mpf_div_ui(scaling_factor,handle->scale,handle->geometry.width);
shift.x=handle->geometry.width/2;
shift.y=handle->geometry.height/2;
/* Calculate the iteration. */
mpf_set_si(help_two,(render_position.x-shift.x));
mpf_mul(help_mpf,scaling_factor,help_two);
mpf_add(complex_position.real_part,help_mpf,handle->center.real_part);
mpf_set_si(help_two,(render_position.y-shift.y));
mpf_mul(help_mpf,scaling_factor,help_two);
mpf_sub(Im(complex_position),Im(handle->center),help_mpf);
*help=(*handle->fractal_facility->facility.fractal.calculate_function)(handle->fractal,&complex_position);
}
mpf_clear(help_mpf);
mpf_clear(Re(complex_position));
mpf_clear(Im(complex_position));
mpf_clear(scaling_factor);
mpf_clear(help_two);
/* Return the iteration. */
return(*help);
//return(0);
}
/*
* Function: compute_bbp_first_sum_gmp
* --------------------
* Computes the first summand in the BBP formula using GNU GMP.
*
* d: digit to be calculated
* base: the base
* c: a fixed positive integer
* p: a simple polynomial like x or x^2
* start_at_0: start the summation at k=0, if true, at k=1, otherwise. Most
* instances of the BBP formula, such as pi, have you start at 0.
* But some, such as log(2), have you start at 1.
*
* returns: the value of the first sum
*/
void compute_bbp_first_sum_gmp(mpf_t sum, unsigned long int d, int base, long int c, void (*p)(mpz_t, mpz_t), bool start_at_0) {
mpf_set_d(sum, 0.0);
signed long int k_start = start_at_0 ? 0 : 1;
mpz_t k;
mpz_init_set_si(k, k_start);
double upper = floor((double) d / (double) c);
while (mpz_cmp_d(k, upper) <= 0)
{
mpz_t poly_result;
mpz_init(poly_result);
(*p)(poly_result, k);
mpz_t num;
mpz_init(num);
mpz_t exponent;
mpz_init_set(exponent, k);
mpz_mul_si(exponent, exponent, c);
mpz_mul_si(exponent, exponent, -1);
mpz_add_ui(exponent, exponent, d);
modular_pow_gmp(num, base, exponent, poly_result);
mpf_t num_float;
mpf_init(num_float);
mpf_set_z(num_float, num);
mpz_clear(num);
mpz_clear(exponent);
mpf_t denom;
mpf_init_set_d(denom, mpz_get_d(poly_result));
mpz_clear(poly_result);
mpf_t quotient;
mpf_init(quotient);
mpf_div(quotient, num_float, denom);
mpf_clear(num_float);
mpf_clear(denom);
mpf_add(sum, sum, quotient);
mpf_clear(quotient);
mod_one_gmp(sum, sum);
mpz_add_ui(k, k, 1);
}
mpz_clear(k);
mod_one_gmp(sum, sum);
}
void recalcZoom() {
int32_t diffX = selectZoomW - selectZoomX;
int32_t diffY = selectZoomH - selectZoomY;
if(abs(diffX) >= 10 || abs(diffY) >= 10) {
long double x = sizeX;
long double y = sizeY;
long double factorLeft = ((selectZoomX*100.0)/x)/100.0;
long double factorRight = 1.0-((selectZoomW*100.0)/x)/100.0;
long double factorBottom = 1.0-((selectZoomH*100.0)/y)/100.0;
mpf_t facLeft;
mpf_init2(facLeft,gmpBit);
mpf_set_d(facLeft,factorLeft);
mpf_t facRight;
mpf_init2(facRight,gmpBit);
mpf_set_d(facRight,factorRight);
mpf_t facBottom;
mpf_init2(facBottom,gmpBit);
mpf_set_d(facBottom,factorBottom);
mpf_t tmpDiff;
mpf_init2(tmpDiff,gmpBit);
mpf_t tmp;
mpf_init2(tmp,gmpBit);
//(maxRe - minRe)
mpf_sub(tmpDiff,mandelRange.maxRe,mandelRange.minRe);
//minRe+=(maxRe - minRe)*factorLeft;
mpf_mul(tmp,tmpDiff,facLeft);
mpf_add(mandelRange.minRe,mandelRange.minRe,tmp);
//maxRe-=(maxRe - minRe)*factorRight;
mpf_mul(tmp,tmpDiff,facRight);
mpf_sub(mandelRange.maxRe,mandelRange.maxRe,tmp);
//minIm+=(maxIm - minIm)*factorBottom;
mpf_sub(tmpDiff,mandelRange.maxIm,mandelRange.minIm);
mpf_mul(tmp,tmpDiff,facBottom);
mpf_add(mandelRange.minIm,mandelRange.minIm,tmp);
mpf_clear(tmp);
mpf_clear(tmpDiff);
mpf_clear(facLeft);
mpf_clear(facRight);
mpf_clear(facBottom);
restart();
}
}
/* merit (rop, t, v, m) -- calculate merit for spectral test result in
dimension T, see Knuth p. 105. BUGS: Only valid for 2 <= T <=
6. */
void
merit (mpf_t rop, unsigned int t, mpf_t v, mpz_t m)
{
int f;
mpf_t f_m, f_const, f_pi;
mpf_init (f_m);
mpf_set_z (f_m, m);
mpf_init_set_d (f_const, M_PI);
mpf_init_set_d (f_pi, M_PI);
switch (t)
{
case 2: /* PI */
break;
case 3: /* PI * 4/3 */
mpf_mul_ui (f_const, f_const, 4);
mpf_div_ui (f_const, f_const, 3);
break;
case 4: /* PI^2 * 1/2 */
mpf_mul (f_const, f_const, f_pi);
mpf_div_ui (f_const, f_const, 2);
break;
case 5: /* PI^2 * 8/15 */
mpf_mul (f_const, f_const, f_pi);
mpf_mul_ui (f_const, f_const, 8);
mpf_div_ui (f_const, f_const, 15);
break;
case 6: /* PI^3 * 1/6 */
mpf_mul (f_const, f_const, f_pi);
mpf_mul (f_const, f_const, f_pi);
mpf_div_ui (f_const, f_const, 6);
break;
default:
fprintf (stderr,
"spect (merit): can't calculate merit for dimensions > 6\n");
mpf_set_ui (f_const, 0);
break;
}
/* rop = v^t */
mpf_set (rop, v);
for (f = 1; f < t; f++)
mpf_mul (rop, rop, v);
mpf_mul (rop, rop, f_const);
mpf_div (rop, rop, f_m);
mpf_clear (f_m);
mpf_clear (f_const);
mpf_clear (f_pi);
}
void my_out_str_raw(FILE *fp, unsigned long digits, mpf_t f, unsigned long offset)
{
unsigned long d;
if (digits <= LINE_SIZE*NUM_BLOCKS) {
unsigned long cursor = offset % LINE_SIZE;
for (d = 0; d < digits; ) {
mpf_set_prec_raw(f, (int)((digits-d)*BITS_PER_DIGIT+1));
mpf_mul_ui(f, f, UNIT_MOD);
unsigned long i = mpf_get_ui(f);
mpf_sub_ui(f, f, i);
utoa(i, UNIT_SIZE);
*out_ptr++ = ' ';
d += UNIT_SIZE;
cursor += UNIT_SIZE;
if (cursor == LINE_SIZE) {
cursor = 0;
*out_ptr++ = ':';
*out_ptr++ = ' ';
utoa(offset + d, 0);
*out_ptr++ = '\n';
if ((offset + d) % (LINE_SIZE*10) == 0)
flush_out(fp);
}
}
} else {
mpf_t block, mod;
unsigned long num_units = (digits + UNIT_SIZE-1)/UNIT_SIZE;
unsigned long block_size = (num_units + NUM_BLOCKS-1)/NUM_BLOCKS*UNIT_SIZE;
mpf_set_default_prec((int)(block_size*BITS_PER_DIGIT+1));
mpf_init(block);
mpf_init_set_ui(mod, 10);
mpf_pow_ui(mod, mod, block_size);
for (d = 0; d < digits; d += block_size) {
unsigned long size = block_size < digits - d ? block_size : digits - d;
mpf_set_prec_raw(block, (int)(size*BITS_PER_DIGIT+1));
mpf_set(block, f);
my_out_str_raw(fp, size, block, offset+d);
if (block_size < digits - d) {
mpf_set_prec_raw(f, (int)((digits-d)*BITS_PER_DIGIT+1));
mpf_mul(f, f, mod);
mpf_floor(trunk, f);
mpf_sub(f, f, trunk);
}
}
mpf_clear(block);
mpf_clear(mod);
}
}
void
check_data (void)
{
static const struct {
long x;
mp_size_t want_size;
mp_limb_t want_limb;
} data[] = {
{ 0L, 0 },
{ 1L, 1, 1 },
{ -1L, -1, 1 },
{ LONG_MAX, 1, LONG_MAX },
{ -LONG_MAX, -1, LONG_MAX },
{ LONG_HIGHBIT, -1, ULONG_HIGHBIT },
};
mpf_t x;
int i;
for (i = 0; i < numberof (data); i++)
{
mpf_init (x);
mpf_set_si (x, data[i].x);
MPF_CHECK_FORMAT (x);
if (x->_mp_size != data[i].want_size
|| (x->_mp_size != 0
&& (x->_mp_d[0] != data[i].want_limb
|| x->_mp_exp != 1)))
{
printf ("mpf_set_si wrong on data[%d]\n", i);
abort();
}
mpf_clear (x);
mpf_init_set_si (x, data[i].x);
MPF_CHECK_FORMAT (x);
if (x->_mp_size != data[i].want_size
|| (x->_mp_size != 0
&& (x->_mp_d[0] != data[i].want_limb
|| x->_mp_exp != 1)))
{
printf ("mpf_init_set_si wrong on data[%d]\n", i);
abort();
}
mpf_clear (x);
}
}
static void mpc_cis(mpc_t res, mpf_t theta) {
mpf_t a;
mpf_init(a); mpf_set(a, theta);
//res = exp(i a)
// = cos a + i sin a
//converges quickly near the origin
mpf_t f0;
mpf_ptr rx = mpc_re(res), ry = mpc_im(res);
int i;
int toggle = 1;
mpf_init(f0);
mpf_set(f0, a);
mpf_set_ui(rx, 1);
mpf_set(ry, f0);
i = 1;
for(;;) {
toggle = !toggle;
i++;
mpf_div_ui(f0, f0, i);
mpf_mul(f0, f0, a);
if (toggle) {
mpf_add(rx, rx, f0);
} else {
mpf_sub(rx, rx, f0);
}
i++;
mpf_div_ui(f0, f0, i);
mpf_mul(f0, f0, a);
if (toggle) {
mpf_add(ry, ry, f0);
} else {
mpf_sub(ry, ry, f0);
}
if (mpf_sgn(f0) > 0) {
if (mpf_cmp(f0, epsilon) < 0) break;
} else {
if (mpf_cmp(f0, negepsilon) > 0) break;
}
}
mpf_clear(f0);
mpf_clear(a);
}
void clear()
{
clear_vec_mp(checker_1_);
clear_vec_mp(checker_2_);
clear_mp(diff_);
mpf_clear(abs_);
mpf_clear(zerothresh_);
for (int ii=0; ii<num_projections_; ii++) {
clear_vec_mp(projections_[ii]);
}
free(projections_);
}
inline Mtbdd
readMPQAttribute(const TiXmlNode* node, const char* att)
{
const std::string numberString = readStringAttribute(node, att);
mpq_t gmp_value;
mpq_init(gmp_value);
try {
size_t pos = 0;
if ((pos = numberString.find('.')) != std::string::npos) {
mpf_t f_value;
mpf_init(f_value);
mpf_set_str(f_value, numberString.c_str(), 10);
mpq_set_f(gmp_value, f_value);
mpf_clear(f_value);
} else {
mpq_set_str(gmp_value, numberString.c_str(), 10);
}
if (mpq_sgn(gmp_value) == 0) {
mpq_clear(gmp_value);
return mtbdd_false;
}
MTBDD res = mtbdd_gmp(gmp_value);
mpq_clear(gmp_value);
return res;
} catch(boost::bad_lexical_cast&) {
throw ParseError("[ERROR] String " + numberString + " is not a number");
}
}
void fmpz_poly_disc_gauss_rounding(fmpz_poly_t rop, const fmpq_poly_t x, const mpfr_t r_f, gmp_randstate_t randstate) {
mpfr_t xi; mpfr_init2(xi, mpfr_get_prec(r_f));
mpf_t xi_f; mpf_init2(xi_f, mpfr_get_prec(r_f));
mpq_t xi_q; mpq_init(xi_q);
mpz_t s_z; mpz_init(s_z);
const long n = fmpq_poly_length(x);
const size_t tau = (ceil(2*sqrt(log2((double)n))) > 3) ? ceil(2*sqrt(log2((double)n))) : 3;
fmpz_poly_zero(rop);
for(int i=0; i<n; i++) {
fmpq_poly_get_coeff_mpq(xi_q, x, i);
mpf_set_q(xi_f, xi_q);
mpfr_set_f(xi, xi_f, MPFR_RNDN);
dgs_disc_gauss_mp_t *D = dgs_disc_gauss_mp_init(r_f, xi, tau, DGS_DISC_GAUSS_UNIFORM_ONLINE);
D->call(s_z, D, randstate);
dgs_disc_gauss_mp_clear(D);
fmpz_poly_set_coeff_mpz(rop, i, s_z);
}
mpz_clear(s_z);
mpq_clear(xi_q);
mpf_clear(xi_f);
mpfr_clear(xi);
}
// TODO: adjust sign
int mpf_gamma(mp_float * a, mp_float * b)
{
int err;
long oldeps, eps;
mp_float t;
err = MP_OKAY;
oldeps = a->radix;
eps = oldeps + MP_DIGIT_BIT;
if ((err = mpf_init(&t, oldeps)) != MP_OKAY) {
return err;
}
if ((err = mpf_copy(a, &t)) != MP_OKAY) {
goto _ERR;
}
if ((err = mpf_normalize_to(&t, eps)) != MP_OKAY) {
goto _ERR;
}
if ((err = mpf_lngamma(&t, &t)) != MP_OKAY) {
goto _ERR;
}
if ((err = mpf_exp(&t, &t)) != MP_OKAY) {
goto _ERR;
}
if ((err = mpf_normalize_to(&t, oldeps)) != MP_OKAY) {
goto _ERR;
}
mpf_exch(&t, b);
_ERR:
mpf_clear(&t);
return err;
}
void
check_various (void)
{
mpf_t got;
mpq_t q;
mpf_init (got);
mpq_init (q);
/* 1/1 == 1 */
mpf_set_prec (got, 20L);
mpq_set_ui (q, 1L, 1L);
mpf_set_q (got, q);
MPF_CHECK_FORMAT (got);
ASSERT_ALWAYS (mpf_cmp_ui (got, 1L) == 0);
/* 1/(2^n+1), a case where truncating the divisor would be wrong */
mpf_set_prec (got, 500L);
mpq_set_ui (q, 1L, 1L);
mpz_mul_2exp (mpq_denref(q), mpq_denref(q), 800L);
mpz_add_ui (mpq_denref(q), mpq_denref(q), 1L);
check_one (got, q);
mpf_clear (got);
mpq_clear (q);
}
void
test_denorms (int prc)
{
#ifdef _GMP_IEEE_FLOATS
double d1, d2;
mpf_t f;
int i;
mpf_set_default_prec (prc);
mpf_init (f);
d1 = 1.9;
for (i = 0; i < 820; i++)
{
mpf_set_d (f, d1);
d2 = mpf_get_d (f);
if (d1 != d2)
abort ();
d1 *= 0.4;
}
mpf_clear (f);
#endif
}
void
check_max (void)
{
mpf_t f;
long want;
long got;
mpf_init2 (f, 200L);
#define CHECK_MAX(name) \
if (got != want) \
{ \
printf ("mpf_get_si wrong on %s\n", name); \
printf (" f "); \
mpf_out_str (stdout, 10, 0, f); printf (", hex "); \
mpf_out_str (stdout, 16, 0, f); printf ("\n"); \
printf (" got %ld, hex %lX\n", got, got); \
printf (" want %ld, hex %lX\n", want, want); \
abort(); \
}
want = LONG_MAX;
mpf_set_si (f, want);
got = mpf_get_si (f);
CHECK_MAX ("LONG_MAX");
want = LONG_MIN;
mpf_set_si (f, want);
got = mpf_get_si (f);
CHECK_MAX ("LONG_MIN");
mpf_clear (f);
}
/**
* Convert a Ruby function value into a long double
*
* Parameters::
* * *iValBD* (_Rational_): The value to convert
* Return::
* * <em>long double</em>: The equivalent long double
*/
inline long double value2ld(
VALUE iValBD) {
long double rResult;
mpf_t lDenominator;
mpf_init_set_str(lDenominator, RSTRING_PTR(rb_funcall(rb_funcall(iValBD, gID_denominator, 0), gID_to_s, 0)), 10);
mpf_t lDivResult;
mpf_init_set_str(lDivResult, RSTRING_PTR(rb_funcall(rb_funcall(iValBD, gID_numerator, 0), gID_to_s, 0)), 10);
mpf_div(lDivResult, lDivResult, lDenominator);
// TODO: Find a way to round correctly lDivResult. It is currently truncated.
rResult = mpf_get_d(lDivResult);
mpf_clear(lDivResult);
mpf_clear(lDenominator);
return rResult;
}
static void
mps_context_init (mps_context * s)
{
mpf_t test;
/* Set default streams */
s->instr = stdin;
s->outstr = stdout;
s->logstr = stdout;
/* Allocate space for the configurations */
s->input_config = (mps_input_configuration*)mps_malloc (sizeof(mps_input_configuration));
s->output_config = (mps_output_configuration*)mps_malloc (sizeof(mps_output_configuration));
mps_set_default_values (s);
/* Find minimum GMP supported precision */
mpf_init2 (test, 1);
s->minimum_gmp_precision = mpf_get_prec (test);
mpf_clear (test);
/* Set standard precision */
s->output_config->prec = (int)(0.9 * DBL_DIG * LOG2_10);
MPS_DEBUG (s, "Setting prec_out to %ld digits", s->output_config->prec);
mps_mp_set_prec (s, DBL_DIG * LOG2_10 + 1);
s->initialized = false;
s->exit_required = false;
}
void
check_consistency (void)
{
mpf_t x;
unsigned long i, a, b;
mpf_init (x);
for (i = 1; i < 2000; i++)
{
mpf_set_prec (x, i);
a = mpf_get_prec (x);
mpf_set_prec (x, a);
b = mpf_get_prec (x);
if (a != b)
{
printf ("mpf_get_prec / mpf_set_prec inconsistent\n");
printf (" set %lu gives %lu, but then set %lu gives %lu\n",
i, a,
a, b);
abort ();
}
}
mpf_clear (x);
}
void w3j(mpf_t w, long j1, long j2, long j3, long m1, long m2, long m3)
{
mpq_t delta_sq,r;
mpz_t i;
mpf_t h;
mpq_init(delta_sq);
mpq_init(r);
mpz_init(i);
mpf_init(h);
mpq_set_si(r,0,1);
if(m1+m2+m3!=0) return;
if((iabs(m1)>j1) || (iabs(m2)>j2) || (iabs(m3)>j3)) return;
if((j3<iabs(j1-j2)) || ((j1+j2)<j3)) return;
w3j_Delta_sq(delta_sq, j1, j2, j3);
w3j_intterm(i, j1, j2, j3, m1, m2, m3);
if(iabs(j1-j2-m3)%2 == 1) mpz_neg(i,i);
w3j_sqrt_sq(r, j1, j2, j3, m1, m2, m3);
mpq_mul(r,r,delta_sq);
mpf_set_q(w,r);
mpf_sqrt(w,w);
mpf_set_z(h,i);
mpf_mul(w,w,h);
mpf_clear(h);
mpz_clear(i);
mpq_clear(r);
mpq_clear(delta_sq);
}
