elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


  Mostrar Mensajes
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 146
1  Foros Generales / Noticias / Re: El responsable de la vulnerabilidad Heartbleed de OpenSSL se disculpa en: 15 Abril 2014, 01:07
en este caso me parece que no es culpa única de el, también están el resto de los programadores que deben revisar el código y corregir los errores dejados (limpieza, corrección y optimización del código), cualquier puede dejar un error incluso uno tan pequeño (que aunque en alcance es grande, normalmente no se piensa en ello al momento, y es posiblemente una linea de código entre cientos diarias)

por otro lado "Lo más fácil siempre es echarle la culpa a los usuarios...." cuando adquieres un software te atienes a sus licencias, no es culpa expresa de los usuarios, pero deben saber que si no quieren tomar riesgos reales consecuencia de esto, deben pagar licencias que les aseguren que en estos casos les pagarán indemnización (porque es mentira que nunca se van a equivocar)
2  Seguridad Informática / Análisis y Diseño de Malware / Re: MONTAR BOTNET en: 12 Abril 2014, 06:32
no, este foro no es para eso...
3  Foros Generales / Noticias / Re: Interior obligará a los locutorios a pedir la documentación a los que usen su... en: 11 Abril 2014, 21:03
como se nota que no sabes que significa esa palabra    :laugh:

cierto!  xD tan comunista como franco y hitler
4  Foros Generales / Foro Libre / Re: ME ha llegado este e-mail y parece que me la quiere colar en: 11 Abril 2014, 14:18
en mi país eso se le llama paquete chileno XD no se por qué
5  Programación / Java / Re: Problemilla con un patrón en: 11 Abril 2014, 14:16
tu patron dice ("[\"][A-Za-z]+[\"]"); que empieze con comillas (lo preparas para una condicion y no se la das) luego que contenga de la a a la z y termine con comillas, no está admitiendo espacios.... puedes intentar con

("\"[A-Za-z\s]+\"")
6  Programación / Programación C/C++ / Re: Calculo de pi en alta precisión (aporte) en: 11 Abril 2014, 07:26
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

Código
  1. //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

Código
  1. string metodo_ramanujan(unsigned long int digitos, long &exponente) {
  2.    digitos/=8;
  3.    digitos*=1.01;
  4.    unsigned long int i, j;
  5.    mpf_t sumatoria, buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior, primera_parte,
  6.            buff_ciclo_inferior2, factorial_superior, factorial_inferior;
  7.    mpf_init_set_ui(sumatoria, 1103); //sumatoria=0
  8.    mpf_init_set_ui(buff_sumatoria, 0); //buff_sumatoria=0
  9.    mpf_init_set_ui(buff_ciclo_superior, 0); //buff_ciclo_superior=0
  10.    mpf_init_set_ui(buff_ciclo_inferior, 0); //buff_ciclo_inferior=0
  11.    mpf_init_set_ui(primera_parte, 0); //primera_parte=0
  12.    mpf_init_set_ui(buff_ciclo_inferior2, 0); //buff_ciclo_inferior2=0
  13.    mpf_init_set_ui(factorial_superior, 1); //factorial_superior=1
  14.    mpf_init_set_ui(factorial_inferior, 1); //factorial_inferior=1
  15.    mpf_sqrt_ui(primera_parte, 2); //primera_parte=sqrt(2)
  16.    mpf_mul_ui(primera_parte, primera_parte, 2); //primera_parte*=2
  17.    mpf_div_ui(primera_parte, primera_parte, 9801); //primera_parte/=9801
  18.  
  19.    for (i = 1; i <= digitos; i++) {
  20.        for (j = (i - 1)*4 + 1; j <= i * 4; j++) {
  21.            mpf_mul_ui(factorial_superior, factorial_superior, j);
  22.        }
  23.        mpf_set_ui(buff_ciclo_superior, 26390);
  24.        mpf_mul_ui(buff_ciclo_superior, buff_ciclo_superior, i);
  25.        mpf_add_ui(buff_ciclo_superior, buff_ciclo_superior, 1103);
  26.        mpf_mul(buff_ciclo_superior, buff_ciclo_superior, factorial_superior);
  27.        mpf_mul_ui(factorial_inferior, factorial_inferior, i);
  28.        mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
  29.        mpf_set_ui(buff_ciclo_inferior2, 396);
  30.        mpf_pow_ui(buff_ciclo_inferior2, buff_ciclo_inferior2, 4 * i);
  31.        mpf_mul(buff_ciclo_inferior, buff_ciclo_inferior, buff_ciclo_inferior2);
  32.        mpf_div(buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior);
  33.        mpf_add(sumatoria, sumatoria, buff_sumatoria);
  34.  
  35.    }
  36.    mpf_mul(sumatoria, sumatoria, primera_parte);
  37.    mpf_ui_div(sumatoria, 1, sumatoria);
  38.    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
  39. }

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
7  Seguridad Informática / Seguridad / Re: Alguien sabe como puedo aprender seguridad informatica? en: 11 Abril 2014, 06:19
elige el tema... XD que quieres defender? o de que te quieres proteger?
8  Programación / Programación C/C++ / Re: Calculo de pi en alta precisión (aporte) en: 10 Abril 2014, 14:59
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
9  Programación / Programación C/C++ / Re: Calculo de pi en alta precisión (aporte) en: 10 Abril 2014, 14:17
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
10  Foros Generales / Foro Libre / Re: 4chan Risk - Partida en: 10 Abril 2014, 05:03
cortinuo invadiendo usa y canadá, dejo la costa oeste siempre desocupada
11  Programación / Programación C/C++ / Re: Calculo de pi en alta precisión (aporte) en: 10 Abril 2014, 04:51
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

Código
  1. for(i=1;i<precision;i++){
  2. for(j=1;j<=4*i;j++){
  3.  factorial1*=j;
  4. }
  5. for(j=1;j<=i;j++){
  6.  factorial2*=j;
  7. }
  8. for(j=1;j<=4;j++){
  9.  factorial2*=factorial2;
  10. }
  11. for(j=1;j<=4*i;j++){
  12.  divisor*=396;
  13. }
  14. sumatoria+=(factorial1*(1103+26390*i))/(factorial2*divisor)
  15.  
  16. }
  17. sumatoria=1/sumatoria
  18.  

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


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:
Código
  1. #include <iostream>
  2. #include <stdlib.h>
  3. #include <string>
  4. #include <gmp.h>
  5. #include <gmpxx.h>
  6. #include <time.h>
  7. #include <sstream>
  8.  
  9. using namespace std;
  10. string metodo_euler(unsigned long int digitos, mp_exp_t &exponente);
  11. string metodo_ramanujan(unsigned long int digitos, mp_exp_t &exponente);
  12. void imprimir_pi_aux(string pi, mp_exp_t exponente, int digitos);
  13.  
  14. int main(int argc, char **argv) {
  15.  
  16.    unsigned long int digitos = strtol(argv[1], NULL, 10); //argv a int
  17.    mpf_set_default_prec(32 * 10 * (digitos / 100) * 1.11); //precision + 10%
  18.    long exponente;
  19.    clock_t start = clock();
  20.    string pi;
  21.    if(argc>2 && argv[2]=="ramanujan"){
  22.        pi = metodo_ramanujan(digitos, exponente);
  23.    }else{
  24.        pi = metodo_euler(digitos, exponente);
  25.    }
  26.    clock_t end = clock();
  27.    imprimir_pi_aux(pi, exponente, digitos);
  28.    cout << "\ntiempo total de ejecucion: " << (float) (end - start) / CLOCKS_PER_SEC << "\n";
  29.    cout << "tiempo total de impresion: " << (float) (clock() - end) / CLOCKS_PER_SEC << "\n\n";
  30.    return 0;
  31. }
  32.  
  33. void imprimir_pi_aux(string pi, long exponente, int digitos) {
  34.    cout << "PI: ";
  35.    stringstream aux;
  36.    unsigned long int i;
  37.    if (exponente < 0) {
  38.        cout << "0.";
  39.        while (exponente < 0) {
  40.            cout << 0;
  41.            exponente++;
  42.        }
  43.    } else {
  44.        for (i = 0; i < exponente; i++) {
  45.            cout << pi[i];
  46.        }
  47.        cout << ".\n\n1:\t";
  48.    }
  49.    for (i = exponente; i < digitos + 1; i++) {
  50.        aux << pi[i];
  51.        if (i % 10 == 0) aux << ' ';
  52.        if (i % 500 == 0) aux << endl;
  53.        if (i % 50 == 0 && i < digitos) aux << endl << i + 1 << ":\t";
  54.    }
  55.    aux << endl;
  56.    cout << aux.str();
  57. }
  58. string metodo_euler(unsigned long int digitos, long &exponente) {
  59.    digitos /= 100; //trabaja con lotes de 100
  60.    unsigned long int precision = digitos * 100 * 3 * 1.12;
  61.    unsigned long int x, i;
  62.    mpf_t factorial, sumatoria, buff_factorial; //variables GMP
  63.    mpf_init_set_ui(factorial, 1); //factorial=1
  64.    mpf_init_set_ui(sumatoria, 1); //sumatoria=1
  65.    mpf_init_set_ui(buff_factorial, 1); //buff_factorial=1
  66.  
  67.    for (x = 1; x < precision; x++) {
  68.        i = 2 * x + 1;
  69.        mpf_set_ui(buff_factorial, x); //buff_factorial=x
  70.        mpf_div_ui(buff_factorial, buff_factorial, i); //buff_factorial*=i
  71.        mpf_mul(factorial, factorial, buff_factorial); //factorial*=buff_factorial
  72.        mpf_add(sumatoria, sumatoria, factorial); //sumatoria+=factorial
  73.    }
  74.    mpf_mul_ui(sumatoria, sumatoria, 2); //sumatoria*=2
  75.    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
  76. }
  77.  
  78. string metodo_ramanujan(unsigned long int digitos, long &exponente) {
  79.    unsigned long int i, j;
  80.    mpf_t sumatoria, buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior, primera_parte,
  81.            buff_ciclo_inferior2, factorial_superior, factorial_inferior;
  82.    mpf_init_set_ui(sumatoria, 1103); //sumatoria=0
  83.    mpf_init_set_ui(buff_sumatoria, 0); //buff_sumatoria=0
  84.    mpf_init_set_ui(buff_ciclo_superior, 0); //buff_ciclo_superior=0
  85.    mpf_init_set_ui(buff_ciclo_inferior, 0); //buff_ciclo_inferior=0
  86.    mpf_init_set_ui(primera_parte, 0); //primera_parte=0
  87.    mpf_init_set_ui(buff_ciclo_inferior2, 0); //buff_ciclo_inferior2=0
  88.    mpf_init_set_ui(factorial_superior, 1); //factorial_superior=1
  89.    mpf_init_set_ui(factorial_inferior, 1); //factorial_inferior=1
  90.    mpf_sqrt_ui(primera_parte, 2); //primera_parte=sqrt(2)
  91.    mpf_mul_ui(primera_parte, primera_parte, 2); //primera_parte*=2
  92.    mpf_div_ui(primera_parte, primera_parte, 9801); //primera_parte/=9801
  93.  
  94.    for (i = 1; i <= digitos; i++) {
  95.        mpf_set_ui(factorial_superior, 1);
  96.        for (j = 2; j <= i * 4; j++) {
  97.            mpf_mul_ui(factorial_superior, factorial_superior, j);
  98.        }
  99.        mpf_set_ui(buff_ciclo_superior, 26390);
  100.        mpf_mul_ui(buff_ciclo_superior, buff_ciclo_superior, i);
  101.        mpf_add_ui(buff_ciclo_superior, buff_ciclo_superior, 1103);
  102.        mpf_mul(buff_ciclo_superior, buff_ciclo_superior, factorial_superior);
  103.  
  104.        mpf_mul_ui(factorial_inferior, factorial_inferior, i);
  105.        mpf_pow_ui(buff_ciclo_inferior, factorial_inferior, 4);
  106.        mpf_set_ui(buff_ciclo_inferior2, 396);
  107.        mpf_pow_ui(buff_ciclo_inferior2, buff_ciclo_inferior2, 4 * i);
  108.        mpf_mul(buff_ciclo_inferior, buff_ciclo_inferior, buff_ciclo_inferior2);
  109.  
  110.        mpf_div(buff_sumatoria, buff_ciclo_superior, buff_ciclo_inferior);
  111.        mpf_add(sumatoria, sumatoria, buff_sumatoria);  
  112.    }
  113.    mpf_mul(sumatoria, sumatoria, primera_parte);
  114.    mpf_ui_div(sumatoria, 1, sumatoria);
  115.    return mpf_get_str(NULL, &exponente, 10, 0, sumatoria);
  116. }
12  Foros Generales / Noticias / Re: El Ministerio de Fomento recuerda la prohibición del uso comercial de los drones en: 10 Abril 2014, 04:32
NADA de tomas aéreas he dicho! XD
13  Programación / Programación C/C++ / Re: Calculo de pi en alta precisión (aporte) en: 10 Abril 2014, 01:25
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
14  Programación / Programación C/C++ / Re: Calculo de pi en alta precisión (aporte) en: 9 Abril 2014, 21:30
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?
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 146
Powered by SMF 1.1.19 | SMF © 2006-2008, Simple Machines