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!

Buenas buenas! Me ha interesado este hilo! Y estoy en absoluto inclinado a unirme al proyecto, se que no tengo muchos posts en el foro pero no soy nuevo en esto como puede parecer, no he tenido chance de leer todos los posts en el tema pero ahora lo leeré.

Cuenten conmigo si me aceptan.

Manejo:
C sentencias, estructuras de datos, modulacion, etc. He emprendido un poco en el tema de la programación gráfica, hace aprox. 2 años hice un juego del ahorcado en con SDL (se que no es mucho, no obstante sólo quería probar diversas operaciones con los gráficos no un juego en sí), no recuerdo exactamente su manejo pero si me pongo al día con el manual oficial pues venga que podría! Así mismo he experimentado un poco con winbgim, aunque ésta no es multiplataforma y me ha costado un bojote conseguirla para el MinGW

Bases de Datos: sé manejarlas, crear tablas, campos, etc. etc. Quién sabe, puede ser útil (sólo he utilizado MySQL, pero venga que si nos toca con otra bien podríamos ponerlos al día)

Bueno, hace poco se me ha ocurrido implementar un algoritmo "genético" con un juego, al principio con un simple juego de tres en línea y luego con un ajedréz usando bases de datos (aunque he tenido problemas implementando MySQL en MinGW xD)

Cualquier cosa puedo mandar mi correo a los que estén en el grupo, si me aceptan, para conversar por skype o cualquier medio!

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

#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?)

#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

Hola! Muchas gracias por responder!

La verdad un no entiendo lo que me propones. Y aún no entiendo por qué sucede.

Con la función seno grafico sin problema alguno

...
...
#define WIDTH 720
#define HEIGHT 600
#define PI 3.1415
 
int main()
{
    float x, y;
    int 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));
        y=sin((2*PI*x)/640)*50;
        printf("f(%f) = %f\n", x, y);
        if (y<=0)
        {
            z=HEIGHT/2 - y;
        } if (y>=0)
        {
            z = abs(HEIGHT/2 - y);
        }
        if (z<HEIGHT && z>0 && i<WIDTH && i>0)
        {
            putpixel(i, z, COLOR(255, 255, 255));
        }
    }
    getch();
    closegraph();
    return 0;
}
 

Al igual que con la funcion f(x)=b

...
...
#define WIDTH 720
#define HEIGHT 600
#define PI 3.1415
 
int main()
{
    float x, y;
    int 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));
        //y=sin((2*PI*x)/640)*50;
        y=-20;
        printf("f(%f) = %f\n", x, y);
        if (y<=0)
        {
            z=HEIGHT/2 - y;
        } if (y>=0)
        {
            z = abs(HEIGHT/2 - y);
        }
        if (z<HEIGHT && z>0 && i<WIDTH && i>0)
        {
            putpixel(i, z, COLOR(255, 255, 255));
        }
    }
    getch();
    closegraph();
    return 0;
}
 

Ví que se grafica perfectamente con una ventana de height=width... Pero...
¿Por qué sucede ese "rebote" del f(x)=x-2 que mostré al principio? O.o

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.

#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

Ya entregue mi trabajo 

Yo personalmente di mis primeros pasos en phpya.com.ar toma por entendido que sabes algo de Html, luego de haberme estudiado todo y hacer cada ejercicio, empece a hacer mis scripts php y a medida que necesitaba mas y mas funciones (que no salen en phpya.com.ar) pues me meti en php.net y agarre las funciones que necesité.

Te recomiendo phpya.com.ar

Saludos

Muy buenos tus diseños todos me gustaron especialmente los ultimos, sigue asi

Saludos