Foro de elhacker.net

Buenas, en estos días estaba por aquí un alguien preguntando sobre un programa básico con pi, por cosas de la vida, decidí ahondar en el tema... calcular pi con alta precisión...

deja claro que el siguiente tema no lo hago en pro de discutir la naturaleza de pi, ni nada al respecto, es solo en pro del calculo de alta precisión ;)

aquí básicamente solo hay 2 temas importantes que abordar

-¿qué formula usar?
-¿como calculo números en alta precisión?

con lo primero... la formula, decidí usar la de euler
(http://upload.wikimedia.org/math/6/3/1/63133aa55473a0e625a4684655831463.png)
escogí esta por su precisión y su relativamente fácil aplicación

para aplicarla la tenemos que separar en 2 partes por su sumatoria y su factorial...

sumatoria = factorial = 1;
for(i=1;i<ciclos;i++){
    factorial *= i/(i*2+1);
    sumatoria += factorial;
}
sumatoria *=2;
pi = sumatoria
 

ahí resolvemos esa formula básicamente... pero nos damos cuenta de un problema... los numeros double están limitados a 64 bits... unos 20 decimales para nuestro caso...

en este caso viene la aritmetica de alta precisión, GMP... aquí (http://foro.elhacker.net/programacion_cc/duda_matematica_de_precision_arbitraria-t412080.0.html;msg1933292#msg1933292) en el foro buscaba como usarlo... al final conseguí y publiqué el como...

este usa unidades especificas y operaciones especificas para alta precisión...

doy una ligera explicación de lo usado... no voy a caer en mucho detalle de las funciones...
mpf_t es una variable de tipo "float" propia
mpf_set_default_prec da el valor en bytes que la variable usará
mpf_init_set_str inicializa las variables desde un string... por que un string? porque quise -.-... se hay que inicializar las variables obligatoriamente

mpf_set_ui da un valor desde un entero sin signo a un float
div= division, mul = multiplicaccion, add= adición

mpf_get_str convierte de float de GMP a char* (string)

como no habia una multiplicacion / asignacion directa, me tocó usar una variable de intercambio


ahora la parte interesante... el codigo  ;-)

hice un pequeño/bonito formato de impresión de 10 en 10 dígitos... en  lineas de 50 y bloques de 500 con el numero de dígito como indicador... probé solo hasta 40.000 dígitos, comprobando en internet precisos... pero en 5min 9 seg! :P es mi único intento en este campo... no esperen romper el record mundial de decimales ;P por cierto... de ahí en adelante, los dígitos son cuesta arriba... así que cuidado con el tiempo... pueden usar el programa pasando el numero de dígitos como argumento... los dígitos los toma en cuanta de 100 en 100

pd: la precisión la hago como  "precision = digitos * 100 * 3 * 1.12" porque descubrí que se requieren 3 ciclos por dígito correcto sobre los 100 con un 12% de error (calculado a ojo) :P



librerias

#include <iostream>
#include <stdlib.h>
#include <string>
#include <gmp.h>
#include <gmpxx.h>
#include <time.h>
#include <sstream>
using namespace std; // :P
 

prototipos

string metodo_euler(unsigned long int digitos, mp_exp_t &exponente);
string metodo_ramanujan(unsigned long int digitos, mp_exp_t &exponente);
void imprimir_pi_aux(string pi, mp_exp_t exponente, int digitos);

main

int main(int argc, char **argv) {
    unsigned long int digitos = strtol(argv[1], NULL, 10); //argv a int
    mpf_set_default_prec(32 * 10 * (digitos / 100) * 1.11); //precision + 10%
    long exponente;
    clock_t start = clock();
    string pi;
    int metodo = 0;
    int i = 1;
    for (i = 0; i < argc; i++) {
        if (argv[i][0] == '-') {
            switch (argv[i][1]) {
                case 'e':
                    metodo = 0;
                    break;
                case 'r':
                    metodo = 1;
                    break;
            }
        }
    }
    switch (metodo) {
        case 0:
            cout << "imprimiendo por metodo Euler, " << digitos * 3 * 1.12 << " ciclos"<<endl;
            pi = metodo_euler(digitos, exponente);
            break;
        case 1:
            cout << "imprimiendo por metodo Ramanujan, " << (int) (digitos / 8 * 1.01) << " ciclos"<<endl;
            pi = metodo_ramanujan(digitos, exponente);
            break;
    }
 
    clock_t end = clock();
 
    imprimir_pi_aux(pi, exponente, digitos);
    cout << "\ntiempo total de ejecucion: " << (float) (end - start) / CLOCKS_PER_SEC << "\n";
    cout << "tiempo total de impresion: " << (float) (clock() - end) / CLOCKS_PER_SEC << "\n\n";
    return 0;
}

tiene 2 argumentos... primero los digitos (obligatorio)... luego -r para ramanujan o -e para euler (opcional, euler predeterminado)

imprimir_pi_aux

para tener un formato único de impresión para todo

void imprimir_pi_aux(string pi, long exponente, int digitos) {
    cout << "Pi: ";
    stringstream aux;
    unsigned long int i;
    if (exponente <= 0) {
        cout << "0.";
        while (exponente < 0) {
            cout << 0;
            exponente++;
        }
    } else {
        for (i = 0; i < exponente; i++) {
            cout << pi[i];
        }
        cout << ".\n\n1:\t";
    }
    for (i = exponente; i < digitos + 1; i++) {
        aux << pi[i];
        if ((i - exponente + 1) % 10 == 0) aux << ' ';
        if ((i - exponente + 1) % 500 == 0) aux << endl;
        if ((i - exponente + 1) % 50 == 0 && i < digitos) aux << endl << i + 1 << ":\t";
    }
    aux << endl;
    cout << aux.str();
}

aux por consejo de amchacon

metodo_euler

corto, simple, pero largo... para 10.000 dígitos 33.600 ciclos o para mi unos 11 seg

basado en la formula

(http://upload.wikimedia.org/math/6/3/1/63133aa55473a0e625a4684655831463.png)

string metodo_euler(unsigned long int digitos, long &exponente) {
    digitos /= 100; //trabaja con lotes de 100
    unsigned long int precision = digitos * 100 * 3 * 1.12;
    unsigned long int x, i;
    mpf_t factorial, sumatoria, buff_factorial; //variables GMP
    mpf_init_set_ui(factorial, 1); //factorial=1
    mpf_init_set_ui(sumatoria, 1); //sumatoria=1
    mpf_init_set_ui(buff_factorial, 1); //buff_factorial=1
 
    for (x = 1; x < precision; x++) {
        i = 2 * x + 1;
        mpf_set_ui(buff_factorial, x); //buff_factorial=x
        mpf_div_ui(buff_factorial, buff_factorial, i); //buff_factorial*=i
        mpf_mul(factorial, factorial, buff_factorial); //factorial*=buff_factorial
        mpf_add(sumatoria, sumatoria, factorial); //sumatoria+=factorial
    }
    mpf_mul_ui(sumatoria, sumatoria, 2); //sumatoria*=2
    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
}

metodo_ramanujan

por consejo de do-while, basado en la formula

eficiente, pero dificil de aplicar (si no, miren el codigo de abajo)
para 10.000 digitos 1.262 ciclos en 1.1 segundos

(http://upload.wikimedia.org/math/3/c/c/3cca05380343cb6f78d776d5e40b3a9d.png)

string metodo_ramanujan(unsigned long int digitos, long &exponente) {
    digitos /= 8;
    digitos *= 1.01;
    unsigned long int i, j;
    mpf_t sumatoria, buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior, primera_parte,
            buff_ciclo_inferior2, factorial_superior, factorial_inferior;
    mpf_init_set_ui(sumatoria, 1103); //sumatoria=0
    mpf_init_set_ui(buff_sumatoria, 0); //buff_sumatoria=0
    mpf_init_set_ui(buff_ciclo_superior, 0); //buff_ciclo_superior=0
    mpf_init_set_ui(buff_ciclo_inferior, 0); //buff_ciclo_inferior=0
    mpf_init_set_ui(primera_parte, 0); //primera_parte=0
    mpf_init_set_ui(buff_ciclo_inferior2, 0); //buff_ciclo_inferior2=0
    mpf_init_set_ui(factorial_superior, 1); //factorial_superior=1
    mpf_init_set_ui(factorial_inferior, 1); //factorial_inferior=1
    mpf_sqrt_ui(primera_parte, 2); //primera_parte=sqrt(2)
    mpf_mul_ui(primera_parte, primera_parte, 2); //primera_parte*=2
    mpf_div_ui(primera_parte, primera_parte, 9801); //primera_parte/=9801
 
    for (i = 1; i <= digitos; i++) {
        for (j = (i - 1)*4 + 1; j <= i * 4; j++) {
            mpf_mul_ui(factorial_superior, factorial_superior, j);
        }
        mpf_set_ui(buff_ciclo_superior, 26390);
        mpf_mul_ui(buff_ciclo_superior, buff_ciclo_superior, i);
        mpf_add_ui(buff_ciclo_superior, buff_ciclo_superior, 1103);
        mpf_mul(buff_ciclo_superior, buff_ciclo_superior, factorial_superior);
        mpf_mul_ui(factorial_inferior, factorial_inferior, i);
        mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
        mpf_set_ui(buff_ciclo_inferior2, 396);
        mpf_pow_ui(buff_ciclo_inferior2, buff_ciclo_inferior2, 4 * i);
        mpf_mul(buff_ciclo_inferior, buff_ciclo_inferior, buff_ciclo_inferior2);
        mpf_div(buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior);
        mpf_add(sumatoria, sumatoria, buff_sumatoria);
 
    }
    mpf_mul(sumatoria, sumatoria, primera_parte);
    mpf_ui_div(sumatoria, 1, sumatoria);
    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
}

Interesante  ;-)

Hace algunos años (como por el 2009) tuve la idea realizar un programa para calcular PI con la mayor cantidad de dígitos pero al investigar, métodos, métodos, algoritmos, proyectos me topé con la sorpresa que en ese tiempo se habían calculado 2.5 trillones de dígitos decimales

Creo que el nuevo record está en 10 trillones de dígitos decimales  :xD

:http://www.numberworld.org/digits/Pi/

Pero me parece interesantes algunas deducciones que hiciste en tu implementación.

PD. Por ahora tengo la idea de hacer un colisionador md5  :silbar:

Está muy bien. Una alternativa al problema de la velocidad, podría ser ir introduciendo cifra a cifra en un fichero. Pero eso ya sale del tema, ya que cambiaría el algoritmo xD

Got to be Fucking Kidding me  :o :o :o :o :o :o :o

Excelente código

Las asignaciones de este tipo de números son muy lentas. Si puedes evitarte usar esa variable auxiliar aumentarías velocidad.

Y bueno el cout es muyyyyyyyy lento, tardarías menos en imprimir haciendo así:

#include <sstream>
 
//....
 
string valor = mpf_get_str(NULL, &buff, 10, 0, sumatoria);
stringstream aux;
 
for (i = 1; i < digitos * 100 + 1; i++) {
       aux << valor[i];
       if (i % 10 == 0) aux << ' ';
       if (i % 500 == 0) aux << endl;
       if (i % 50 == 0 && i < digitos * 100) aux <<endl << i + 1 << ":\t";
}
aux << endl;
 
cout<<aux.str();
 

en realidad no me preocupé del cout porque la diferencia ue causa es baja, si calculan 10000 decimales, haces unos 33000 calculos con 3 variables de 35kb xD e imprimir 35kb no toma sino unas décimas de segundo por lento que sea :p pero lo voy a hacer con printf me dió pereza hacerlo anoche

por otro lado no se puede hacet cifra a cifra ya que el resultado es la combinación de factoriales sumatorias y potencias, el numero siempre debe debe ser reusado

El problema no es imprimir muchos datos, sino el acceso a pantalla. Cada vez que adcedes a pantalla el programa se "congela" hasta que se refresque.

Por eso he condensado toda tu salida en un solo string, para que haga un solo acceso a pantalla.

PD: Si crees que la diferencia de tiempo es baja, te invito a poner un simple cout en el bucle de cálculo. A ver la diferencia de tiempos ;D

http://www.mscs.dal.ca/~selinger/md5collision/ (http://www.mscs.dal.ca/~selinger/md5collision/)

Saludos!

Interesante el tema... Ya solo falta que haya un contador en la consola diciendo cuantos decimales se han calculado y los segundos requeridos :)

Un saludo.

ikillnukes tambien a eso voy, segundo argumento sin salida, solo para ver el tiempo del calculo, los decimales calculados correctos no es tan simple fijate que yo genero decimales de mas, para asegurar el valor correcto, si ves.el metodo de euler ves que casi siempre da decimales periódicos

próximo a probar:salida concatenada a archivo, tiempo de ejecución, alguna sugerencia?

¡Buenas!

Si te interesa el tema de pi, hay por ahí una formula de Ramanujan (http://es.wikipedia.org/wiki/Srinivasa_Aiyangar_Ramanujan) que calcula 8 decimales por iteración (era un fiera).

¡Saludos!

gracias do-while! :P vamos con esa! voy a extender el programa... ya llegué a mi casa, tengo 1,5l de te negro listos y 250g de maní japonés! ese código sale en un rato! :P

No sé mucho de c++, apenas estoy en pañales pero tal vez esto te pueda servir.
De hecho la idea viene de un programa que hice en otro lenguaje pero tratando de implementarlo en c++, aunque tal vez necesitas algo más "exacto" (microsegundos, aunque creo que los ordenadores no trabajan a ese nivel)

Además parece haber un fallo en mi método xD

#include <iostream>
#include <ctime>
 
using namespace std;
 
int main() {
 
    clock_t tiempo_inicial = clock();
 
    //Alguna función
    for(int indice=0;indice<=10000;indice=indice+1) {
        std::cout << indice << endl;
    }
    clock_t tiempo_final = clock();
 
    std::cout << float( tiempo_final - tiempo_inicial ) /  CLOCKS_PER_SEC << " segundos";
 
    return 0;
}
 

Lo que me causa intriga es lo siguiente:  :¬¬

la  ecuación de Ramanujan es una locura @.@ es un poco dificil de aplicar... sin embargo dudo de su eficiencia al momento de procesar, ya que a diferencia de la de euler es muy compleja, tiene 2 factoriales diferentes (y el de arriba es grande, con k = 3 el valor es de 479.001.600) la de abajo tiene 2 potencias y la segunda es de 4*k, haciéndola sin funciones matemáticas precompiladas sería

for(i=1;i<precision;i++){
for(j=1;j<=4*i;j++){
  factorial1*=j;
}
for(j=1;j<=i;j++){
  factorial2*=j;
}
for(j=1;j<=4;j++){
  factorial2*=factorial2;
}
for(j=1;j<=4*i;j++){
  divisor*=396;
}
sumatoria+=(factorial1*(1103+26390*i))/(factorial2*divisor)
 
}
sumatoria=1/sumatoria
 

el código sobre eso se puede optimizar pero igual son muchos ciclos dentro de cada ciclo (cuando precision = 1.000; tendrá que hacer por lo menos 4.000.000 de ciclos secundarios los cuales multiplicarán valores muy grandes, esto sin contar que sería solo para obtener 8.000 dígitos teóricos...)


la de euler es simple y hasta bonita XD solo requiere en ciclo principal y unas pocas operaciones

aqui la formula de Ramanujan
(http://upload.wikimedia.org/math/3/c/c/3cca05380343cb6f78d776d5e40b3a9d.png)

cambié un poco el programa para hacerlo más modular...

ya se me hizo tarde... así que ni argumentos (más que ramanujan), ni corrida silenciosa, ni salida a archivo! :P sorry por ahora... estoy cansado  :(

agregado por ahora, ramanujan (no da pi... si alguien me ayuda con esto, sobre donde me equivoco...), tiempo de calculo e impresion


por cierto amchacon sobre el tiempo de impresión incluso a 40.000 decimales la diferencia es instrumental, no llega al medio segundo de diferencia :P

aquí el código... se está tornando largo D:

#include <iostream>
#include <stdlib.h>
#include <string>
#include <gmp.h>
#include <gmpxx.h>
#include <time.h>
#include <sstream>
 
using namespace std;
string metodo_euler(unsigned long int digitos, mp_exp_t &exponente);
string metodo_ramanujan(unsigned long int digitos, mp_exp_t &exponente);
void imprimir_pi_aux(string pi, mp_exp_t exponente, int digitos);
 
int main(int argc, char **argv) {
 
    unsigned long int digitos = strtol(argv[1], NULL, 10); //argv a int
    mpf_set_default_prec(32 * 10 * (digitos / 100) * 1.11); //precision + 10%
    long exponente;
    clock_t start = clock();
    string pi;
    if(argc>2 && argv[2]=="ramanujan"){
        pi = metodo_ramanujan(digitos, exponente);
    }else{
        pi = metodo_euler(digitos, exponente);
    }
    clock_t end = clock();
    imprimir_pi_aux(pi, exponente, digitos);
    cout << "\ntiempo total de ejecucion: " << (float) (end - start) / CLOCKS_PER_SEC << "\n";
    cout << "tiempo total de impresion: " << (float) (clock() - end) / CLOCKS_PER_SEC << "\n\n";
    return 0;
}
 
void imprimir_pi_aux(string pi, long exponente, int digitos) {
    cout << "PI: ";
    stringstream aux;
    unsigned long int i;
    if (exponente < 0) {
        cout << "0.";
        while (exponente < 0) {
            cout << 0;
            exponente++;
        }
    } else {
        for (i = 0; i < exponente; i++) {
            cout << pi[i];
        }
        cout << ".\n\n1:\t";
    }
    for (i = exponente; i < digitos + 1; i++) {
        aux << pi[i];
        if (i % 10 == 0) aux << ' ';
        if (i % 500 == 0) aux << endl;
        if (i % 50 == 0 && i < digitos) aux << endl << i + 1 << ":\t";
    }
    aux << endl;
    cout << aux.str();
}
string metodo_euler(unsigned long int digitos, long &exponente) {
    digitos /= 100; //trabaja con lotes de 100
    unsigned long int precision = digitos * 100 * 3 * 1.12;
    unsigned long int x, i;
    mpf_t factorial, sumatoria, buff_factorial; //variables GMP
    mpf_init_set_ui(factorial, 1); //factorial=1
    mpf_init_set_ui(sumatoria, 1); //sumatoria=1
    mpf_init_set_ui(buff_factorial, 1); //buff_factorial=1
 
    for (x = 1; x < precision; x++) {
        i = 2 * x + 1;
        mpf_set_ui(buff_factorial, x); //buff_factorial=x
        mpf_div_ui(buff_factorial, buff_factorial, i); //buff_factorial*=i
        mpf_mul(factorial, factorial, buff_factorial); //factorial*=buff_factorial
        mpf_add(sumatoria, sumatoria, factorial); //sumatoria+=factorial
    }
    mpf_mul_ui(sumatoria, sumatoria, 2); //sumatoria*=2
    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
}
 
string metodo_ramanujan(unsigned long int digitos, long &exponente) {
    unsigned long int i, j;
    mpf_t sumatoria, buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior, primera_parte,
            buff_ciclo_inferior2, factorial_superior, factorial_inferior;
    mpf_init_set_ui(sumatoria, 1103); //sumatoria=0
    mpf_init_set_ui(buff_sumatoria, 0); //buff_sumatoria=0
    mpf_init_set_ui(buff_ciclo_superior, 0); //buff_ciclo_superior=0
    mpf_init_set_ui(buff_ciclo_inferior, 0); //buff_ciclo_inferior=0
    mpf_init_set_ui(primera_parte, 0); //primera_parte=0
    mpf_init_set_ui(buff_ciclo_inferior2, 0); //buff_ciclo_inferior2=0
    mpf_init_set_ui(factorial_superior, 1); //factorial_superior=1
    mpf_init_set_ui(factorial_inferior, 1); //factorial_inferior=1
    mpf_sqrt_ui(primera_parte, 2); //primera_parte=sqrt(2)
    mpf_mul_ui(primera_parte, primera_parte, 2); //primera_parte*=2
    mpf_div_ui(primera_parte, primera_parte, 9801); //primera_parte/=9801
 
    for (i = 1; i <= digitos; i++) {
        mpf_set_ui(factorial_superior, 1);
        for (j = 2; j <= i * 4; j++) {
            mpf_mul_ui(factorial_superior, factorial_superior, j);
        }
        mpf_set_ui(buff_ciclo_superior, 26390);
        mpf_mul_ui(buff_ciclo_superior, buff_ciclo_superior, i);
        mpf_add_ui(buff_ciclo_superior, buff_ciclo_superior, 1103);
        mpf_mul(buff_ciclo_superior, buff_ciclo_superior, factorial_superior);
 
        mpf_mul_ui(factorial_inferior, factorial_inferior, i);
        mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
        mpf_set_ui(buff_ciclo_inferior2, 396);
        mpf_pow_ui(buff_ciclo_inferior2, buff_ciclo_inferior2, 4 * i);
        mpf_mul(buff_ciclo_inferior, buff_ciclo_inferior, buff_ciclo_inferior2);
 
        mpf_div(buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior);
        mpf_add(sumatoria, sumatoria, buff_sumatoria);   
    }
    mpf_mul(sumatoria, sumatoria, primera_parte);
    mpf_ui_div(sumatoria, 1, sumatoria);
    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
}

¡Buenas!

Te ha faltado calcular el factorial inferior:
Tu código:

        mpf_mul_ui(factorial_inferior, factorial_inferior, i); //linea 104
       mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
 

Corregido:

        mpf_set_ui(factorial_inferior, 1);
       for (j = 2; j <= i ; j++) {
           mpf_mul_ui(factorial_inferior, factorial_inferior, j);
       }
       mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
 

Creo que eso era todo.

¡Saludos!

no, el factorial inferior si se calcula, lo hago igual que el de euler, es decir como es un factorial que crece de 1 en 1 uso el ciclo principal para evitar hacer más ciclos

fíjate que el factorial superior inicia reasignándose y el inferior no... pero me diste una idea para hacer algo similar con el superior

El factorial inferior lo tienes que recalcular en cada iteracion. No es el factorial de n, siendo n el numero de iteraciones. Para cada iteración k es el factorial de k. Si dices que no te da el resultado, en algún punto tiene que haber un error. ¿No?

Además, de la forma en la que lo haces no estas calculando el factorial de nada. Estas multiplicando un acumulador por el numero de ciclo y luego lo elevas a 4, lo multiplicas por el siguiente contador de ciclo y lo vuelves a elevar a 4. Eso no es lo que indica la fórmula...

mira como lo hice en euler :P

si tengo un error, pero hice ya el debug porque justamente se que esa es la principal posible primera falla :P


factorial_inferior = 1 // 0!
ciclo 1:
factorial_inferior *=1 //1*1 = 1
ciclo 2:
factorial_inferior *=2 //2*1*1 = 2
ciclo 3:
factorial_inferior *=3 //3*2*1*1 = 6
ciclo 4:
factorial_inferior *=4 //4*3*2*1*1 = 24
ciclo 5:
factorial_inferior *=5 //5*4*3*2*1*1 = 120

el arrastra el valor del factorial y lo multiplica cada vez, por eso no le reasigno un valor entero :P (así evito hacer un ciclo extra con una variable de 1kb o más) el superior lo voy a hacer similar corriéndolo solo de i*4 y x< (i+1)*4 así solo hace 4 ciclos por ciclo :P pero esa parte si está funcionando... comprobado (hace 15 segundos XD)

sospecho que tendré que hacer debug con buena calma ver los valores con lápiz en mano... porque en donde sospecho que puede salir el error es en uno de esos números grandes

buenas! entré un segundo justo antes de ir a dormir, ando complicado con los tiempos jejej y recién veo el tema! pero no quería dejar el sitio sin antes felicitarte engel lx por el post, es muy interesante!

tan solo a titulo informativo, el excelente algoritmo de Ramanujan ha sido modificado ligeramente obteniéndose el algoritmo de Chudnovsky, que permite algo así como 15 decimales de exactitud creo, luego de cada término XD una locura!

(http://s.wordpress.com/latex.php?latex=%20\cfrac{1}{\pi}%20%3D%2012%20\%3B%20\displaystyle{\sum^\infty_{k%3D0}%20\cfrac{%28-1%29^k%20%286k%29!%20%2813591409%20%2B%20545140134k%29}{%283k%29!%28k!%29^3%20640320^{3k%20%2B%203%2F2}}}&bg=ffffff&fg=000000&s=0)

pd: acabo de buscarlo, son 14 decimales; de 9 que se obtenía con el anterior. tengo entendido que los últimos records que indicaban más arriba fueron con dicha implementación. saludos

do-while: lo que es la arrogancia! XD al final si era el factorial el error! XD (eso creo)
XD pero ahorita está más feo aún pero funciona! y es increiblemente eficiente!

de ahora en adelante publicaré el codigo en el post inicial...  no lo publicaré como un gran bloque sino, cada sección... olvidense de imprimir en archivo y de la modularidad! XD eso aún lo postergo

Gh057: lo había visto! XD pero me tomará otro dia adaptarlo, aunque como tiene similaridad con Ramanujan no se me debría ser tan difícil...


alguna vez vi algo de comentario de código cómicos... este merece uno que vi

//cuando empeze a hacer esto solo dios y yo sabiamos lo que hacia, en este momento solo dios lo sabe

aqui la correccion de Ramanujan

string metodo_ramanujan(unsigned long int digitos, long &exponente) {
    digitos/=8;
    digitos*=1.01;
    unsigned long int i, j;
    mpf_t sumatoria, buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior, primera_parte,
            buff_ciclo_inferior2, factorial_superior, factorial_inferior;
    mpf_init_set_ui(sumatoria, 1103); //sumatoria=0
    mpf_init_set_ui(buff_sumatoria, 0); //buff_sumatoria=0
    mpf_init_set_ui(buff_ciclo_superior, 0); //buff_ciclo_superior=0
    mpf_init_set_ui(buff_ciclo_inferior, 0); //buff_ciclo_inferior=0
    mpf_init_set_ui(primera_parte, 0); //primera_parte=0
    mpf_init_set_ui(buff_ciclo_inferior2, 0); //buff_ciclo_inferior2=0
    mpf_init_set_ui(factorial_superior, 1); //factorial_superior=1
    mpf_init_set_ui(factorial_inferior, 1); //factorial_inferior=1
    mpf_sqrt_ui(primera_parte, 2); //primera_parte=sqrt(2)
    mpf_mul_ui(primera_parte, primera_parte, 2); //primera_parte*=2
    mpf_div_ui(primera_parte, primera_parte, 9801); //primera_parte/=9801
 
    for (i = 1; i <= digitos; i++) {
        for (j = (i - 1)*4 + 1; j <= i * 4; j++) {
            mpf_mul_ui(factorial_superior, factorial_superior, j);
        }
        mpf_set_ui(buff_ciclo_superior, 26390);
        mpf_mul_ui(buff_ciclo_superior, buff_ciclo_superior, i);
        mpf_add_ui(buff_ciclo_superior, buff_ciclo_superior, 1103);
        mpf_mul(buff_ciclo_superior, buff_ciclo_superior, factorial_superior);
        mpf_mul_ui(factorial_inferior, factorial_inferior, i);
        mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
        mpf_set_ui(buff_ciclo_inferior2, 396);
        mpf_pow_ui(buff_ciclo_inferior2, buff_ciclo_inferior2, 4 * i);
        mpf_mul(buff_ciclo_inferior, buff_ciclo_inferior, buff_ciclo_inferior2);
        mpf_div(buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior);
        mpf_add(sumatoria, sumatoria, buff_sumatoria);
 
    }
    mpf_mul(sumatoria, sumatoria, primera_parte);
    mpf_ui_div(sumatoria, 1, sumatoria);
    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
}

si no fuera tan flojo (y estuviera claro en el tema), intentara hacer operator overload para usar los operadores normales! D:

a partir de ahora modifico el post principal

Disculpa por revivir el post. Muy buen post, en definitiva Pi tiene muchos decimales, que en calculos escolares me basta con 3.1416 xD, Pero jamás entendí la ecuacuón de Ramanujan.
Me volví loco y opté por enender otras, ¿me la puedes explicar con peras y manzanas?  :P

Un Cordial Saludo  ;D

que cosa no entendiste? las operaciones en el código?

Si  :huh:

lo voy a traducir a codigo en lenguaje "normal"(c++) para que sea más visible

recordaré la formula por cosas paracticas
(http://upload.wikimedia.org/math/3/c/c/3cca05380343cb6f78d776d5e40b3a9d.png)

unsigned long int i, j;
 
float sumatoria, buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior, primera_parte, buff_ciclo_inferior2, factorial_superior, factorial_inferior;
 
sumatoria=1103;
buff_sumatoria=0;
buff_ciclo_superior=0;
buff_ciclo_inferior=0;
primera_parte=0;
buff_ciclo_inferior2=0;
factorial_superior=1;
factorial_inferior=1;
 
//sqrt(2)
primera_parte=sqrt(2);
 
//sqrt(2) * 2
primera_parte*=2;
 
//sqrt(2)*2 / 9801
primera_parte/=9801
 
for (i = 1; i <= digitos; i++) {//sabiendo que ramanujan produce 8 digitos con un margen de error de 1% por ciclo, según mis pruebas
        for (j = (i - 1)*4 + 1; j <= i * 4; j++) {
            factorial_superior*=*j;//ciclo acumulador del factorial (4k)!
        }
        //29690 * k
        buff_ciclo_superior= 26390;
        buff_ciclo_superior *= i;
 
        //(1103 + 29690*k)
        buff_ciclo_superior+=1103;
 
        //(4k)! * (1103+29690*k)
        buff_ciclo_superior*=factorial_superior;
 
        //(k!)^4
        factorial_inferior*=i;
        buff_ciclo_inferior = pow(factorial_inferior, 4);
 
        //396^4k
        buff_ciclo_inferior2 = 396;
        buff_ciclo_inferior2 = pow(buff_ciclo_inferior2, 4 * i);
 
        //(k!)^4 * 396^4
        buff_ciclo_inferior*=buff_ciclo_inferior2;
 
        // (4k)!*(1103+29690*k) / (k!)^4*396^4
        buff_sumatoria = buff_ciclo_superior / buff_ciclo_inferior;
 
        sumatoria+=buff_sumatoria;//la sumatoria...
 
    }
 
    //sqrt(2)*2/9801 * SUMATORIA (4k)!*(1103+29690*k) / (k!)^4*396^4
    sumatoria*=primera_parte;
 
    // el resultado original es 1/pi, entonces con esto hago la inversión
    sumatoria = 1 / sumatoria;
 
    //convierte a texto para poder imprimirlo
    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
 
 
 

espero que así sea más visible

Mejor  ;D ;D ;D

Que lenguaje C++ si se una gran parte de él  ;-)

Gracias y un Cordial Saludo  ;D

es que siempre fue en c++ solo que para poder manejar grandes cifras (al final manejaba 10 millones de digitos (en menos de 5 minutos creo...) descargate la librería y prueba el código e intenta a ver si puedes hacer el que no pude, el de Chudnovsky que lo intenté y se me hizo muy complicado (luego estuve muy saturado de trabajo en la oficina para pensar en esto XD)

(http://s.wordpress.com/latex.php?latex=%20\cfrac{1}{\pi}%20%3D%2012%20\%3B%20\displaystyle{\sum^\infty_{k%3D0}%20\cfrac{%28-1%29^k%20%286k%29!%20%2813591409%20%2B%20545140134k%29}{%283k%29!%28k!%29^3%20640320^{3k%20%2B%203%2F2}}}&bg=ffffff&fg=000000&s=0)