void DoUniaryOperation(number_t result, number_t number1, char *op) { switch( op[0] ) { case '!': mpf_set_si(result, mpf_cmp_ui(number1, 0)); break; case '~': DO_INTEGER_OPERATION1_ON_FLOAT(mpz_com, result, number1); break; case '+': if (op[1] == '+') { mpf_add_ui(result, number1, 1); } else { mpf_set(result, number1); } break; case '-': if (op[1] == '-') { mpf_sub_ui(result, number1, 1); } else { mpf_sub(result, result, number1); } break; } }
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); }
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 my_out_str(FILE *fp, unsigned long base, unsigned long digits, mpf_t f) { unsigned long num_units = (digits + UNIT_SIZE-1)/UNIT_SIZE; unsigned long block_size = (num_units + NUM_BLOCKS-1)/NUM_BLOCKS*UNIT_SIZE; mpf_init2(trunk, (int)(block_size*BITS_PER_DIGIT+1)); unsigned long i = mpf_get_ui(f); fprintf(fp, "%lu.\n", i); mpf_sub_ui(f, f, i); my_out_str_raw(fp, digits, f, 0); if (out_ptr != out_buf) flush_out(fp); mpf_clear(trunk); }
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); }
void ks (mpf_t Kp, mpf_t Km, mpf_t X[], void (P) (mpf_t, mpf_t), unsigned long int n) { mpf_t Kt; /* temp */ mpf_t f_x; mpf_t f_j; /* j */ mpf_t f_jnq; /* j/n or (j-1)/n */ unsigned long int j; /* Sort the vector in ascending order. */ qsort (X, n, sizeof (__mpf_struct), mpf_cmp); /* K-S test. */ /* Kp = sqr(n) * max(j/n - F(Xj)) for all 1<=j<=n Km = sqr(n) * max(F(Xj) - (j-1)/n)) for all 1<=j<=n */ mpf_init (Kt); mpf_init (f_x); mpf_init (f_j); mpf_init (f_jnq); mpf_set_ui (Kp, 0); mpf_set_ui (Km, 0); for (j = 1; j <= n; j++) { P (f_x, X[j-1]); mpf_set_ui (f_j, j); mpf_div_ui (f_jnq, f_j, n); mpf_sub (Kt, f_jnq, f_x); if (mpf_cmp (Kt, Kp) > 0) mpf_set (Kp, Kt); if (g_debug > DEBUG_2) { printf ("j=%lu ", j); printf ("P()="); mpf_out_str (stdout, 10, 2, f_x); printf ("\t"); printf ("jnq="); mpf_out_str (stdout, 10, 2, f_jnq); printf (" "); printf ("diff="); mpf_out_str (stdout, 10, 2, Kt); printf (" "); printf ("Kp="); mpf_out_str (stdout, 10, 2, Kp); printf ("\t"); } mpf_sub_ui (f_j, f_j, 1); mpf_div_ui (f_jnq, f_j, n); mpf_sub (Kt, f_x, f_jnq); if (mpf_cmp (Kt, Km) > 0) mpf_set (Km, Kt); if (g_debug > DEBUG_2) { printf ("jnq="); mpf_out_str (stdout, 10, 2, f_jnq); printf (" "); printf ("diff="); mpf_out_str (stdout, 10, 2, Kt); printf (" "); printf ("Km="); mpf_out_str (stdout, 10, 2, Km); printf (" "); printf ("\n"); } } mpf_sqrt_ui (Kt, n); mpf_mul (Kp, Kp, Kt); mpf_mul (Km, Km, Kt); mpf_clear (Kt); mpf_clear (f_x); mpf_clear (f_j); mpf_clear (f_jnq); }
int main (void) { mpf_t f, f0p5; int got; const char *expr; int error = 0; tests_start (); mpf_init2 (f, 200L); mpf_init2 (f0p5, 200L); /* 0.5 */ mpf_set_ui (f0p5, 1L); mpf_div_2exp (f0p5, f0p5, 1L); mpf_set_ui (f, 0L); expr = "0"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); EXPECT (mpf_fits_ushort_p, 1); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_ui (f, 1L); expr = "1"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); EXPECT (mpf_fits_ushort_p, 1); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_si (f, -1L); expr = "-1"; EXPECT (mpf_fits_ulong_p, 0); EXPECT (mpf_fits_uint_p, 0); EXPECT (mpf_fits_ushort_p, 0); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_ui (f, (unsigned long) USHRT_MAX); expr = "USHRT_MAX"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); EXPECT (mpf_fits_ushort_p, 1); mpf_set_ui (f, (unsigned long) USHRT_MAX); mpf_add (f, f, f0p5); expr = "USHRT_MAX + 0.5"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); EXPECT (mpf_fits_ushort_p, 1); mpf_set_ui (f, (unsigned long) USHRT_MAX); mpf_add_ui (f, f, 1L); expr = "USHRT_MAX + 1"; EXPECT (mpf_fits_ushort_p, 0); mpf_set_ui (f, (unsigned long) UINT_MAX); expr = "UINT_MAX"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); mpf_set_ui (f, (unsigned long) UINT_MAX); mpf_add (f, f, f0p5); expr = "UINT_MAX + 0.5"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); mpf_set_ui (f, (unsigned long) UINT_MAX); mpf_add_ui (f, f, 1L); expr = "UINT_MAX + 1"; EXPECT (mpf_fits_uint_p, 0); mpf_set_ui (f, ULONG_MAX); expr = "ULONG_MAX"; EXPECT (mpf_fits_ulong_p, 1); mpf_set_ui (f, ULONG_MAX); mpf_add (f, f, f0p5); expr = "ULONG_MAX + 0.5"; EXPECT (mpf_fits_ulong_p, 1); mpf_set_ui (f, ULONG_MAX); mpf_add_ui (f, f, 1L); expr = "ULONG_MAX + 1"; EXPECT (mpf_fits_ulong_p, 0); mpf_set_si (f, (long) SHRT_MAX); expr = "SHRT_MAX"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_si (f, (long) SHRT_MAX); expr = "SHRT_MAX + 0.5"; mpf_add (f, f, f0p5); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_si (f, (long) SHRT_MAX); mpf_add_ui (f, f, 1L); expr = "SHRT_MAX + 1"; EXPECT (mpf_fits_sshort_p, 0); mpf_set_si (f, (long) INT_MAX); expr = "INT_MAX"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); mpf_set_si (f, (long) INT_MAX); mpf_add (f, f, f0p5); expr = "INT_MAX + 0.5"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); mpf_set_si (f, (long) INT_MAX); mpf_add_ui (f, f, 1L); expr = "INT_MAX + 1"; EXPECT (mpf_fits_sint_p, 0); mpf_set_si (f, LONG_MAX); expr = "LONG_MAX"; EXPECT (mpf_fits_slong_p, 1); mpf_set_si (f, LONG_MAX); mpf_add (f, f, f0p5); expr = "LONG_MAX + 0.5"; EXPECT (mpf_fits_slong_p, 1); mpf_set_si (f, LONG_MAX); mpf_add_ui (f, f, 1L); expr = "LONG_MAX + 1"; EXPECT (mpf_fits_slong_p, 0); mpf_set_si (f, (long) SHRT_MIN); expr = "SHRT_MIN"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_si (f, (long) SHRT_MIN); mpf_sub (f, f, f0p5); expr = "SHRT_MIN - 0.5"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_si (f, (long) SHRT_MIN); mpf_sub_ui (f, f, 1L); expr = "SHRT_MIN + 1"; EXPECT (mpf_fits_sshort_p, 0); mpf_set_si (f, (long) INT_MIN); expr = "INT_MIN"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); mpf_set_si (f, (long) INT_MIN); mpf_sub (f, f, f0p5); expr = "INT_MIN - 0.5"; EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); mpf_set_si (f, (long) INT_MIN); mpf_sub_ui (f, f, 1L); expr = "INT_MIN + 1"; EXPECT (mpf_fits_sint_p, 0); mpf_set_si (f, LONG_MIN); expr = "LONG_MIN"; EXPECT (mpf_fits_slong_p, 1); mpf_set_si (f, LONG_MIN); mpf_sub (f, f, f0p5); expr = "LONG_MIN - 0.5"; EXPECT (mpf_fits_slong_p, 1); mpf_set_si (f, LONG_MIN); mpf_sub_ui (f, f, 1L); expr = "LONG_MIN + 1"; EXPECT (mpf_fits_slong_p, 0); mpf_set_str_or_abort (f, "0.5", 10); expr = "0.5"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); EXPECT (mpf_fits_ushort_p, 1); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_str_or_abort (f, "-0.5", 10); expr = "-0.5"; EXPECT (mpf_fits_ulong_p, 0); EXPECT (mpf_fits_uint_p, 0); EXPECT (mpf_fits_ushort_p, 0); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_str_or_abort (f, "1.000000000000000000000000000000000001", 16); expr = "1.000000000000000000000000000000000001 base 16"; EXPECT (mpf_fits_ulong_p, 1); EXPECT (mpf_fits_uint_p, 1); EXPECT (mpf_fits_ushort_p, 1); EXPECT (mpf_fits_slong_p, 1); EXPECT (mpf_fits_sint_p, 1); EXPECT (mpf_fits_sshort_p, 1); mpf_set_str_or_abort (f, "1@1000", 16); expr = "1@1000 base 16"; EXPECT (mpf_fits_ulong_p, 0); EXPECT (mpf_fits_uint_p, 0); EXPECT (mpf_fits_ushort_p, 0); EXPECT (mpf_fits_slong_p, 0); EXPECT (mpf_fits_sint_p, 0); EXPECT (mpf_fits_sshort_p, 0); mpf_set_ui (f, 1L); mpf_mul_2exp (f, f, BITS_PER_ULONG + 1); mpf_sub_ui (f, f, 1L); expr = "2^(BITS_PER_ULONG+1) - 1"; EXPECT (mpf_fits_ulong_p, 0); EXPECT (mpf_fits_uint_p, 0); EXPECT (mpf_fits_ushort_p, 0); EXPECT (mpf_fits_slong_p, 0); EXPECT (mpf_fits_sint_p, 0); EXPECT (mpf_fits_sshort_p, 0); mpf_set_ui (f, 1L); mpf_mul_2exp (f, f, BITS_PER_ULONG + 1); mpf_sub_ui (f, f, 1L); mpf_neg (f, f); expr = "- (2^(BITS_PER_ULONG+1) - 1)"; EXPECT (mpf_fits_ulong_p, 0); EXPECT (mpf_fits_uint_p, 0); EXPECT (mpf_fits_ushort_p, 0); EXPECT (mpf_fits_slong_p, 0); EXPECT (mpf_fits_sint_p, 0); EXPECT (mpf_fits_sshort_p, 0); mpf_set_ui (f, 1L); mpf_mul_2exp (f, f, BITS_PER_ULONG + 5); mpf_sub_ui (f, f, 1L); expr = "2^(BITS_PER_ULONG+5) - 1"; EXPECT (mpf_fits_ulong_p, 0); EXPECT (mpf_fits_uint_p, 0); EXPECT (mpf_fits_ushort_p, 0); EXPECT (mpf_fits_slong_p, 0); EXPECT (mpf_fits_sint_p, 0); EXPECT (mpf_fits_sshort_p, 0); if (error) abort (); mpf_clear (f); mpf_clear (f0p5); tests_end (); exit (0); }
void check_rand (int argc, char **argv) { mp_size_t size; mp_exp_t exp; int reps = 20000; int i; mpf_t u, v, w, wref; mp_size_t bprec = 100; mpf_t rerr, max_rerr, limit_rerr; gmp_randstate_t rands; if (argc > 1) { reps = strtol (argv[1], 0, 0); if (argc > 2) bprec = strtol (argv[2], 0, 0); } mpf_set_default_prec (bprec); gmp_randinit_default(rands); mpf_init_set_ui (limit_rerr, 1); mpf_div_2exp (limit_rerr, limit_rerr, bprec); #if VERBOSE mpf_dump (limit_rerr); #endif mpf_init (rerr); mpf_init_set_ui (max_rerr, 0); mpf_init (u); mpf_init (v); mpf_init (w); mpf_init (wref); for (i = 0; i < reps; i++) { size = urandom (rands) % (2 * SIZE) - SIZE; exp = urandom (rands) % SIZE; mpf_rrandomb (u, rands, size, exp); size = urandom (rands) % (2 * SIZE) - SIZE; exp = urandom (rands) % SIZE; mpf_rrandomb (v, rands, size, exp); if ((urandom (rands) & 1) != 0) mpf_add_ui (u, v, 1); else if ((urandom (rands) & 1) != 0) mpf_sub_ui (u, v, 1); mpf_sub (w, u, v); refmpf_sub (wref, u, v); mpf_reldiff (rerr, w, wref); if (mpf_cmp (rerr, max_rerr) > 0) { mpf_set (max_rerr, rerr); #if VERBOSE mpf_dump (max_rerr); #endif if (mpf_cmp (rerr, limit_rerr) > 0) { printf ("ERROR after %d tests\n", i); printf (" u = "); mpf_dump (u); printf (" v = "); mpf_dump (v); printf ("wref = "); mpf_dump (wref); printf (" w = "); mpf_dump (w); abort (); } } } mpf_clear (limit_rerr); mpf_clear (rerr); mpf_clear (max_rerr); mpf_clear (u); mpf_clear (v); mpf_clear (w); mpf_clear (wref); gmp_randclear(rands); }
int main() { pthread_t thread_a, thread_b; /* My threads*/ int i; FILE *filePi, *fileTime; clock_t start, end; double cpu_time_used; mpf_set_default_prec(BITS_PER_DIGIT * 11000000); /* Borwein Variable Initialization */ for(i=0; i<2; i++) for(j=0; j<2; j++) mpf_init(params[i][j]); mpf_init(real_pi); mpf_init(y0Aux); mpf_init(y0Aux2); mpf_init(a0Aux); mpf_init(a0Aux2); mpf_init(pi[0]); mpf_init(pi[1]); mpf_init_set_str(error, "1e-10000000", 10); /* Initial value setting */ mpf_sqrt_ui(params[A][0], 2.0); /* a0 = sqrt(2)*/ mpf_mul_ui(params[A][0], params[A][0], 4.0); /* a0 = 4 * sqrt(2) */ mpf_ui_sub(params[A][0], 6.0, params[A][0]); /* a0 = 6 - 4 * sqrt(2) */ mpf_sqrt_ui(params[Y][0], 2.0); /* y0 = sqrt(2) */ mpf_sub_ui(params[Y][0], params[Y][0], 1.0); /* y0 = sqrt(2) - 1 */ mpf_set_ui(pi[0], 0); mpf_set_ui(pi[1], 0); i = 1; j = 1; iteracoes = 0; x = 0; /* Load the reals digits of pi */ filePi = fopen("pi.txt", "r"); gmp_fscanf(filePi, "%Ff", real_pi); fclose(filePi); start = clock(); while(1){ /* y = ( 1 - (1 - y0 ^ 4) ^ 0.25 ) / ( 1 + ( 1 - y0 ^ 4) ^ 0.25 ) */ mpf_pow_ui(y0Aux, params[Y][0], 4); mpf_ui_sub(y0Aux, 1.0, y0Aux); mpf_sqrt(y0Aux, y0Aux); mpf_sqrt(y0Aux, y0Aux); mpf_add_ui(y0Aux2, y0Aux, 1.0); mpf_ui_sub(y0Aux, 1.0, y0Aux); mpf_div(params[Y][1], y0Aux, y0Aux2); /* a = a0 * ( 1 + params[Y][1] ) ^ 4 - 2 ^ ( 2 * i + 3 ) * params[Y][1] * ( 1 + params[Y][1] + params[Y][1] ^ 2 ) */ /* Threads creation */ pthread_create(&thread_a, NULL, calc_a, NULL); pthread_create(&thread_b, NULL, calc_b, NULL); pthread_join(thread_a, NULL); pthread_join(thread_b, NULL); /* 2 ^ ( 2 * i + 3 ) * params[Y][1] * ( 1 + params[Y][1] + params[Y][1] ^ 2 ) */ mpf_mul(a0Aux, a0Aux, a0Aux2); /*a0 * ( 1 + params[Y][1] ) ^ 4*/ mpf_add_ui(a0Aux2, params[Y][1], 1); mpf_pow_ui(a0Aux2, a0Aux2, 4); mpf_mul(a0Aux2, params[A][0], a0Aux2); /* form the entire expression */ mpf_sub(params[A][1], a0Aux2, a0Aux); mpf_set(params[A][0], params[A][1]); mpf_set(params[Y][0], params[Y][1]); mpf_ui_div(pi[j], 1, params[A][0]); gmp_printf("\nIteracao %d | pi = %.25Ff", iteracoes, pi[j]); /* Calculate the error */ mpf_sub(pi[(j+1)%2], real_pi, pi[j]); mpf_abs(pi[(j+1) % 2], pi[(j+1) % 2]); if(mpf_cmp(pi[(j+1)%2], error) < 0){ printf("\n%d iteracoes para alcancar 10 milhoes de digitos de corretos.", iteracoes); break; } j = (j+1) % 2; iteracoes++; i++; } end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; fileTime = fopen("execution_time.txt", "w"); fprintf(fileTime, "Execution time: %f\n", cpu_time_used); fclose(fileTime); /* Clean up*/ for(i=0; i<2; i++) for(j=0; j<2; j++) mpf_clear(params[i][j]); mpf_clear(pi[0]); mpf_clear(pi[1]); mpf_clear(real_pi); mpf_clear(error); return 0; }
/** * Algoritmo de Borwein * * a1 se aproxima do valor de 1/PI. * Cada iteração quadruplica o número de dígitos corretos. * */ void gmp_borwein() { /*variáveis para calculo com respectivos valores iniciais*/ mpf_t a0, a1, y0, y1, aux1, aux2; /*contador de iterações*/ long unsigned int k=0; //mpf_set_default_prec(33220); /*define a precisao do float em bits*/ mpf_set_default_prec(33219280);//(33219280); /*define a precisao do float em bits*/ mpf_init(a0),mpf_init(a1),mpf_init(y0),mpf_init(y1),mpf_init(aux1),mpf_init(aux2); /*Inicializa as variáveis em 0*/ /*seta os valores inicias das váriaveis de precisão variável*/ /*a0 = 6-4*sqrt(2)*/ mpf_set_ui(aux1,2); mpf_sqrt(aux1,aux1); /*sqrt(2)*/ mpf_mul_ui(a0,aux1,4); mpf_ui_sub(a0,6,a0); //mpf_set_d(a0, 6-4*sqrt(2)); mpf_sub_ui(y0,aux1,1); /*y0 = sqrt(2)-1*/ while(k<12) { /*y1 = (1-sqrt(sqrt((1-pow(y0,4))))) / (1+sqrt(sqrt(1-pow(y0,4))));*/ mpf_pow_ui(y1,y0,4); /*y1 = pow(y0,4)*/ mpf_ui_sub(y1,1,y1); /*y1 = 1 - y1*/ mpf_sqrt(y1,y1); mpf_sqrt(y1,y1); mpf_ui_sub(aux1,1,y1); mpf_add_ui(aux2,y1,1); mpf_div(y1,aux1,aux2); /*a1 = a0*pow(1 + y1,4) - pow(2,2*k+3)*y1*(1+y1+pow(y1,2));*/ mpf_add_ui(a1,y1,1); /*a1 = y1+1*/ mpf_pow_ui(a1,a1,4); /*a1 = a1^4*/ mpf_mul(a1,a0,a1); /*a1 = a0*a1*/ mpf_pow_ui(aux2,y1,2); /*aux2 = pow(y1,2)*/ mpf_add(aux2,aux2,y1); /*aux2 += y1*/ mpf_add_ui(aux2,aux2,1); /*aux2++*/ mpf_mul(aux2,aux2,y1); /*aux2 *= y1*/ mpf_set_ui(aux1,2); /* aux1=2 */ mpf_pow_ui(aux1,aux1,2*k+3); /* aux1 = pow(aux1,2*k+3)*/ mpf_mul(aux1,aux1,aux2); /*aux1 = aux1*aux2*/ mpf_sub(a1,a1,aux1); /*troca os valores das variáveis de maneira eficiente*/ mpf_swap(a0,a1); mpf_swap(y0,y1); k++; /*gmp_printf("k=%ld, y1=%.*Ff, 1/PI=%.*Ff\n", k, 20, y1, 20, a1); gmp_printf("a0=%.*Ff, y0=%.*Ff\n", 20, a0, 20, y0);*/ } mpf_ui_div(a1,1,a1); /*PI=1/a1*/ gmp_printf("%.*Ff\n",10000000,a1); mpf_clear(a0),mpf_clear(a1),mpf_clear(y0),mpf_clear(y1),mpf_clear(aux1),mpf_clear(aux2); /*Limpa as variáveis da memória*/ }
int main () { int i = 0; /*Contador de iterações*/ int k = 8; /*Fator de multiplicação*/ mpf_t pi_pas, pi_novo; mpf_t a_pas, a_novo; mpf_t y_pas, y_novo; mpf_t temp1, temp2; mpf_t e; FILE *fileTime; /*Ponteiro do arquivo de saída*/ clock_t start, end; double cpu_time_used; mpf_set_default_prec(BITS_PER_DIGIT * 11000000); /*Precisão default*/ /*Inicialização das variáveis*/ mpf_init(pi_pas); mpf_init(pi_novo); mpf_init(a_pas); mpf_init(y_pas); mpf_init(temp1); mpf_init(temp2); mpf_init_set_d(a_novo, 32.0); mpf_sqrt(a_novo, a_novo); mpf_ui_sub(a_novo, 6, a_novo); mpf_init_set_d(y_novo, 2.0); mpf_sqrt(y_novo, y_novo); mpf_sub_ui(y_novo, y_novo, 1); mpf_init_set_str(e, "1e-10000000", 10); mpf_ui_div(pi_novo, 1, a_novo); start = clock(); /*Calcula as iterações*/ do { mpf_swap(pi_pas, pi_novo); mpf_swap(a_pas, a_novo); mpf_swap(y_pas, y_novo); mpf_pow_ui(y_pas, y_pas, 4); mpf_ui_sub(y_pas, 1, y_pas); mpf_sqrt(y_pas, y_pas); mpf_sqrt(y_pas, y_pas); mpf_add_ui(temp1, y_pas, 1); mpf_ui_sub(y_novo, 1, y_pas); mpf_div(y_novo, y_novo, temp1); mpf_add_ui(temp1, y_novo, 1); mpf_pow_ui(temp2, y_novo, 2); mpf_add(temp2, temp2, temp1); mpf_mul(temp2, temp2, y_novo); mpf_mul_ui(temp2, temp2, k); k *= 4; mpf_pow_ui(temp1, temp1, 4); mpf_mul(temp1, temp1, a_pas); mpf_sub(a_novo, temp1, temp2); mpf_ui_div(pi_novo, 1, a_novo); mpf_sub(pi_pas, pi_novo, pi_pas); mpf_abs(pi_pas, pi_pas); gmp_printf("\nIteracao %d | pi = %.25Ff", i, pi_novo); i++; } while ( mpf_cmp(e, pi_pas) < 0 ); end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; fileTime = fopen("execution_time.txt", "w"); fprintf(fileTime, "Execution time: %f\n", cpu_time_used); fclose(fileTime); /*Libera espaço de memória*/ mpf_clear(pi_pas); mpf_clear(pi_novo); mpf_clear(a_pas); mpf_clear(a_novo); mpf_clear(y_pas); mpf_clear(y_novo); mpf_clear(temp1); mpf_clear(temp2); mpf_clear(e); return 0; }
/** * Algoritmo de Borwein * * vars.a1 se aproxima do valor de 1/PI. * Cada iteração quadruplica o número de dígitos corretos. * */ void gmp_borwein_par() { /*threads*/ pthread_t init[9], calc[4]; /*variáveis para calculos*/ thr_gmpf_t vars; mpf_set_default_prec(33219280);//(33219280); /*define a precisao do float em bits*/ vars.k = 0; /*Seta o valor inicial do iterador*/ calc[1] = 0; calc[3] = 0; /*Inicializa as variáveis em 0*/ pthread_create(&init[0],NULL,(void *)&mpf_init,(void *)&vars.a0); pthread_create(&init[1],NULL,(void *)&mpf_init,(void *)&vars.a1); pthread_create(&init[2],NULL,(void *)&mpf_init,(void *)&vars.y0); pthread_create(&init[3],NULL,(void *)&mpf_init,(void *)&vars.y1); pthread_create(&init[4],NULL,(void *)&mpf_init,(void *)&vars.aux_y1); pthread_create(&init[5],NULL,(void *)&mpf_init,(void *)&vars.aux_y2); pthread_create(&init[6],NULL,(void *)&mpf_init,(void *)&vars.aux_a1); pthread_create(&init[7],NULL,(void *)&mpf_init,(void *)&vars.aux_a2); pthread_create(&init[8],NULL,(void *)&mpf_init,(void *)&vars.y_valoratual); /*A função espera as variáveis serem atualizadas*/ pthread_join(init[0],NULL); pthread_join(init[1],NULL); pthread_join(init[2],NULL); pthread_join(init[3],NULL); pthread_join(init[4],NULL); pthread_join(init[5],NULL); pthread_join(init[6],NULL); pthread_join(init[7],NULL); pthread_join(init[8],NULL); /*TODO: verificar se é possível fazer os cálculos abaixo assim que a variável for inicializada acima*/ /*seta os valores inicias das váriaveis de precisão variável*/ /*d = sqrt(2)*/ mpf_set_ui(vars.aux_y1,2); mpf_sqrt(vars.aux_y1,vars.aux_y1); /*a0 = 6-4*d*/ mpf_mul_ui(vars.a0,vars.aux_y1,4); mpf_ui_sub(vars.a0,6,vars.a0); mpf_set(vars.a1,vars.a0); //a1=a0 /*y0 = d-1*/ mpf_sub_ui(vars.y0,vars.aux_y1,1); /*vars.y0 = sqrt(2)-1*/ while(vars.k<12) { /*Certifica que o valor de y está atualizado antes de calcular o próximo valor de y*/ if(calc[3] != 0) pthread_join(calc[3],NULL); pthread_create(&calc[0], NULL, (void *) &calc_y, (void *)&vars); //calcula valor de y-> nao depende de a nem de k, só do y anterior /*Certifica que a já foi calculado antes de fazer a0=a1*/ if(calc[1] != 0) pthread_join(calc[1],NULL); pthread_create(&calc[2], NULL, (void *) &mpf_seta_thread, (void *)&vars); //troca o valor de a pthread_join(calc[0],NULL); mpf_set(vars.y_valoratual,vars.y1); //seta o valor de y que será usado para calcular a /*Troca o valor de y0=y1*/ pthread_create(&calc[3], NULL, (void *) &mpf_sety_thread, (void *)&vars); pthread_join(calc[2],NULL); /*Calcula o novo valor de a*/ pthread_create(&calc[1], NULL, (void *) &calc_a, (void *)&vars); } mpf_ui_div(vars.a1,1,vars.a1); /*PI=1/vars.a1*/ gmp_printf("%.*Ff\n",10000000,vars.a1); /*Limpa as variáveis da memória*/ mpf_clear(vars.a0),mpf_clear(vars.a1),mpf_clear(vars.y0),mpf_clear(vars.y1); mpf_clear(vars.aux_y1),mpf_clear(vars.aux_y2),mpf_clear(vars.aux_a1),mpf_clear(vars.aux_a2); mpf_clear(vars.y_valoratual); }