Trabajo de Informática

Ir abajo

Trabajo de Informática

Mensaje  Invitado el Mar Ene 27, 2009 9:16 pm

Bueno, lo prometido es deuda, acabo de salir del examen, en el que nos han pedido que pusiésemos fuerza de rozamiento introducida por teclado después de echar a andar el programa.

Tengo lo que son 4 programitas distintos, dos con su MIERDA de librería, y otros dos con las librerías de OpenGL.



Este es el código del programa sin modificaciones, en su MIERDA de librería:

Código:
//#define VGA
#include <stdio.h>
#include <math.h>
#include <unistd.h>

#ifndef VGA
#define X_M 0
#define Y_M 0
#else
#include "graficos.h"
#define graf
struct ventana ve;
#endif
FILE *salida;

        //Definimos las variables generales

double h;         //Lapso de tiempo pequeño
int i;
double G=6.67e-11;      //constante de gravitación universal
double time;      //Tiempo transcurrido

#ifdef graf
double escala;      //escala para dibujar
#endif

#define TRUE 1      //Definimos TRUE
#define FALSE 0      //Definimos FALSE
#define ESCAPE 27   //Definimos el ESCAPE
int pauser=FALSE;   //Boolean para la pausa
int bucle=TRUE;      //Boolean para el bucle

        //Definimos las variables para la partícula

double x,y,M,R,h0;      //Posición, masa, distancia al centro de la tierra y altura a la superficie
double v_i;            //velocidad inicial

#ifdef graf
double y_d;      //Posición para dibujar
double y_old;      //Posición para borrar
double radio1;          //Radio de la partícula
#endif

        //Definimos las variables para la tierra

double Tierrax,Tierray;       //Posición de la tierra
double Masa;                   //Peso de la tierra
float R1=6371000,r=3490000;   //Radios de las distintas densidades
float ro1=4400,ro2=11000;   //Densidades de las distintas partes

#ifdef graf
double radio2;                 //Radio de la tierra
#endif



   //Función para calcular la masa total de la tierra, solo se llama en el main una vez

double Weight(float ro1,float ro2, float R1, float r)
{
    double Volume1,Volume2;

    Volume1=4*3.141592654*(R1*R1*R1-r*r*r)/3;
    Volume2=4*3.141592654*r*r*r/3;

    return(Volume1*ro1+Volume2*ro2);
}


   //Función para calcular la energía potencial, se la llama continuamente en el calcula

double energia_p(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(-G*Masa*M/R);
   }

   if(r<=R && R<R1)
   {
          return(-G*4./3.*3.141592654*M*(-0.5*ro1*R*R+(ro2-ro1)*r*r*r/R+1.5*ro1*R1*R1));
   }

   if(0<R && R<r)
   {
      return(-G*4./3.*3.141592654*M*(-0.5*ro2*R*R+1.5*(ro2-ro1)*r*r+1.5*ro1*R1*R1));
       }
}




   //Función para calcular la masa que interviene en la fuerza, se la llama en el calcula   
      
double peso_efectivo(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(Masa);
   }

   if(r<=R && R<R1)
   {
      Volume1=4*3.141592654*(R*R*R-r*r*r)/3;
          Volume2=4*3.141592654*r*r*r/3;

          return(Volume1*ro1+Volume2*ro2);
   }

   if(0<R && R<r)
   {
      Volume2=4*3.141592654*(R*R*R)/3;

      return(Volume1*ro1+Volume2*ro2);
       }
}


   //Función principal para el calculo físico

void calcula(void)
{
   double F;               //Fuerza
   double Energia,Energia_p,Energia_c;      //Energía total, potencial y cinética
   double delta_v,v_media;            //variación de velocidad y velocidad media

   y+=h*v_i;                     //Calculamos la nueva posición

       R=sqrt((y)*(y));               //Calculamos la distancia

   F=-G*peso_efectivo(y)*M*(y)/(R*R*R);        //Calculamos la fuerza, utilizando la función del peso efectivo
    //F-=0.00005*v_i;

   delta_v=F*h/M;                           //Calculamos la variación de velocidad

     v_i+=delta_v;               //Calculamos la nueva velocidad

   v_media=v_i-0.5*delta_v;         //Calculamos la velocidad media

   Energia_p=energia_p(y);            //Llamamos a la función de la energía potencial para obtenerla

   Energia_c=0.5*M*v_media*v_media;      //Obtenemos la energía cinética

   Energia=Energia_c+Energia_p;         //Obtenemos la energía total


   fprintf(salida,"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",time,y,v_i,Energia_p,Energia_c,Energia,F);
   //fprintf(salida,"\nx = %10.3f y = %10.3lf\n",x,y);
   //fprintf(salida,"Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   //fprintf(salida,"Masa = %10.3lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);

      //Debugger

   //printf("\nx = %10.3f y = %10.3lf\n",x,y);
   //printf("Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   //printf("Masa = %lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);
   //getchar();


   time+=h;               //Con esto hacemos que pase el tiempo
}

void procesa(void)
{
   int extended,c;

   extended=0;

   c=getchar();
   if(!c)extended=getchar();

   switch(c)
   {
      case ESCAPE:            //Con ESCAPE cerramos el archivo y hacemos que ya no repita el bucle
      fclose(salida);

      #ifdef graf
      inicia_graf(MODO_TXT);
      #endif

      bucle=FALSE;
      break;

/*      case 'p':            //Con la "P" pausamos el programa
      if(pauser==FALSE) {pauser=TRUE;break;}
      if(pauser==TRUE) pauser=FALSE;
      break;

      case '1':            //Con "1" es velocidad normal
      h=0.001;
      break;

      case '2':            //Con "2" es 5 veces la velocidad
      h=0.005;
      break;

      case '3':            //Con "3" es 10 veces la velocidad
      h=0.01;
      break;*/
   }
}

int main(int argc,char **argv)
{
    int mesfr=16,cont;



    switch(argc)
    {
        case 4:               //Introducimos tres números además del comando
               sscanf(argv[1],"%lf",&M);      //Masa de la partícula
               sscanf(argv[2],"%lf",&h0);      //Altura inicial
               sscanf(argv[3],"%lf",&v_i);      //Velocidad inicial
               break;
/*   case 8:               //Introducimos 7 números además del comando
      sscanf(argv[1],"%lf",&M);   //Masa de la partícula
           sscanf(argv[2],"%lf",&h0);   //Altura inicial
           sscanf(argv[3],"%lf",&v_i);   //Velocidad inicial
      sscanf(argv[4],"%f",&ro1);   //Densidad de la corteza
           sscanf(argv[5],"%f",&ro2);   //Densidad del núcleo
           sscanf(argv[6],"%f",&R1);   //Radio total
           sscanf(argv[7],"%f",&r);   //Radio del núcleo
      break;*/
   default:
          M=1;
          h0=0;
          v_i=0;
      break;
    }

   salida=fopen("salida.txt","wt");   //Abrimos el archivo

    fprintf(salida,"plot \"salida.txt\" using 1:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"replot \"salida.txt\" using 1:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"replot \"salida.txt\" using 1:5 t \"cinetica\" with lines 6\n");
    fprintf(salida,"pause -1 \"pulse intro\";");
    fprintf(salida,"plot \"salida.txt\" using 2:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"replot \"salida.txt\" using 2:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"replot \"salida.txt\" using 2:5 t \"cinetica\" with lines 6\n");

            //Fijamos todas las variables

        //Variables generales

    h=0.01;                //Lapso de tiempo pequeño

   #ifdef graf
       escala=150/R1;            //Escala para dibujar
   #endif

        //Variables de la partícula

    x=0;                  //Posición inicial x=0
    y=R1+h0;             //Posición inicial y=6.371e6 + h0

   #ifdef graf
       radio1=3;               //radio de la partícula
   #endif

        //Variables de la Tierra

    Tierrax=0;               //Centro x de la Tierra x=0
    Tierray=0;               //Centro y de la tierra y=0
    Masa=Weight(ro1,ro2,R1,r);       //Peso de la tierra, calculado con una función

   #ifdef graf
       radio2=150;                //Radio de la tierra
   #endif


    #ifdef graf      //Esto sirve para que si estamos trabajando en modo video creemos la ventana en la que se mostrará el programa
   ve.x_i=0;
   ve.y_i=0;
   
   ve.x_f=X_M-1;
   ve.y_f=Y_M-1;
   ve.borde=10;
   ve.colorw=VERDE;
   crea_ventana(&ve);
   #endif

    #ifdef graf
         color=AZUL;

         elipse_f((int)X_M/2, (int)y*escala+Y_M/2, (int)radio1, (int)radio1,ROJO);      //Dibujamos la partícula
         elipse((int)X_M/2, (int)Y_M/2, (int)radio2, (int)radio2,color);            //Dibujamos la Tierra

         getchar()                     //Para que tengamos que pulsar algo para que empiece a funcionar
   #endif

   cont=0;

   while(bucle==TRUE)
   {
      //if(kbhit())procesa();
      #ifdef graf
         if((cont%mesfr)==0)
         {
            elipse_f((int)X_M/2, (int)y*escala+Y_M/2, (int)radio1, (int)radio1,ROJO);      //Dibujamos la partícula
            elipse((int)X_M/2, (int)Y_M/2, (int)radio2, (int)radio2,color);          //Dibujamos la Tierra

                      y_old=y*escala+Y_M/2;    //Ponemos el valor de y antes de cambiarlo en una variable para después borrar
         }
      #endif
      
      if(pauser==FALSE)
      {
         calcula();    //Calculamos las nuevas posiciones
      }

      #ifdef graf

      // Borro la imagen para no ver la estela

      if((cont%mesfr)==(mesfr-1))
      {
         elipse_f((int)X_M/2, (int)y_old, (int)radio1, (int)radio1,NEGRO);
          }

      cont++;
      #endif
   }
}

Está preparado para modo gráfico con su MIERDA de librería, solo hay que descomentar #define VGA

Invitado
Invitado


Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Invitado el Mar Ene 27, 2009 9:17 pm

Este es el código del programa con modificaciones y su MIERDA de librería:

Código:
//#define VGA
#include <stdio.h>
#include <math.h>
#include <unistd.h>

#ifndef VGA
#define X_M 0
#define Y_M 0
#else
#include "graficos.h"
#define graf
struct ventana ve;
#endif
FILE *salida;

        //Definimos las variables generales

double h;         //Lapso de tiempo pequeño
int i;
double G=6.67e-11;      //constante de gravitación universal
double time;      //Tiempo transcurrido
float mu;

#ifdef graf
double escala;      //escala para dibujar
#endif

#define TRUE 1      //Definimos TRUE
#define FALSE 0      //Definimos FALSE
#define ESCAPE 27   //Definimos el ESCAPE
int pauser=FALSE;   //Boolean para la pausa
int bucle=TRUE;      //Boolean para el bucle

        //Definimos las variables para la partícula

double x,y,M,R,h0;      //Posición, masa, distancia al centro de la tierra y altura a la superficie
double v_i;            //velocidad inicial

#ifdef graf
double y_d;      //Posición para dibujar
double y_old;      //Posición para borrar
double radio1;          //Radio de la partícula
#endif

        //Definimos las variables para la tierra

double Tierrax,Tierray;       //Posición de la tierra
double Masa;                   //Peso de la tierra
float R1=6371000,r=3490000;   //Radios de las distintas densidades
float ro1=4400,ro2=11000;   //Densidades de las distintas partes

#ifdef graf
double radio2;                 //Radio de la tierra
#endif



   //Función para calcular la masa total de la tierra, solo se llama en el main una vez

double Weight(float ro1,float ro2, float R1, float r)
{
    double Volume1,Volume2;

    Volume1=4*3.141592654*(R1*R1*R1-r*r*r)/3;
    Volume2=4*3.141592654*r*r*r/3;

    return(Volume1*ro1+Volume2*ro2);
}


   //Función para calcular la energía potencial, se la llama continuamente en el calcula

double energia_p(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(-G*Masa*M/R);
   }

   if(r<=R && R<R1)
   {
          return(-G*4./3.*3.141592654*M*(-0.5*ro1*R*R+(ro2-ro1)*r*r*r/R+1.5*ro1*R1*R1));
   }

   if(0<R && R<r)
   {
      return(-G*4./3.*3.141592654*M*(-0.5*ro2*R*R+1.5*(ro2-ro1)*r*r+1.5*ro1*R1*R1));
       }
}




   //Función para calcular la masa que interviene en la fuerza, se la llama en el calcula   
      
double peso_efectivo(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(Masa);
   }

   if(r<=R && R<R1)
   {
      Volume1=4*3.141592654*(R*R*R-r*r*r)/3;
          Volume2=4*3.141592654*r*r*r/3;

          return(Volume1*ro1+Volume2*ro2);
   }

   if(0<R && R<r)
   {
      Volume2=4*3.141592654*(R*R*R)/3;

      return(Volume1*ro1+Volume2*ro2);
       }
}


   //Función principal para el calculo físico

void calcula(void)
{
   double F;               //Fuerza
   double Energia,Energia_p,Energia_c;      //Energía total, potencial y cinética
   double delta_v,v_media;            //variación de velocidad y velocidad media

   y+=h*v_i;                     //Calculamos la nueva posición

       R=sqrt((y)*(y));               //Calculamos la distancia

   F=-G*peso_efectivo(y)*M*(y)/(R*R*R);        //Calculamos la fuerza, utilizando la función del peso efectivo
    F-=mu*v_i;

   delta_v=F*h/M;                           //Calculamos la variación de velocidad

     v_i+=delta_v;               //Calculamos la nueva velocidad

   v_media=v_i-0.5*delta_v;         //Calculamos la velocidad media

   Energia_p=energia_p(y);            //Llamamos a la función de la energía potencial para obtenerla

   Energia_c=0.5*M*v_media*v_media;      //Obtenemos la energía cinética

   Energia=Energia_c+Energia_p;         //Obtenemos la energía total


   fprintf(salida,"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",time,y,v_i,Energia_p,Energia_c,Energia,F);
   //fprintf(salida,"\nx = %10.3f y = %10.3lf\n",x,y);
   //fprintf(salida,"Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   //fprintf(salida,"Masa = %10.3lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);

      //Debugger

   //printf("\nx = %10.3f y = %10.3lf\n",x,y);
   //printf("Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   //printf("Masa = %lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);
   //getchar();


   time+=h;               //Con esto hacemos que pase el tiempo
}

void procesa(void)
{
   int extended,c;

   extended=0;

   c=getchar();
   if(!c)extended=getchar();

   switch(c)
   {
      case ESCAPE:            //Con ESCAPE cerramos el archivo y hacemos que ya no repita el bucle
      fclose(salida);

      #ifdef graf
      inicia_graf(MODO_TXT);
      #endif

      bucle=FALSE;
      break;

/*      case 'p':            //Con la "P" pausamos el programa
      if(pauser==FALSE) {pauser=TRUE;break;}
      if(pauser==TRUE) pauser=FALSE;
      break;

      case '1':            //Con "1" es velocidad normal
      h=0.001;
      break;

      case '2':            //Con "2" es 5 veces la velocidad
      h=0.005;
      break;

      case '3':            //Con "3" es 10 veces la velocidad
      h=0.01;
      break;*/
   }
}

int main(int argc,char **argv)
{
    int mesfr=16,cont;



    switch(argc)
    {
        case 4:               //Introducimos tres números además del comando
               sscanf(argv[1],"%lf",&M);      //Masa de la partícula
               sscanf(argv[2],"%lf",&h0);      //Altura inicial
               sscanf(argv[3],"%lf",&v_i);      //Velocidad inicial
               break;
/*   case 8:               //Introducimos 7 números además del comando
      sscanf(argv[1],"%lf",&M);   //Masa de la partícula
           sscanf(argv[2],"%lf",&h0);   //Altura inicial
           sscanf(argv[3],"%lf",&v_i);   //Velocidad inicial
      sscanf(argv[4],"%f",&ro1);   //Densidad de la corteza
           sscanf(argv[5],"%f",&ro2);   //Densidad del núcleo
           sscanf(argv[6],"%f",&R1);   //Radio total
           sscanf(argv[7],"%f",&r);   //Radio del núcleo
      break;*/
   default:
          M=1;
          h0=0;
          v_i=0;
      break;
    }
    printf("Introduce la fuerza de rozamiento\n");
    scanf("%f",&mu);

   salida=fopen("salida.txt","wt");   //Abrimos el archivo

    fprintf(salida,"plot \"salida.txt\" using 1:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"replot \"salida.txt\" using 1:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"replot \"salida.txt\" using 1:5 t \"cinetica\" with lines 6\n");
    fprintf(salida,"pause -1 \"pulse intro\";");
    fprintf(salida,"plot \"salida.txt\" using 2:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"replot \"salida.txt\" using 2:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"replot \"salida.txt\" using 2:5 t \"cinetica\" with lines 6\n");

            //Fijamos todas las variables

        //Variables generales

    h=0.01;                //Lapso de tiempo pequeño

   #ifdef graf
       escala=150/R1;            //Escala para dibujar
   #endif

        //Variables de la partícula

    x=0;                  //Posición inicial x=0
    y=R1+h0;             //Posición inicial y=6.371e6 + h0

   #ifdef graf
       radio1=3;               //radio de la partícula
   #endif

        //Variables de la Tierra

    Tierrax=0;               //Centro x de la Tierra x=0
    Tierray=0;               //Centro y de la tierra y=0
    Masa=Weight(ro1,ro2,R1,r);       //Peso de la tierra, calculado con una función

   #ifdef graf
       radio2=150;                //Radio de la tierra
   #endif


    #ifdef graf      //Esto sirve para que si estamos trabajando en modo video creemos la ventana en la que se mostrará el programa
   ve.x_i=0;
   ve.y_i=0;
   
   ve.x_f=X_M-1;
   ve.y_f=Y_M-1;
   ve.borde=10;
   ve.colorw=VERDE;
   crea_ventana(&ve);
   #endif

    #ifdef graf
         color=AZUL;

         elipse_f((int)X_M/2, (int)y*escala+Y_M/2, (int)radio1, (int)radio1,ROJO);      //Dibujamos la partícula
         elipse((int)X_M/2, (int)Y_M/2, (int)radio2, (int)radio2,color);            //Dibujamos la Tierra

         getchar()                     //Para que tengamos que pulsar algo para que empiece a funcionar
   #endif

   cont=0;

   while(bucle==TRUE)
   {
      //if(kbhit())procesa();
      #ifdef graf
         if((cont%mesfr)==0)
         {
            elipse_f((int)X_M/2, (int)y*escala+Y_M/2, (int)radio1, (int)radio1,ROJO);      //Dibujamos la partícula
            elipse((int)X_M/2, (int)Y_M/2, (int)radio2, (int)radio2,color);          //Dibujamos la Tierra

                      y_old=y*escala+Y_M/2;    //Ponemos el valor de y antes de cambiarlo en una variable para después borrar
         }
      #endif
      
      if(pauser==FALSE)
      {
         calcula();    //Calculamos las nuevas posiciones
      }

      #ifdef graf

      // Borro la imagen para no ver la estela

      if((cont%mesfr)==(mesfr-1))
      {
         elipse_f((int)X_M/2, (int)y_old, (int)radio1, (int)radio1,NEGRO);
          }

      cont++;
      #endif
   }
}

Invitado
Invitado


Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Invitado el Mar Ene 27, 2009 9:18 pm

Y ahora viene lo bueno, un verdadero programa hecho por profesionales, o sea, yo. 😉

Está hecho para OpenGL y GLUT así que no creo que lo podáis compilar con lo que tenéis, por lo que abajo del todo os voy a poner una imagen de como se ve.

Código:
/* Este programa está realizado bajo licencia GPL   */
/* El programa original fue realizado por Bruno Jiménez   */
/* Cualquier modificación, error o cualquier cosa,
  notificarla a brunojimen@gmail.com         */


#include <GL/glut.h>    // Header File For The GLUT Library
#include <GL/gl.h>   // Header File For The OpenGL32 Library
#include <GL/glu.h>   // Header File For The GLu32 Library
#include <unistd.h>    // Header File For sleeping.
#include <stdlib.h>
#include <stdio.h>

#include "lib_2d.h"
FILE *salida;

        //Definimos las variables generales

double h;         //Lapso de tiempo pequeño
int i;
double G=6.67e-11;      //Constante de gravitación universal
double time;      //Tiempo transcurrido

double escala;      //Escala para dibujar

float rotate=0.5;   //Variable para girar nuestra esfera
#define TRUE 1      //Definimos TRUE
#define FALSE 0      //Definimos FALSE
int pauser=FALSE;   //Boolean para pausar el programa

        //Definimos las variables para la partícula

double x,y,M,R,h0;      //Posición, masa, distancia al centro de la tierra y altura a la superficie
double v_i;            //velocidad inicial
double x_old,y_old;
double radio1;          //Radio de la partícula

        //Definimos las variables para la tierra

double Tierrax,Tierray;       //Posición de la tierra
double Masa;                   //Peso de la tierra
double radio2;                 //Radio de la tierra
float R1=6371000,r=3490000;   //Radios de las distintas densidades
float ro1=4400,ro2=11000;   //Densidades de las distintas partes



double Weight(float ro1,float ro2, float R1, float r)
{
    double Volume1,Volume2;

    Volume1=4*3.141592654*(R1*R1*R1-r*r*r)/3;
    Volume2=4*3.141592654*r*r*r/3;

    return(Volume1*ro1+Volume2*ro2);
}

double energia_p(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(-G*Masa*M/R);
   }

   if(r<=R && R<R1)
   {
          return(-G*4./3.*3.141592654*M*(-0.5*ro1*R*R+(ro2-ro1)*r*r*r/R+1.5*ro1*R1*R1));
   }

   if(0<R && R<r)
   {
      return(-G*4./3.*3.141592654*M*(-0.5*ro2*R*R+1.5*(ro2-ro1)*r*r+1.5*ro1*R1*R1));
       }
}
   
      
double peso_efectivo(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(Masa);
   }

   if(r<=R && R<R1)
   {
      Volume1=4*3.141592654*(R*R*R-r*r*r)/3;
          Volume2=4*3.141592654*r*r*r/3;

          return(Volume1*ro1+Volume2*ro2);
   }

   if(0<R && R<r)
   {
      Volume2=4*3.141592654*(R*R*R)/3;

      return(Volume1*ro1+Volume2*ro2);
       }
}

void calcula(void)
{
   double F;               //Fuerza
   double Energia,Energia_p,Energia_c;      //Energía total, potencial y cinética
   double delta_v,v_media;            //variación de velocidad y velocidad media

   y+=h*v_i;                     //Calculamos la nueva posición

       R=sqrt((y)*(y));               //Calculamos la distancia

   F=-G*peso_efectivo(y)*M*(y)/(R*R*R);        //Calculamos la fuerza, utilizando la función del peso efectivo
    //F-=0.00005*v_i;

   delta_v=F*h/M;                           //Calculamos la variación de velocidad

     v_i+=delta_v;               //Calculamos la nueva velocidad

   v_media=v_i-0.5*delta_v;         //Calculamos la velocidad media

   Energia_p=energia_p(y);            //Llamamos a la función de la energía potencial para obtenerla

   Energia_c=0.5*M*v_media*v_media;      //Obtenemos la energía cinética

   Energia=Energia_c+Energia_p;         //Obtenemos la energía total



   fprintf(salida,"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",time,y,v_i,Energia_p,Energia_c,Energia,F);
/*
   fprintf(salida,"\nx = %10.3f y = %10.3lf\n",x,y);
   fprintf(salida,"Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   fprintf(salida,"Masa = %10.3lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);
*/   


      //Debugger

   //printf("\nx = %10.3f y = %10.3lf\n",x,y);
   //printf("Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   //printf("Masa = %10.3lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);
   //getchar();


   time+=h;               //Con esto hacemos que pase el tiempo
}







/* ASCII code for the escape key. */
#define ESCAPE 27

/* The number of our GLUT window */
int window;

/* A general OpenGL initialization function.  Sets all of the initial parameters. */
void InitGL(int Width, int Height)           // We call this right after our OpenGL window is created.
{
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);      // This Will Clear The Background Color To Black
  glClearDepth(1.0);            // Enables Clearing Of The Depth Buffer
  glDepthFunc(GL_LESS);            // The Type Of Depth Test To Do
  glEnable(GL_DEPTH_TEST);         // Enables Depth Testing
  glShadeModel(GL_SMOOTH);         // Enables Smooth Color Shading

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();            // Reset The Projection Matrix

  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);   // Calculate The Aspect Ratio Of The Window

  glMatrixMode(GL_MODELVIEW);
}

/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
void ReSizeGLScene(int Width, int Height)
{
  if (Height==0)            // Prevent A Divide By Zero If The Window Is Too Small
    Height=1;

  glViewport(0, 0, Width, Height);      // Reset The Current Viewport And Perspective Transformation

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
  glMatrixMode(GL_MODELVIEW);
}

/* The main drawing function. */
void DrawGLScene()
{

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);      // Clear The Screen And The Depth Buffer
  glLoadIdentity();            // Reset The View

  glTranslatef(0.0f,0.0f,-99.0f);
  glRotatef(rotate,0.0f,1.0f,0.0f);

   gridsphere(radio2,25,25,ROJO);
   elipse(x,y*escala,radio1,radio1,AZUL);


   if(pauser==FALSE)
   {
      rotate=rotate+0.5;
      calcula();
   }


  // swap buffers to display, since we're double buffered.
  glutSwapBuffers();
}

/* The function called whenever a key is pressed. */
void keyPressed(unsigned char key, int x, int y)
{
    /* avoid thrashing this procedure */
    usleep(100);

    /* If escape is pressed, kill everything. */
    switch(key)
    {
      case ESCAPE:
      fclose(salida);
      glutDestroyWindow(window);
      exit(0);
      break;

      case 'p':
      if(pauser==FALSE) {pauser=TRUE;break;}
      if(pauser==TRUE) pauser=FALSE;
      break;

      case '1':
      h=0.1;
      break;

      case '2':
      h=0.5;
      break;

      case '3':
      h=1;
      break;
    }
}



int main(int argc, char **argv)
{

   

    switch(argc)
    {
        case 4:               //Introducimos tres números además del comando
            sscanf(argv[1],"%lf",&M);      //Masa de la partícula
            sscanf(argv[2],"%lf",&h0);      //Altura inicial
            sscanf(argv[3],"%lf",&v_i);      //Velocidad inicial
            break;
/*   case 8:               //Introducimos 7 números además del comando
      sscanf(argv[1],"%lf",&M);   //Masa de la partícula
           sscanf(argv[2],"%lf",&h0);   //Altura inicial
           sscanf(argv[3],"%lf",&v_i);   //Velocidad inicial
      sscanf(argv[4],"%f",&ro1);   //Densidad de la corteza
           sscanf(argv[5],"%f",&ro2);   //Densidad del núcleo
           sscanf(argv[6],"%f",&R1);   //Radio total
           sscanf(argv[7],"%f",&r);   //Radio del núcleo
      break;*/
   default:
          M=1;
          h0=0;
          v_i=0;
/*      ro1=4.4;
      ro2=11;
      R1=63.71;
      r=34.90;*/
      break;
    }


   salida=fopen("salida.txt","wt");   //Abrimos el archivo

    fprintf(salida,"plot \"salida.txt\" using 1:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 1:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 1:5 t \"cinetica\" with lines 6\n");
    fprintf(salida,"pause -1 \"pulse intro\";");
    fprintf(salida,"plot \"salida.txt\" using 2:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 2:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 2:5 t \"cinetica\" with lines 6\n");



            //Fijamos todas las variables

        //Variables generales

    h=0.1;    //Lapso de tiempo pequeño

   escala=35/R1;

        //Variables de la partícula

    x=0;                   //Posición inicial x=0
    y=R1+h0;             //Posición inicial y=40
    radio1=2;               //radio de la partícula

        //Variables de la Tierra

    Tierrax=0;               //Centro x de la Tierra x=0
    Tierray=0;               //Centro y de la tierra y=0
    Masa=Weight(ro1,ro2,R1,r);       //Peso de la tierra, calculado con una función
    radio2=35;                //Radio de la tierra



  /* Initialize GLUT state - glut will take any command line arguments that pertain to it or
    X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */ 
  glutInit(&argc, argv); 

  /* Select type of Display mode: 
    Double buffer
    RGBA color
    Alpha components supported
    Depth buffer */ 
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH); 

  /* get a 640 x 480 window */
  glutInitWindowSize(640, 480); 

  /* the window starts at the upper left corner of the screen */
  glutInitWindowPosition(0, 0); 

  /* Open a window */ 
  window = glutCreateWindow("Tunel"); 

  /* Register the function to do all our OpenGL drawing. */
  glutDisplayFunc(&DrawGLScene); 

  /* Even if there are no events, redraw our gl scene. */
  glutIdleFunc(&DrawGLScene);

  /* Register the function called when our window is resized. */
  glutReshapeFunc(&ReSizeGLScene);

  /* Register the function called when the keyboard is pressed. */
  glutKeyboardFunc(&keyPressed);

  /* Initialize our window. */
  InitGL(640, 480);
 
  /* Start Event Processing Engine */ 
  glutMainLoop(); 

  return 1;
}

Invitado
Invitado


Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Invitado el Mar Ene 27, 2009 9:18 pm

Ese sería el programa sin modificación, y ahora os pongo uno con modificación.

Código:
/* Este programa está realizado bajo licencia GPL   */
/* El programa original fue realizado por Bruno Jiménez   */
/* Cualquier modificación, error o cualquier cosa,
  notificarla a brunojimen@gmail.com         */


#include <GL/glut.h>    // Header File For The GLUT Library
#include <GL/gl.h>   // Header File For The OpenGL32 Library
#include <GL/glu.h>   // Header File For The GLu32 Library
#include <unistd.h>    // Header File For sleeping.
#include <stdlib.h>
#include <stdio.h>

#include "lib_2d.h"
FILE *salida;

        //Definimos las variables generales

double h;         //Lapso de tiempo pequeño
int i;
double G=6.67e-11;      //Constante de gravitación universal
double time;      //Tiempo transcurrido
float mu;      //Constante de rozamiento

double escala;      //Escala para dibujar

float rotate=0.5;   //Variable para girar nuestra esfera
#define TRUE 1      //Definimos TRUE
#define FALSE 0      //Definimos FALSE
int pauser=FALSE;   //Boolean para pausar el programa

        //Definimos las variables para la partícula

double x,y,M,R,h0;      //Posición, masa, distancia al centro de la tierra y altura a la superficie
double v_i;            //velocidad inicial
double x_old,y_old;
double radio1;          //Radio de la partícula

        //Definimos las variables para la tierra

double Tierrax,Tierray;       //Posición de la tierra
double Masa;                   //Peso de la tierra
double radio2;                 //Radio de la tierra
float R1=6371000,r=3490000;   //Radios de las distintas densidades
float ro1=4400,ro2=11000;   //Densidades de las distintas partes



double Weight(float ro1,float ro2, float R1, float r)
{
    double Volume1,Volume2;

    Volume1=4*3.141592654*(R1*R1*R1-r*r*r)/3;
    Volume2=4*3.141592654*r*r*r/3;

    return(Volume1*ro1+Volume2*ro2);
}

double energia_p(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(-G*Masa*M/R);
   }

   if(r<=R && R<R1)
   {
          return(-G*4./3.*3.141592654*M*(-0.5*ro1*R*R+(ro2-ro1)*r*r*r/R+1.5*ro1*R1*R1));
   }

   if(0<R && R<r)
   {
      return(-G*4./3.*3.141592654*M*(-0.5*ro2*R*R+1.5*(ro2-ro1)*r*r+1.5*ro1*R1*R1));
       }
}
   
      
double peso_efectivo(double y)
{
   double Volume1=0,Volume2=0;

   if(R1<=R)
   {
      return(Masa);
   }

   if(r<=R && R<R1)
   {
      Volume1=4*3.141592654*(R*R*R-r*r*r)/3;
          Volume2=4*3.141592654*r*r*r/3;

          return(Volume1*ro1+Volume2*ro2);
   }

   if(0<R && R<r)
   {
      Volume2=4*3.141592654*(R*R*R)/3;

      return(Volume1*ro1+Volume2*ro2);
       }
}

void calcula(void)
{
   double F;               //Fuerza
   double Energia,Energia_p,Energia_c;      //Energía total, potencial y cinética
   double delta_v,v_media;            //variación de velocidad y velocidad media

   y+=h*v_i;                     //Calculamos la nueva posición

       R=sqrt((y)*(y));               //Calculamos la distancia

   F=-G*peso_efectivo(y)*M*(y)/(R*R*R);        //Calculamos la fuerza, utilizando la función del peso efectivo
       F-=mu*v_i;

   delta_v=F*h/M;                           //Calculamos la variación de velocidad

     v_i+=delta_v;               //Calculamos la nueva velocidad

   v_media=v_i-0.5*delta_v;         //Calculamos la velocidad media

   Energia_p=energia_p(y);            //Llamamos a la función de la energía potencial para obtenerla

   Energia_c=0.5*M*v_media*v_media;      //Obtenemos la energía cinética

   Energia=Energia_c+Energia_p;         //Obtenemos la energía total



   fprintf(salida,"%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n",time,y,v_i,Energia_p,Energia_c,Energia,F);
/*
   fprintf(salida,"\nx = %10.3f y = %10.3lf\n",x,y);
   fprintf(salida,"Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   fprintf(salida,"Masa = %10.3lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);
*/   


      //Debugger

   //printf("\nx = %10.3f y = %10.3lf\n",x,y);
   //printf("Energía potencial = %10.3lf Energía cinética = %10.3lf\nEnergía total = %10.3lf\n",Energia_p,Energia_c,Energia);
   //printf("Masa = %10.3lf Fuerza = %10.3lf Distancia = %10.3lf\n",Masa,F,R);
   //getchar();


   time+=h;               //Con esto hacemos que pase el tiempo
}







/* ASCII code for the escape key. */
#define ESCAPE 27

/* The number of our GLUT window */
int window;

/* A general OpenGL initialization function.  Sets all of the initial parameters. */
void InitGL(int Width, int Height)           // We call this right after our OpenGL window is created.
{
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);      // This Will Clear The Background Color To Black
  glClearDepth(1.0);            // Enables Clearing Of The Depth Buffer
  glDepthFunc(GL_LESS);            // The Type Of Depth Test To Do
  glEnable(GL_DEPTH_TEST);         // Enables Depth Testing
  glShadeModel(GL_SMOOTH);         // Enables Smooth Color Shading

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();            // Reset The Projection Matrix

  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);   // Calculate The Aspect Ratio Of The Window

  glMatrixMode(GL_MODELVIEW);
}

/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
void ReSizeGLScene(int Width, int Height)
{
  if (Height==0)            // Prevent A Divide By Zero If The Window Is Too Small
    Height=1;

  glViewport(0, 0, Width, Height);      // Reset The Current Viewport And Perspective Transformation

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height,0.1f,100.0f);
  glMatrixMode(GL_MODELVIEW);
}

/* The main drawing function. */
void DrawGLScene()
{

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);      // Clear The Screen And The Depth Buffer
  glLoadIdentity();            // Reset The View

  glTranslatef(0.0f,0.0f,-99.0f);
  glRotatef(rotate,0.0f,1.0f,0.0f);

   gridsphere(radio2,25,25,ROJO);
   elipse(x,y*escala,radio1,radio1,AZUL);


   if(pauser==FALSE)
   {
      rotate=rotate+0.5;
      calcula();
   }


  // swap buffers to display, since we're double buffered.
  glutSwapBuffers();
}

/* The function called whenever a key is pressed. */
void keyPressed(unsigned char key, int x, int y)
{
    /* avoid thrashing this procedure */
    usleep(100);

    /* If escape is pressed, kill everything. */
    switch(key)
    {
      case ESCAPE:
      fclose(salida);
      glutDestroyWindow(window);
      exit(0);
      break;

      case 'p':
      if(pauser==FALSE) {pauser=TRUE;break;}
      if(pauser==TRUE) pauser=FALSE;
      break;

      case '1':
      h=0.1;
      break;

      case '2':
      h=0.5;
      break;

      case '3':
      h=1;
      break;
    }
}



int main(int argc, char **argv)
{

   

    switch(argc)
    {
        case 4:               //Introducimos tres números además del comando
            sscanf(argv[1],"%lf",&M);      //Masa de la partícula
            sscanf(argv[2],"%lf",&h0);      //Altura inicial
            sscanf(argv[3],"%lf",&v_i);      //Velocidad inicial
            break;
/*   case 8:               //Introducimos 7 números además del comando
      sscanf(argv[1],"%lf",&M);   //Masa de la partícula
           sscanf(argv[2],"%lf",&h0);   //Altura inicial
           sscanf(argv[3],"%lf",&v_i);   //Velocidad inicial
      sscanf(argv[4],"%f",&ro1);   //Densidad de la corteza
           sscanf(argv[5],"%f",&ro2);   //Densidad del núcleo
           sscanf(argv[6],"%f",&R1);   //Radio total
           sscanf(argv[7],"%f",&r);   //Radio del núcleo
      break;*/
   default:
          M=1;
          h0=0;
          v_i=0;
/*      ro1=4.4;
      ro2=11;
      R1=63.71;
      r=34.90;*/
      break;
    }

    printf("Introduce la fuerza de rozamiento\n");
    scanf("%f",&mu);


   salida=fopen("salida.txt","wt");   //Abrimos el archivo

    fprintf(salida,"plot \"salida.txt\" using 1:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 1:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 1:5 t \"cinetica\" with lines 6\n");
    fprintf(salida,"pause -1 \"pulse intro\";");
    fprintf(salida,"plot \"salida.txt\" using 2:3 t \"velocidad\" with lines 4\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 2:4 t \"potencial\" with lines 5\n");
    fprintf(salida,"pause 4;");
    fprintf(salida,"plot \"salida.txt\" using 2:5 t \"cinetica\" with lines 6\n");




            //Fijamos todas las variables

        //Variables generales

    h=0.1;    //Lapso de tiempo pequeño

   escala=35/R1;

        //Variables de la partícula

    x=0;                   //Posición inicial x=0
    y=R1+h0;             //Posición inicial y=40
    radio1=2;               //radio de la partícula

        //Variables de la Tierra

    Tierrax=0;               //Centro x de la Tierra x=0
    Tierray=0;               //Centro y de la tierra y=0
    Masa=Weight(ro1,ro2,R1,r);       //Peso de la tierra, calculado con una función
    radio2=35;                //Radio de la tierra



  /* Initialize GLUT state - glut will take any command line arguments that pertain to it or
    X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */ 
  glutInit(&argc, argv); 

  /* Select type of Display mode: 
    Double buffer
    RGBA color
    Alpha components supported
    Depth buffer */ 
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH); 

  /* get a 640 x 480 window */
  glutInitWindowSize(640, 480); 

  /* the window starts at the upper left corner of the screen */
  glutInitWindowPosition(0, 0); 

  /* Open a window */ 
  window = glutCreateWindow("Tunel"); 

  /* Register the function to do all our OpenGL drawing. */
  glutDisplayFunc(&DrawGLScene); 

  /* Even if there are no events, redraw our gl scene. */
  glutIdleFunc(&DrawGLScene);

  /* Register the function called when our window is resized. */
  glutReshapeFunc(&ReSizeGLScene);

  /* Register the function called when the keyboard is pressed. */
  glutKeyboardFunc(&keyPressed);

  /* Initialize our window. */
  InitGL(640, 480);
 
  /* Start Event Processing Engine */ 
  glutMainLoop(); 

  return 1;
}


Y ahora la fotito del programa:



NOTA IMPORTANTE: TODOS ESTOS PROGRAMAS ESTÁN HECHOS BAJO LICENCIA GPL.

Invitado
Invitado


Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Raven el Miér Ene 28, 2009 1:40 am

Uh, yo de Turbo Pascal no paso... Y eso que me he estado mordiendo con él esta tarde. 4 problemas de Arrays. xD
avatar
Raven
Espectro Otaku
Espectro Otaku

Cantidad de envíos : 59
Fecha de inscripción : 15/01/2009
Edad : 30
Localización : Hummm... Mentalmente no sé. Físicamente Tudela.

Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Nezumi el Miér Ene 28, 2009 2:06 am

La verdad es que se pueden llegar a hacer muchas mas cosas con C que con pascal. Yo no le he encontrado ningun uso al turbopascal asi que

_________________
avatar
Nezumi
Espectro Otaku
Espectro Otaku

Cantidad de envíos : 147
Fecha de inscripción : 11/12/2008
Edad : 29
Localización : Alfaro

http://otakuisland.260mb.com

Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Invitado el Miér Ene 28, 2009 12:40 pm

Turbopascal está medio muerto... y en C no es que se puedan hacer tantas cosas, lo que pasa es que con OpenGL y eso se pueden hacer cosas muy muy chulas.

Invitado
Invitado


Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Raven el Miér Ene 28, 2009 2:02 pm

Jo, podríamos dar cosas más interesantes en informática... Programas de desarrollo de vieojuegos o algo así.
Sería genial.
avatar
Raven
Espectro Otaku
Espectro Otaku

Cantidad de envíos : 59
Fecha de inscripción : 15/01/2009
Edad : 30
Localización : Hummm... Mentalmente no sé. Físicamente Tudela.

Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Invitado el Miér Ene 28, 2009 2:46 pm

¿Igual te crees que nos han enseñado la mitad...? Esto es el fruto de unas cuantas muchas horas de investigación. Cuando vuelva ya os enseñaré un poco a programar en C si eso.

Invitado
Invitado


Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Nezumi el Jue Ene 29, 2009 12:50 am

Eso eso interesa, solo por curiosidad

la informatica mola jaja

_________________
avatar
Nezumi
Espectro Otaku
Espectro Otaku

Cantidad de envíos : 147
Fecha de inscripción : 11/12/2008
Edad : 29
Localización : Alfaro

http://otakuisland.260mb.com

Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Shizuku el Jue Ene 29, 2009 2:18 am

En respuesta a Nezu:

La informatica mola.... siempre k el ordenador no se te casque y no tengas que llamr al inventor de crtl+z...
avatar
Shizuku
Shinigami
Shinigami

Cantidad de envíos : 281
Fecha de inscripción : 11/12/2008
Edad : 29
Localización : Monty

http://www.otakuisland.260mb.com

Volver arriba Ir abajo

Re: Trabajo de Informática

Mensaje  Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Volver arriba


 
Permisos de este foro:
No puedes responder a temas en este foro.