Ejemplo n.º 1
0
/**
 * 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;
}
Ejemplo n.º 2
0
Float::Float(const char* str)
{
  const int result = mpf_init_set_str(value, str, 10);

  if (result != 0)
    CFD_EXCEPTION("Invalid specification for floating point value.");
}
Ejemplo n.º 3
0
bool sg_big_float_check_num_str(const char *float_str, enum sg_num_sys sys)
{
    mpf_t z;
    float base = SG_COMPUTE_BASE(sys);

    if (!float_str || !base)
        return false;

    return mpf_init_set_str(z, float_str, base) == 0;
}
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;
}
Ejemplo n.º 5
0
Archivo: util.c Proyecto: tyru/dentaku
void
token2digit(Digit *digit, Token *tok, int base)
{
    mpf_init_set_str(*digit, tok->str, base);
}
Ejemplo n.º 6
0
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;
}