Trabajo de Informática

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

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


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;
}


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.

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

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

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.

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

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

Eso eso interesa, solo por curiosidad

la informatica mola jaja

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