Temas

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  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.

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!

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

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <winbgim.h>
#include<time.h>

#define ESC 27
#define KEY_SPACE 32

#define lado 20
#define columnas 11
#define filas 38
#define ancho filas*lado+filas
#define alto columnas*lado+columnas
#define viva 1
#define muerta 0
struct celula
{
    int x, y;
};
struct tablero
{
    int fichas[filas][columnas];
    int vivas=0;
};
void imprimir_celula(celula celula);
void borrar_celula(celula celula);
void rayado();
tablero crear_tablero();
void mostrar_tablero(tablero tablero);
int main()
{
    celula celula;
    int i, z, vivas, m, n, h1, h2;
    tablero tablero, alpha;
    initwindow (ancho, alto);
    rayado();
    tablero = crear_tablero();
    alpha=tablero;
    cleardevice();
    mostrar_tablero(tablero);
    rayado();
    /* Algoritmo del juego
        Recorre todas las celulas:
        Si está muerta y tiene extactamente 3 celulas vecinas vivas, esta nace al siguiente turno
        Si está viva:
            y tiene 2 o 3 celulas vivas sigue viva
            en otro caso, muere al siguiente turno
     */
     //Recordar: la matriz del tablero está ordenada en filas->columnas
    while (tablero.vivas > 0)
    {
        for (i=0; i<columnas; i++)
        {
            for (z=0; z<filas; z++)
            {
                vivas=0; //Contador de celulas vivas vecinas
                for(m=i-1; m<=i+1; m++)
                {
                    for(n=z-1; n<=z+1; n++)
                    {
                        if (n<0) {
                            h1=filas-1;
                        } else if(n>filas-1)
                        {
                            h1=0;
                        } else {
                            h1=n;
                        }
                        if (m<0) {
                            h2=columnas-1;
                        } else if(m>columnas-1)
                        {
                            h2=0;
                        } else {
                            h2=m;
                        }
                        if (tablero.fichas[h1][h2]==viva && (z!=h1 || i!=h2)) vivas++;
                    }
                }
                if (tablero.fichas[z][i]==muerta)
                {
                    if (vivas==3)
                    {
                        alpha.fichas[z][i]=viva;
                        alpha.vivas++;
                    }
                } else {
                    if (!(vivas==3 || vivas==2))
                    {
                        alpha.fichas[z][i]=muerta;
                        alpha.vivas--;
                    }
                }
            }
        }
        tablero = alpha;
        cleardevice();
        mostrar_tablero(tablero);
        rayado();
        delay(300);
    }
    getch();
    closegraph();
    return 0;
}

tablero crear_tablero()
{
    char tecla;
    tablero alpha;
    celula celula;
    int i, z;
    //Inicializa el tablero con todas las celulas muertas
    for (i=0; i<columnas; i++)
    {
        for (z=0; z<filas; z++)
        {
            alpha.fichas[z][i]=muerta;
        }
    }
    celula.x=0;
    celula.y=0;
    imprimir_celula(celula);
    do
    {
            cleardevice();
            mostrar_tablero(alpha);
            if (alpha.fichas[celula.x][celula.y] == muerta)
            {
                imprimir_celula(celula);
            } else {
                borrar_celula(celula);
            }
            rayado();
            if (kbhit())
            {
                tecla=getch();
                switch(tecla)
                {
                    case KEY_LEFT:
                        if (celula.x>0) celula.x--;
                    break;

                    case KEY_RIGHT:
                        if (celula.x<filas-1) celula.x++;
                    break;

                    case KEY_UP:
                        if (celula.y>0) celula.y--;
                    break;

                    case KEY_DOWN:
                        if (celula.y<columnas-1) celula.y++;
                    break;

                    case ESC:
                        return alpha;
                    break;

                    case KEY_SPACE:
                        if (alpha.fichas[celula.x][celula.y] == muerta)
                        {
                            alpha.fichas[celula.x][celula.y]=viva;
                            alpha.vivas++;
                        } else {
                            alpha.fichas[celula.x][celula.y]=muerta;
                            alpha.vivas--;
                        }
                    break;
                }
            }
        delay(30);
    } while(1);
}
void mostrar_tablero(tablero tablero)
{
    int i=0, z=0;
    celula celula;
    for (i=0; i<columnas; i++)
    {
        for (z=0; z<filas; z++)
        {
            if (tablero.fichas[z][i]==viva)
            {
                celula.x=z;
                celula.y=i;
                imprimir_celula(celula);
            }
        }
    }

}
void imprimir_celula(celula celula)
{
    int x1, x2, y1, y2;
    x1=celula.x*(1+lado);
    y1=celula.y*(1+lado);
    x2=x1+lado+1;
    y2=y1+lado+1;
    setcolor(COLOR(255, 255, 255));
    setfillstyle(SOLID_FILL, COLOR(255, 255, 255));
    bar(x1, y1, x2, y2);
}
void borrar_celula(celula celula)
{
    int x1, x2, y1, y2;
    x1=celula.x*(1+lado);
    y1=celula.y*(1+lado);
    x2=x1+lado+1;
    y2=y1+lado+1;
    setcolor(COLOR(0, 0, 0));
    setfillstyle(SOLID_FILL, COLOR(0, 0, 0));
    bar(x1, y1, x2, y2);
}
void rayado()
{
    int i, cont=0;
    setcolor(COLOR(100, 100, 100));
    for (i=1; i<columnas; i++)
    {
        cont+=lado+1;
        line(0, cont, ancho, cont);
    }
    cont=0;
    for (i=1; i<filas; i++)
    {
        cont+=lado+1;
        line(cont, 0, cont, alto);
    }
}




Un saludo

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 (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <winbgim.h>
#include <math.h>
#include <windows.h>

#define blanco COLOR(255, 255, 255)
#define rojo COLOR(255, 0, 0)
#define radio 40
#define pi 3.1415
#define width 800
#define height 600
struct circulo {
    int x=0;
    int y=0; // Componentes del punto centro del círculo (x,y)
    int a=0; // Aceleración
    long double v=0; // Velocidad
    double ang; // En radianes
    int rad=0; //Radio del círculo

};

void dibujar_circulo(circulo objeto, HDC a);

COORD CursorPosition;

int main()
{

    circulo objeto;
    HDC a;
    float vx, vy;
    POINT mouse;
    bool help=true;
    int frames, i, tiempo, n;

    initwindow (800,600);
    objeto.x = radio;
    objeto.y = getmaxy()-radio;
    objeto.rad = radio;

    while (help)
    {
        cleardevice();
        dibujar_circulo(objeto, a);
        GetCursorPos(&mouse);
        setcolor(rojo);
        line(objeto.x, objeto.y, mouse.x, mouse.y);

        if (ismouseclick(WM_LBUTTONDOWN))
        {
            objeto.ang = atan(
                                (abs(- objeto.y + mouse.y))
                                     /
                                (abs( mouse.x - objeto.x))
                                    ) ;

            objeto.v = sqrt(pow((abs( - objeto.y + mouse.y)),2)+pow((abs(-mouse.x + objeto.x)),2))/1000;

            help=false;
            printf("%lu", objeto.ang);
        }

        delay(50);

    }
    delay(200);

    vy=sin(objeto.ang)*objeto.v;
    vx=cos(objeto.ang)*objeto.v;

    objeto.a=-(10);


    frames = (-vy/objeto.a);
    i=0;
    while(i>=0 && n!=2)
    {

        cleardevice();
        objeto.x=i+objeto.rad;
        objeto.y=tan(objeto.ang)*i - pow(i,2)*(
                                               objeto.a*( 1+pow(tan(objeto.ang),2) )/(2* pow(objeto.v,2))
                                                );
                                                objeto.y=height-objeto.y+objeto.rad;
        dibujar_circulo(objeto, a);
        if (i==0) n++;
        i++;
        delay(30);

    }







    getch();
    closegraph();
    return 0;
}


void dibujar_circulo(circulo objeto, HDC a)
{
    setcolor(blanco);
    setfillstyle(SOLID_FILL, blanco);


    circle(objeto.x, objeto.y, objeto.rad);
    a = GetWindowDC ( GetForegroundWindow () );
    FloodFill(a, objeto.x, objeto.y, blanco);
}


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

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 (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <winbgim.h>
#include <math.h>

#define WIDTH 960
#define HEIGHT 600
#define PI 3.1415

int main()
{
    long long x, y, z;
    initwindow(WIDTH, HEIGHT);

    setcolor(COLOR(157, 157, 157));

    line(WIDTH/2, 0, WIDTH/2, HEIGHT);
    line(0, HEIGHT/2, WIDTH, HEIGHT/2);

    for (int i=0; i<=WIDTH; i++)
    {
        x = (i - WIDTH/2);
        if (x!=0) y=x-2;
        if (y<=0)
        {
            z=HEIGHT/2 + abs(y);
        } if (y>0)
        {
            z = abs(HEIGHT/2 - y);
        }
        if (z<=HEIGHT && z>=0) putpixel(i, z, COLOR(255, 255, 255));
        printf("f(%d) = %d\n", i, z); //el printf es para ver que pasa con esos valores o.0

    }


    getch();
    closegraph();
    return 0;
}

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

Bueno quiero un reto pero no conozco muchas personas aqui asi que reto al que acepte 

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

Saludos!