vanilla::object::ptr vanilla::int_object::div(object::ptr const& other) { switch(other->type_id()) { case OBJECT_ID_INT: { float_object::float_type lhs( (_v.mpz()) ); float_object::float_type rhs( (static_cast<int_object const*>(other.get())->value().mpz()) ); float_object::float_type result; mpf_div(result.mpf(), lhs.mpf(), rhs.mpf()); return allocate_object<float_object>(std::move(result)); } case OBJECT_ID_FLOAT: { float_object::float_type lhs( (_v.mpz()) ); float_object const* rhs = static_cast<float_object const*>(other.get()); float_object::float_type result; mpf_div(result.mpf(), lhs.mpf(), rhs->value().mpf()); return allocate_object<float_object>(std::move(result)); } default: { return object::div(other); } } }
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); }
static void newton(mpf_t x, double seed, fun_3term *fun, fun_3term *der, int n) { DECLARE_3VARS(ox,f,df); mpf_set_d(x, seed); do { mpf_set(ox, x); fun(f, n,x), der(df, n,x), mpf_div(f, f,df), mpf_sub(x, x,f); } while(!is_small(f,x)); fun( f, n,x), der(df, n,x), mpf_div(f, f,df), mpf_sub(x, x,f); }
void mpfc_div(mpfc_ptr r,mpfc_ptr x,mpfc_ptr y) { static mpfc_t z; mpf_mul(mpfc_mpf_temp[0],x->Re,y->Re); mpf_mul(mpfc_mpf_temp[1],x->Im,y->Im); mpf_add(mpfc_mpf_temp[2],mpfc_mpf_temp[0],mpfc_mpf_temp[1]); mpf_mul(mpfc_mpf_temp[0],x->Re,y->Im); mpf_mul(mpfc_mpf_temp[1],x->Im,y->Re); mpf_sub(mpfc_mpf_temp[3],mpfc_mpf_temp[1],mpfc_mpf_temp[0]); mpf_mul(mpfc_mpf_temp[0],x->Re,x->Re); mpf_mul(mpfc_mpf_temp[1],x->Im,x->Im); mpf_add(mpfc_mpf_temp[0],mpfc_mpf_temp[0],mpfc_mpf_temp[1]); mpf_div(r->Re,mpfc_mpf_temp[2],mpfc_mpf_temp[0]); mpf_div(r->Im,mpfc_mpf_temp[3],mpfc_mpf_temp[0]); }
void mpf_div_ui (mpf_ptr r, mpf_srcptr u, unsigned long int v) { mp_srcptr up; mp_ptr rp, tp, rtp; mp_size_t usize; mp_size_t rsize, tsize; mp_size_t sign_quotient; mp_size_t prec; mp_limb_t q_limb; mp_exp_t rexp; TMP_DECL; #if BITS_PER_ULONG > GMP_NUMB_BITS /* avoid warnings about shift amount */ if (v > GMP_NUMB_MAX) { mpf_t vf; mp_limb_t vl[2]; SIZ(vf) = 2; EXP(vf) = 2; PTR(vf) = vl; vl[0] = v & GMP_NUMB_MASK; vl[1] = v >> GMP_NUMB_BITS; mpf_div (r, u, vf); return; }
//------------------------------------------------------------------------------ // Name: //------------------------------------------------------------------------------ knumber_base *knumber_float::reciprocal() { mpf_t mpf; mpf_init_set_d(mpf, 1.0); mpf_div(mpf_, mpf, mpf_); return this; }
float evaluateFitness(float position[]) { char stringFitness[28]; mpf_t mpfFitness, one; float ris; float fitness = formulae(position); if (fitness >= 0) { sprintf(stringFitness, "%.20f", fitness); mpf_init(mpfFitness); mpf_init(one); mpf_set_str (one, "1.0", 10); mpf_set_str(mpfFitness, stringFitness, 10); mpf_add(mpfFitness, mpfFitness, one); //printf("fitness: %.20e\t", fitness); //mpf_out_str (stdout, 10, 256, mpfFitness); mpf_div(mpfFitness, one, mpfFitness); printf("\nris %.20e\t", (float) mpf_get_d(mpfFitness)); ris = (float) mpf_get_d(mpfFitness); mpf_out_str (stdout, 10, 256, mpfFitness); printf("\n"); return ris; //return 1 / (1 + fitness); } return 1 + fabs(fitness); }
//------------------------------------------------------------------------------ // Name: //------------------------------------------------------------------------------ knumber_base *knumber_float::div(knumber_base *rhs) { if(rhs->is_zero()) { if(sign() < 0) { delete this; return new knumber_error(knumber_error::ERROR_NEG_INFINITY); } else { delete this; return new knumber_error(knumber_error::ERROR_POS_INFINITY); } } if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) { knumber_float f(p); return div(&f); } else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) { mpf_div(mpf_, mpf_, p->mpf_); return this; } else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) { knumber_float f(p); return div(&f); } else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) { if(p->sign() > 0 || p->sign() < 0) { delete this; return new knumber_integer(0); } delete this; return new knumber_error(p); } Q_ASSERT(0); return 0; }
void mpf_reldiff (mpf_t rdiff, mpf_srcptr x, mpf_srcptr y) { if (UNLIKELY (SIZ(x) == 0)) { mpf_set_ui (rdiff, (unsigned long int) (mpf_sgn (y) != 0)); } else { mp_size_t dprec; mpf_t d; TMP_DECL; TMP_MARK; dprec = PREC(rdiff) + ABSIZ(x); ASSERT (PREC(rdiff)+1 == dprec - ABSIZ(x) + 1); PREC(d) = dprec; PTR(d) = TMP_ALLOC_LIMBS (dprec + 1); mpf_sub (d, x, y); SIZ(d) = ABSIZ(d); mpf_div (rdiff, d, x); TMP_FREE; } }
int main (void) { mpf_set_default_prec (300000); mpf_t x0, y0, resA, resB, Z, var; mpf_init_set_ui (x0, 1); mpf_init_set_d (y0, 0.5); mpf_sqrt (y0, y0); mpf_init (resA); mpf_init (resB); mpf_init_set_d (Z, 0.25); mpf_init (var); int n = 1; for(int i=0; i<8; i++){ agm(x0, y0, resA, resB); mpf_sub(var, resA, x0); mpf_mul(var, var, var); mpf_mul_ui(var, var, n); mpf_sub(Z, Z, var); n += n; agm(resA, resB, x0, y0); mpf_sub(var, x0, resA); mpf_mul(var, var, var); mpf_mul_ui(var, var, n); mpf_sub(Z, Z, var); n += n; } mpf_mul(x0, x0, x0); mpf_div(x0, x0, Z); gmp_printf ("%.100000Ff\n", x0); return 0; }
int sg_big_float_div(sg_big_float_t *a, sg_big_float_t *b, sg_big_float_t *res) { if (!a || !b || !res) return -1; mpf_div(res->mpf, a->mpf, b->mpf); return 0; }
/** * void calculate_a() * * Descricao: * Calcula o valor do "pi" na n-esima iteracao. * * Parametros de entrada: * - * * Parametros de retorno: * - */ void calculate_pi(){ mpf_add(pi[n_count], a_n[n_count+1], b_n[n_count+1]); mpf_pow_ui(pi[n_count], pi[n_count], 2); mpf_div_ui(pi[n_count], pi[n_count], 4); mpf_div(pi[n_count], pi[n_count], t_n[n_count+1]); }
void log(const mpf_t n, mpf_t l, mpf_t b) { // l = log10(n)/log10(b) mpf_t tmp, tmp2; mpf_inits(tmp, tmp2, NULL); log10(n, tmp); log10(b, tmp2); mpf_div(l, tmp, tmp2); mpf_clears(tmp, tmp2, NULL); }
/* atan2(a,b) = atan(a/b); */ int mpf_atan2(mp_float * a, mp_float * b, mp_float * c) { int err; // TODO: implement IEEE-754. But be warned: it's a looong list! if ((err = mpf_div(a, b, c)) != MP_OKAY) { return err; } return mpf_atan(c, c); }
void division(int var1, int var2, int digits) { mpf_t x; mpf_init(x); mpf_t y; mpf_init(y); mpf_set_d(x, var1); mpf_set_d(y, var2); mpf_div (x, x, y); gmp_printf ("%.*Ff\n", digits, x); }
libmaus2::math::GmpFloat & libmaus2::math::GmpFloat::operator/=( GmpFloat const & #if defined(LIBMAUS2_HAVE_GMP) o #endif ) { #if defined(LIBMAUS2_HAVE_GMP) mpf_div(decode(v),decode(v),decode(o.v)); #endif return *this; }
void *thread1(void *param) { if (i != 0) { mpf_mul(aux2, y, sqrtx); mpf_add(aux2, aux2, invsqrtx); mpf_add_ui(y, y, 1); mpf_div(y, aux2, y); } mpf_add_ui(aux2, y, 1); pthread_exit(0); }
void gmp_monte_carlo_par (int numthr, int numpts) { /*Para realizar o metodo Monte Carlo foi utilizado uma circunferencia de raio igual a 1 (para facilitar a comparacao que verifica se o ponto esta dentro da circunferencia) inscrita em uma quadrado de lado igual a 2. Foi considerado apenas o primeiro quadrante, pois assim as coordenadas dos pontos variam de 0 a 1. */ int i =0; mpf_t pi; mpf_t intern_points, total_points, ratio; pthread_t tabela_thr[1000]; /*Variavel que armazena quantos pontos vao ficar dentro da circunferencia*/ /*A precisao padrao sera no minimo 10.000.000*log10.*/ mpf_set_default_prec (34000000); /*O objeto mpf_t deve ser inicializado antes de receber algum valor.*/ mpf_init(pi),mpf_init(intern_points),mpf_init(total_points),mpf_init(ratio); /* Inicializa a semente para calcular o valor aleatorio*/ srand (time(NULL)); /* Para uma quantidade de quase 1 bi de pontos*/ i=0; if(numthr>1000) numthr=1000; while(i<numthr) { //printf("\nIniciando Thread: %d", i); mpf_init(param[i].intern_points); mpf_init(param[i].total_points); param[i].numpoints=numpts; pthread_create(&tabela_thr[i], NULL, (void*)&montecarlo_thr, (void*) & param[i]); i++; } i=0; while(i<numthr){ pthread_join(tabela_thr[i], NULL); mpf_add(intern_points,intern_points,param[i].intern_points); mpf_add(total_points,total_points,param[i].total_points); i++; } /*calculando o valor de pi pi = 4* (double) intern_points /total_points */ mpf_div (ratio,intern_points,total_points); /*ratio = intern_points / total_points*/ mpf_mul_ui (pi,ratio,4); /* pi = 4*ratio*/ mpf_out_str (stdout,10,10000000,pi); }
/* 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); }
/* * 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); }
/** * 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; }
void *calc_y(thr_gmpf_t *vars) { /*vars.y1 = (1-sqrt(sqrt((1-pow(vars.y0,4))))) / (1+sqrt(sqrt(1-pow(vars.y0,4))));*/ /*b = sqrt(sqrt(1-y0^4))*/ mpf_pow_ui(vars->y1,vars->y0,4); /*y1 = pow(y0,4)*/ mpf_ui_sub(vars->y1,1,vars->y1); /*y1 = 1 - y1*/ mpf_sqrt(vars->y1,vars->y1); mpf_sqrt(vars->y1,vars->y1); /*y1 = 1-b/1+b*/ mpf_ui_sub(vars->aux_y1,1,vars->y1); mpf_add_ui(vars->aux_y2,vars->y1,1); mpf_div(vars->y1,vars->aux_y1,vars->aux_y2); pthread_exit(NULL); return NULL; }
// The Brent-Salamin algorithm int main(int argc, char* argv[]) { if (argc < 2) return -1; int n = (int)strtol(argv[1], NULL, 10); mpf_set_default_prec(1000); mpf_t a, b, t, c, sum; // a=1 mpf_init_set_ui(a, 1); mpf_init_set_ui(sum, 0); mpf_init(b); mpf_init(t); mpf_init(c); mpf_init(sum); // b=1/sqrt(2) mpf_sqrt_ui(b, 2); mpf_ui_div(b, 1, b); // n次迭代的误差小于\frac{2^{n+9}}{20^{2n+1}} for (int i = 1; i <= n; ++i) { // t=(a+b)/2 mpf_add(t, a, b); mpf_div_ui(t, t, 2); // b=sqrt(a*b); mpf_mul(b, a, b); mpf_sqrt(b, b); // a=t mpf_swap(t, a); mpf_mul(t, a, a); mpf_mul(c, b, b); mpf_sub(c, t, c); mpf_mul_2exp(c, c, i + 1); mpf_add(sum, sum, c); } mpf_mul(t, a, a); mpf_mul_ui(t, t, 4); mpf_ui_sub(sum, 1, sum); mpf_div(t, t, sum); mpf_out_str(stdout, 10, 0, t); printf("\n"); mpf_clear(a); mpf_clear(b); mpf_clear(t); mpf_clear(c); mpf_clear(sum); return 0; }
int main(void) { clock_t begin, end; mpf_set_default_prec(BITS_PER_DIGIT*DIGITS); //mpf_set_default_prec(4096); begin = clock(); mpf_init(x); mpf_init(y); mpf_init(p); mpf_init(aux1); mpf_init(aux2); mpf_init(sqrtx); mpf_init(invsqrtx); /* x = sqrt(2)*/ mpf_set_ui(x, 2); mpf_sqrt(x, x); /* y = sqrt(sqrt(2)) = sqrt(x)*/ mpf_sqrt(y, x); /* p = 2 + sqrt(2) = 2 + x*/ mpf_add_ui(p, x, 2); for (i=0; i<24; i++) { mpf_sqrt(sqrtx, x); mpf_ui_div(invsqrtx, 1, sqrtx); pthread_create(&t1, NULL, thread1, NULL); pthread_create(&t2, NULL, thread2, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); mpf_div(p, aux1, aux2); //Para ver os valores de pi a cada iteracao //mpf_out_str(stdout, 10, DIGITS, p); } mpf_out_str(stdout, 10, DIGITS, p); mpf_clear(x); mpf_clear(y); mpf_clear(p); mpf_clear(aux1); mpf_clear(aux2); mpf_clear(sqrtx); mpf_clear(invsqrtx); end = clock(); printf("Took %lfs\n", (double)(end-begin)/CLOCKS_PER_SEC); pthread_exit(0); }
int main() { char function; mpf_t number1, number2, output; mpf_init_set_ui(number1, 0); mpf_init_set_ui(number2, 0); mpf_init_set_ui(output, 0); while(true) { printf("enter a calculation using A +,-,*,/ B format.\n"); gmp_scanf("%Ff%c%Ff", number1, &function, number2); if (function == '+') { mpf_add(output, number1, number2); gmp_printf("%Ff\n", output); } if (function == '-') { mpf_sub(output, number1, number2); gmp_printf("%Ff\n", output); } if (function == 'x' || function == '*') { mpf_mul(output, number1, number2); gmp_printf("%Ff\n", output); } if (function == '/') { mpf_div(output, number1, number2); gmp_printf("%Ff\n", output); } } mpf_clear(number1); mpf_clear(number2); mpf_clear(output); }
void calculate_term(unsigned int n,double x, mpf_t term, mpf_t a, mpf_t b) { /* a = ((-1)^n) */ mpf_set_str(a,"-1.0",10); mpf_pow_ui(a,a,n); /* b = (x^(2*n)) */ mpf_set_d(b,x); mpf_pow_ui(b,b,2*n); /* a = a*b (liberamos o uso de b para contas futuras) */ mpf_mul(a,a,b); /* fatorial(2*n) */ mpf_fac_ui(b,2*n); /* a = a/b */ mpf_div(term,a,b); }
void correction_factor_Q(mpf_t Q, int N,mpf_t rho,int k){ unsigned long int f; mpf_t tmp,tmp1,tmp2; /* if (PNK_N_1_rho_1_PN == 0) cout << "Algun factor es 0 N = " << N << " rho = " << rho << " k = " << k << " P__0 = " << P__0 << " P__N = " << P__N << endl; */ mpf_init(tmp); mpf_init_set_d(tmp1,pow(N,k-1)); // N^(k-1) f = 1; mpf_set_ui(Q,0); for (unsigned long int j = k;j < N;j++) { /*Q += (N - j) * pow(N,j) * pow(rho,j - k) * P__0 * N_k_1 / (factorial(j - k) * PNK_N_1_rho_1_PN); */ /* Q += [(N - j) * N^j * rho^(j - k) / (j - k)!] * P__0 * N_k_1 / PNK_N_1_rho_1_PN; */ mpf_mul_ui(tmp1,tmp1,N); // * N if (j - k > 1) mpf_div_ui(tmp1,tmp1,j - k); // / (j - k) mpf_mul_ui(tmp,tmp1,N - j); // * (N - j) mpf_add(Q,Q,tmp); // Q += (N - j) * N^j * rho^(j - k) / (j - k)! mpf_mul(tmp1,tmp1,rho); // * rho } mpf_init(tmp2); mpf_ui_sub(tmp2,1,P__N); // 1 - P__N mpf_pow_ui(tmp1,tmp2,k); // (1 - P__N)^k mpf_mul(tmp2,tmp2,rho); // rho * (1 - P__N) mpf_ui_sub(tmp2,1,tmp2); // 1 - rho * (1 - P__N) mpf_mul(Q,Q,P__0); // * P__0 mpf_mul_ui(Q,Q,factorial(N-k-1)); // * (N - k - 1)! /* pow(1 - P__N,k) * factorial(N) * (1 - rho * (1 - P__N)) */ mpf_mul(tmp2,tmp1,tmp2); // (1 - P__N)^k * (1 - rho * (1 - P__N)) mpf_mul_ui(tmp2,tmp2,factorial(N)); // (1 - P__N)^k * (1 - rho * (1 - P__N)) * N! mpf_div(Q,Q,tmp2); // / [(1 - P__N)^k * (1 - rho * (1 - P__N)) * N!] mpf_clear(tmp); mpf_clear(tmp1); mpf_clear(tmp2); }
void mpf_reldiff (mpf_t rdiff, mpf_srcptr x, mpf_srcptr y) { if (mpf_cmp_ui (x, 0) == 0) { mpf_set_ui (rdiff, (unsigned long int) (mpf_sgn (y) != 0)); } else { mpf_t d; mp_limb_t tmp_limb[2]; d->_mp_prec = 1; d->_mp_d = tmp_limb; mpf_sub (d, x, y); mpf_abs (d, d); mpf_div (rdiff, d, x); } }
void DoArithematicOperation(number_t result, number_t number1, number_t number2, char *op) { switch (op[0]) { case '+': mpf_add(result, number1, number2); break; case '-': mpf_sub(result, number1, number2); break; case '*': mpf_mul(result, number1, number2); break; case '/': mpf_div(result, number1, number2); break; case '%': DO_INTEGER_OPERATION2_ON_FLOAT(mpz_mod, result, number1, number2); break; } }
void x2 (mpf_t V, /* result */ unsigned long int X[], /* data */ unsigned int k, /* #of categories */ void (P) (mpf_t, unsigned long int, void *), /* probability func */ void *x, /* extra user data passed to P() */ unsigned long int n) /* #of samples */ { unsigned int f; mpf_t f_t, f_t2; /* temp floats */ mpf_init (f_t); mpf_init (f_t2); mpf_set_ui (V, 0); for (f = 0; f < k; f++) { if (g_debug > DEBUG_2) fprintf (stderr, "%u: P()=", f); mpf_set_ui (f_t, X[f]); mpf_mul (f_t, f_t, f_t); /* f_t = X[f]^2 */ P (f_t2, f, x); /* f_t2 = Pr(f) */ if (g_debug > DEBUG_2) mpf_out_str (stderr, 10, 2, f_t2); mpf_div (f_t, f_t, f_t2); mpf_add (V, V, f_t); if (g_debug > DEBUG_2) { fprintf (stderr, "\tV="); mpf_out_str (stderr, 10, 2, V); fprintf (stderr, "\t"); } } if (g_debug > DEBUG_2) fprintf (stderr, "\n"); mpf_div_ui (V, V, n); mpf_sub_ui (V, V, n); mpf_clear (f_t); mpf_clear (f_t2); }