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);
}
