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

 

 


Tema destacado: Estamos en la red social de Mastodon


  Mostrar Temas
Páginas: [1]
1  Programación / Programación General / En busca de un libro en digital... en: 12 Diciembre 2014, 03:00 am
Buenas, estoy llevando el curso de cómputo científico I en la universidad, en este estudiamos algo básico de cómo la maquina lleva a cabo operaciones y cómo almacena números en la memoria aparte de tener laboratorios de Matlab, esto precede a cálculo numérico..

He estado buscando el siguiente libro: Handbook for Matrix Computations (Frontiers in Applied Mathematics) autores: Charles Van Loan & Thomas F. Coleman ~ pero la verdad es que no lo he encontrado en digital ¿Alguien sabrá donde encontrarlo o lo tendrá disponible?

Aparte, ¿alguien conoce algún libro que trate de estos menesteres? Me refiero a la parte lógica del almacenamiento de números en una máquina y cómo lleva a cabo operaciones  ;D me ha llamado la atención para aplicarlo a ANSI C más que a Matlab, he visto problemas que me han causado dolores de cabeza con errores de underflow y overflow.

Cualquier ayuda la agradecería grandemente y de antemano,

Saludos.
2  Programación / Programación General / Algoritmos quick union y wighted quick union? en: 11 Septiembre 2014, 14:44 pm
Buenas, estoy en el primer curso de algoritmos y en la primera semana toca conexiones dinámicas, comenzamos a ver los algoritmos quick find y quick union. El acercamiento del algoritmo quick find es bastante intuitivo y hasta visual, el problema comenzó con el quick union y mas tarde el weighted quick union.

La duda es, ¿Qué es la raíz? esta método es lo más importante para el quick union, ¿cómo demuestro que es única?

Entiendo perfectamente como implementar el código, lo que aún no capto es "cómo funciona"

Gracias de antemano,

Saludos!
3  Programación / Programación C/C++ / [Aporte] El juego de la vida (librería winbgim) en: 4 Abril 2013, 17:13 pm
Aquí posteo el código de un juego de la vida que hice hace unos días por mero ocio.

Es simple, no tiene ningún menú ni nada por el estilo, lo abres y te aparece el tablero cuadriculado, te vas moviendo con las flechas y con la tecla de espacio la dejas viva o muerta, con la tecla ESC comienzas el juego.

Si se quiere cambiar el tamaño del tablero basta con cambiar las constantes "filas" y "columnas", y igual manera si se quiere cambiar el tamaño de los lados de las células se cambia la constante "lado" (es necesario re-compilar obviamente)

La modalidad es la clásica: si una célula muerta tiene 3 celulas vecinas vivas, vivirá en el siguiente turno, si una célula viva tiene 2 o 3 celulas vivas vecinas ésta seguirá viva, de lo contrario, morirá en el próximo turno.

Es bastante sencillo, puede que a alguien por allí le sirva ;D

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <winbgim.h>
  4. #include<time.h>
  5.  
  6. #define ESC 27
  7. #define KEY_SPACE 32
  8.  
  9. #define lado 20
  10. #define columnas 11
  11. #define filas 38
  12. #define ancho filas*lado+filas
  13. #define alto columnas*lado+columnas
  14. #define viva 1
  15. #define muerta 0
  16. struct celula
  17. {
  18.    int x, y;
  19. };
  20. struct tablero
  21. {
  22.    int fichas[filas][columnas];
  23.    int vivas=0;
  24. };
  25. void imprimir_celula(celula celula);
  26. void borrar_celula(celula celula);
  27. void rayado();
  28. tablero crear_tablero();
  29. void mostrar_tablero(tablero tablero);
  30. int main()
  31. {
  32.    celula celula;
  33.    int i, z, vivas, m, n, h1, h2;
  34.    tablero tablero, alpha;
  35.    initwindow (ancho, alto);
  36.    rayado();
  37.    tablero = crear_tablero();
  38.    alpha=tablero;
  39.    cleardevice();
  40.    mostrar_tablero(tablero);
  41.    rayado();
  42.    /* Algoritmo del juego
  43.         Recorre todas las celulas:
  44.         Si está muerta y tiene extactamente 3 celulas vecinas vivas, esta nace al siguiente turno
  45.         Si está viva:
  46.             y tiene 2 o 3 celulas vivas sigue viva
  47.             en otro caso, muere al siguiente turno
  48.      */
  49.     //Recordar: la matriz del tablero está ordenada en filas->columnas
  50.    while (tablero.vivas > 0)
  51.    {
  52.        for (i=0; i<columnas; i++)
  53.        {
  54.            for (z=0; z<filas; z++)
  55.            {
  56.                vivas=0; //Contador de celulas vivas vecinas
  57.                for(m=i-1; m<=i+1; m++)
  58.                {
  59.                    for(n=z-1; n<=z+1; n++)
  60.                    {
  61.                        if (n<0) {
  62.                            h1=filas-1;
  63.                        } else if(n>filas-1)
  64.                        {
  65.                            h1=0;
  66.                        } else {
  67.                            h1=n;
  68.                        }
  69.                        if (m<0) {
  70.                            h2=columnas-1;
  71.                        } else if(m>columnas-1)
  72.                        {
  73.                            h2=0;
  74.                        } else {
  75.                            h2=m;
  76.                        }
  77.                        if (tablero.fichas[h1][h2]==viva && (z!=h1 || i!=h2)) vivas++;
  78.                    }
  79.                }
  80.                if (tablero.fichas[z][i]==muerta)
  81.                {
  82.                    if (vivas==3)
  83.                    {
  84.                        alpha.fichas[z][i]=viva;
  85.                        alpha.vivas++;
  86.                    }
  87.                } else {
  88.                    if (!(vivas==3 || vivas==2))
  89.                    {
  90.                        alpha.fichas[z][i]=muerta;
  91.                        alpha.vivas--;
  92.                    }
  93.                }
  94.            }
  95.        }
  96.        tablero = alpha;
  97.        cleardevice();
  98.        mostrar_tablero(tablero);
  99.        rayado();
  100.        delay(300);
  101.    }
  102.    getch();
  103.    closegraph();
  104.    return 0;
  105. }
  106.  
  107. tablero crear_tablero()
  108. {
  109.    char tecla;
  110.    tablero alpha;
  111.    celula celula;
  112.    int i, z;
  113.    //Inicializa el tablero con todas las celulas muertas
  114.    for (i=0; i<columnas; i++)
  115.    {
  116.        for (z=0; z<filas; z++)
  117.        {
  118.            alpha.fichas[z][i]=muerta;
  119.        }
  120.    }
  121.    celula.x=0;
  122.    celula.y=0;
  123.    imprimir_celula(celula);
  124.    do
  125.    {
  126.            cleardevice();
  127.            mostrar_tablero(alpha);
  128.            if (alpha.fichas[celula.x][celula.y] == muerta)
  129.            {
  130.                imprimir_celula(celula);
  131.            } else {
  132.                borrar_celula(celula);
  133.            }
  134.            rayado();
  135.            if (kbhit())
  136.            {
  137.                tecla=getch();
  138.                switch(tecla)
  139.                {
  140.                    case KEY_LEFT:
  141.                        if (celula.x>0) celula.x--;
  142.                    break;
  143.  
  144.                    case KEY_RIGHT:
  145.                        if (celula.x<filas-1) celula.x++;
  146.                    break;
  147.  
  148.                    case KEY_UP:
  149.                        if (celula.y>0) celula.y--;
  150.                    break;
  151.  
  152.                    case KEY_DOWN:
  153.                        if (celula.y<columnas-1) celula.y++;
  154.                    break;
  155.  
  156.                    case ESC:
  157.                        return alpha;
  158.                    break;
  159.  
  160.                    case KEY_SPACE:
  161.                        if (alpha.fichas[celula.x][celula.y] == muerta)
  162.                        {
  163.                            alpha.fichas[celula.x][celula.y]=viva;
  164.                            alpha.vivas++;
  165.                        } else {
  166.                            alpha.fichas[celula.x][celula.y]=muerta;
  167.                            alpha.vivas--;
  168.                        }
  169.                    break;
  170.                }
  171.            }
  172.        delay(30);
  173.    } while(1);
  174. }
  175. void mostrar_tablero(tablero tablero)
  176. {
  177.    int i=0, z=0;
  178.    celula celula;
  179.    for (i=0; i<columnas; i++)
  180.    {
  181.        for (z=0; z<filas; z++)
  182.        {
  183.            if (tablero.fichas[z][i]==viva)
  184.            {
  185.                celula.x=z;
  186.                celula.y=i;
  187.                imprimir_celula(celula);
  188.            }
  189.        }
  190.    }
  191.  
  192. }
  193. void imprimir_celula(celula celula)
  194. {
  195.    int x1, x2, y1, y2;
  196.    x1=celula.x*(1+lado);
  197.    y1=celula.y*(1+lado);
  198.    x2=x1+lado+1;
  199.    y2=y1+lado+1;
  200.    setcolor(COLOR(255, 255, 255));
  201.    setfillstyle(SOLID_FILL, COLOR(255, 255, 255));
  202.    bar(x1, y1, x2, y2);
  203. }
  204. void borrar_celula(celula celula)
  205. {
  206.    int x1, x2, y1, y2;
  207.    x1=celula.x*(1+lado);
  208.    y1=celula.y*(1+lado);
  209.    x2=x1+lado+1;
  210.    y2=y1+lado+1;
  211.    setcolor(COLOR(0, 0, 0));
  212.    setfillstyle(SOLID_FILL, COLOR(0, 0, 0));
  213.    bar(x1, y1, x2, y2);
  214. }
  215. void rayado()
  216. {
  217.    int i, cont=0;
  218.    setcolor(COLOR(100, 100, 100));
  219.    for (i=1; i<columnas; i++)
  220.    {
  221.        cont+=lado+1;
  222.        line(0, cont, ancho, cont);
  223.    }
  224.    cont=0;
  225.    for (i=1; i<filas; i++)
  226.    {
  227.        cont+=lado+1;
  228.        line(cont, 0, cont, alto);
  229.    }
  230. }




Un saludo
4  Programación / Programación C/C++ / ¿Atan() Siempre devuelve 0? (posible problema con la declaración de las varibles en: 4 Abril 2013, 17:02 pm
Buenos tardes,

Desde hace algunos días en mi tiempo libre me he puesto a programar un simulador (excesivamente simple) de movimiento parabólico, les cuento, yo dibujo un círculo y una linea, desde el centro del círculo hasta las coordenadas del mouse, para así cuando se reciba un click obtener la pendiente de la recta y aplicando la tangente inversa, el ángulo, sin embargo no he podido obtener el ángulo, he revisado mi código por esos lares y he investigado, el cociente es perfecto (al menos eso asumo, por lo menos congruente es), no veo la razón por la que atan() me devuelve un ángulo 0, si tengo entendido que si la tangente es 0 <==> el angulo es 0. (por qué 466/399 devolvería cero?)

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <winbgim.h>
  4. #include <math.h>
  5. #include <windows.h>
  6.  
  7. #define blanco COLOR(255, 255, 255)
  8. #define rojo COLOR(255, 0, 0)
  9. #define radio 40
  10. #define pi 3.1415
  11. #define width 800
  12. #define height 600
  13. struct circulo {
  14.    int x=0;
  15.    int y=0; // Componentes del punto centro del círculo (x,y)
  16.    int a=0; // Aceleración
  17.    long double v=0; // Velocidad
  18.    double ang; // En radianes
  19.    int rad=0; //Radio del círculo
  20.  
  21. };
  22.  
  23. void dibujar_circulo(circulo objeto, HDC a);
  24.  
  25. COORD CursorPosition;
  26.  
  27. int main()
  28. {
  29.  
  30.    circulo objeto;
  31.    HDC a;
  32.    float vx, vy;
  33.    POINT mouse;
  34.    bool help=true;
  35.    int frames, i, tiempo, n;
  36.  
  37.    initwindow (800,600);
  38.    objeto.x = radio;
  39.    objeto.y = getmaxy()-radio;
  40.    objeto.rad = radio;
  41.  
  42.    while (help)
  43.    {
  44.        cleardevice();
  45.        dibujar_circulo(objeto, a);
  46.        GetCursorPos(&mouse);
  47.        setcolor(rojo);
  48.        line(objeto.x, objeto.y, mouse.x, mouse.y);
  49.  
  50.        if (ismouseclick(WM_LBUTTONDOWN))
  51.        {
  52.            objeto.ang = atan(
  53.                                (abs(- objeto.y + mouse.y))
  54.                                     /
  55.                                (abs( mouse.x - objeto.x))
  56.                                    ) ;
  57.  
  58.            objeto.v = sqrt(pow((abs( - objeto.y + mouse.y)),2)+pow((abs(-mouse.x + objeto.x)),2))/1000;
  59.  
  60.            help=false;
  61.            printf("%lu", objeto.ang);
  62.        }
  63.  
  64.        delay(50);
  65.  
  66.    }
  67.    delay(200);
  68.  
  69.    vy=sin(objeto.ang)*objeto.v;
  70.    vx=cos(objeto.ang)*objeto.v;
  71.  
  72.    objeto.a=-(10);
  73.  
  74.  
  75.    frames = (-vy/objeto.a);
  76.    i=0;
  77.    while(i>=0 && n!=2)
  78.    {
  79.  
  80.        cleardevice();
  81.        objeto.x=i+objeto.rad;
  82.        objeto.y=tan(objeto.ang)*i - pow(i,2)*(
  83.                                               objeto.a*( 1+pow(tan(objeto.ang),2) )/(2* pow(objeto.v,2))
  84.                                                );
  85.                                                objeto.y=height-objeto.y+objeto.rad;
  86.        dibujar_circulo(objeto, a);
  87.        if (i==0) n++;
  88.        i++;
  89.        delay(30);
  90.  
  91.    }
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99.    getch();
  100.    closegraph();
  101.    return 0;
  102. }
  103.  
  104.  
  105. void dibujar_circulo(circulo objeto, HDC a)
  106. {
  107.    setcolor(blanco);
  108.    setfillstyle(SOLID_FILL, blanco);
  109.  
  110.  
  111.    circle(objeto.x, objeto.y, objeto.rad);
  112.    a = GetWindowDC ( GetForegroundWindow () );
  113.    FloodFill(a, objeto.x, objeto.y, blanco);
  114. }
  115.  

No presten atención al código basura que hay debajo, estaba probando si era algun error del algoritmo de la animación, pero no, luego de revisar me di cuenta que objeto.ang siempre es igual a 0

Sospecho que es en la declaración "double ang", quizás debería ser long, he probado pero no encuentro solución

Muchas gracias de antemano!

Saludos
5  Programación / Programación C/C++ / Problema al graficar una función lineal (winbgim) en: 9 Febrero 2013, 23:10 pm
Bueno pues, inventando, como siempre, se me ocurrio hacer un programa que grafique una funcion lineal, peero, me llegó un problema extraño, no le veo la lógica, aún.

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <winbgim.h>
  4. #include <math.h>
  5.  
  6. #define WIDTH 960
  7. #define HEIGHT 600
  8. #define PI 3.1415
  9.  
  10. int main()
  11. {
  12.    long long x, y, z;
  13.    initwindow(WIDTH, HEIGHT);
  14.  
  15.    setcolor(COLOR(157, 157, 157));
  16.  
  17.    line(WIDTH/2, 0, WIDTH/2, HEIGHT);
  18.    line(0, HEIGHT/2, WIDTH, HEIGHT/2);
  19.  
  20.    for (int i=0; i<=WIDTH; i++)
  21.    {
  22.        x = (i - WIDTH/2);
  23.        if (x!=0) y=x-2;
  24.        if (y<=0)
  25.        {
  26.            z=HEIGHT/2 + abs(y);
  27.        } if (y>0)
  28.        {
  29.            z = abs(HEIGHT/2 - y);
  30.        }
  31.        if (z<=HEIGHT && z>=0) putpixel(i, z, COLOR(255, 255, 255));
  32.        printf("f(%d) = %d\n", i, z); //el printf es para ver que pasa con esos valores o.0
  33.  
  34.    }
  35.  
  36.  
  37.    getch();
  38.    closegraph();
  39.    return 0;
  40. }

El problema es el siguiente:


WTF? Por qué pasa eso? 0.0
Casi parece una funcion de valor absoluto, pero no, en este caso es y=x-2, probé con y=2; y=40, es decir "y" constante y grafica perfectamente. ¿Por qué será? o.0

Hahahaha, si saben algo gracias, se me despejaría una gran duda


Saludos
6  Media / Diseño Gráfico / Reto [Al que Acepte] en: 4 Marzo 2009, 03:07 am
Bueno quiero un reto pero no conozco muchas personas aqui asi que reto al que acepte  :P

Tema, medidas, fecha de entrega que las de el que acepte.

Saludos!
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines