ESTE BLOG SE MANEJA COMO UN LIBRO. SI VAS AL INDICE ENCONTRARAS TODOS LOS TEMAS ORDENADOS POR MATERIAS. MUCHAS GRACIAS.

FORTRAN + ANALiSIS NUMERICO (Euler simple h variable)

Bueno, ahora vengo a presentares algo increíble... Un libro de fortran! Si. Descarga completamente gratuito, si leen atentamente tendrán todo lo que necesitan para interpretar el lenguaje fortran con facilidad. 

Este lenguaje de programación se utiliza para aplicaciones en ingeniería y matemática generalmente. Por lo tanto vengo a dejar también algunos programas interesantes.

Para los que no sepan de que va... el análisis numérico es la rama de la matemática que se encarga de utilizar las herramientas matemáticas previamente obtenidas para la resolución de problemas numéricos. Los problemas numéricos son aquellos que no pueden ser resueltos de manera analítica (es decir, haciendo cuentas con el lápiz y papel) y necesitan de una APROXIMACIÓN numérica. Un valor que, dependiendo del problema, se encontrara tan cerca del resultado que podemos asumir que es el resultado.

En el análisis numérico no se obtiene una función resultado como en la resolución analítica. Acá obtenemos una serie de puntos discretos (con un determinado error dependiendo del método de resolución seleccionado, cada uno con sus ventajas y desventajas) que serán la aproximación numérica de la función resultado. 

Libro de fortran: Descarga acá

Programa de análisis numérico: EULER SIMPLE.

Este método de resolución se basa en la aproximación por serie de Taylor utilizando los 2 primeros términos. Es una aproximación muy burda pero logra grandes resultados cuando se utiliza un intervalo relativamente chico y un paso de aproximación igual de chico.
Utiliza poca memoria y es fácil de programar. 
Desventajas: falla al hacer análisis de intervalos grandes. 

Este programa en particular que dejo escrito es con "h variable". Esto significa que el programa por si mismo corrige el paso para que los resultados tengan menos de un error previamente explicitado. Las desventajas son obvias... Quizas la h tiene que hacerse tan chica que nunca llega al final del intervalo, aparte que después buscar la respuesta que queres es dificultoso.. a menos que lo escribas en un archivo (altamente recomendable).

!en este programa alocan los vectores desde 1 y no desde 0
PROGRAM Eulersimple
implicit none 

real, allocatable::  v(:)
real xf,h
integer n,var 
REAL, PARAMETER :: ee=2.71828

 var= 2   !cantidad de componentes del vector
 allocate (v(var))
 v(1)=0.
 v(2)=5.
 xf=10.
 h=1.
    

 n=int((xf-v(1))/h+0.5)
 open(unit=2, file='puntos.dat', status='replace')
 write(2,*) v 
 call calculador(v,var,h)
 write(*,*) h
 deallocate(v)
 close(2)
 call system ("gnuplot -persist puntos.p")
 read(*,*) 

 CONTAINS

 FUNCTION vprima (v,var)
   integer var
   real :: v(var), vprima(var)
   vprima(1)= 1 !la derivada de x siempre es 1
   vprima(2)= -20*v(2)+ 7*(ee**(-0.5*v(1)))
  END FUNCTION vprima

 SUBROUTINE calculador (v,var,h)
  real:: v(var),h
  integer var

   do while (v(1)<=xf)
    h=ajustapaso(h, v)
    v= v+h*vprima(v,var)
    write(2,*) v
   end do 
  end subroutine calculador
  
FUNCTION ajustapaso(h,v) !aca ajusta el paso. Avanza 2 veces h/2 y 1 vez h, luego calcula la diferencia y compara con una tolerancia
  real:: h, tol, v(0:1), vec1 (0:1), vec2(0:1), ajustapaso
  logical ok 

  tol=0.005
  ok=.true.
  do while (ok)
    vec1= v+h*vprima(v,var)
    vec2= v+(h/2)*vprima(v,var)

  !print*,maxval(abs(vec2-vec1))
    if (maxval(abs(vec2-vec1))>=tol) then !aca compara con la tolerancia
      h=h/2.
      else
      ok=.false.
    end if
  end do
  ajustapaso=h
END FUNCTION ajustapaso


END PROGRAM 


                                                                       Muchas gracias.

PLANOS VARIOS

En la siguiente entrega les vengo a presentar una serie de planos hechos "a mano alzada" en fusion360. Son de mi autoria, libre distribucion y utilizacion. Todos los presentes son planos pensados para el taller, es decir sufrieron modificaciones en la ejecucion y planificacion de los mismos.

Estos "artefactos" ... muebles, son para practicar en la utilizacion de herramientas, maneje de metales varios, soldadura, acabados etc. 






Bueno en este caso en particular para la mesa, los tornillitos aclarados en los planos fueron reemplazados por uniones soldadas.  La mesa fue soldada con electrodo.





En este caso, fue agregada una planchuela en la base del mismo. El zapatero fue soldado integramente con mig.



Las ménsulas están en proceso. Sin embargo, debido a que no fui a comprar el material exacto que necesitaba para seguir el plano y agarre lo primero que encontré tirado en el taller... estoy haciéndolas un poco diferente. Agarre una tira de acero inoxidable, corte 2 tiras de 20 cm de largo, las pulí y le hice dos agujeros en las puntas. Después corte otras dos tiras de 25 cm de largo, las pulí y las soldé aproximadamente a 1 cm del agujero de las otras dos.. Todavía falta ponerle un redondo a 45 para mayor sostén. 

Les aviso para los que no sepan, manejar inoxidable es mucho mas difícil que hierro común, se calienta distinto. Les aviso porque me queme como un condenado. Entre que las piezas son chicas y con los guantes se hacen difíciles de manejar, dando puntadas te quemas todos los dedos jaja. Quedaron "Bien". En breve subiré como quedan finalmente.


Galpón, planos a mano alzada, sin calculo ni cimentación. Solo estructura metálica.


Continuación, se hizo en 3d y se modifico el reticulado interior.




Programas escritos en PASCAL

Les presento algunos programas que tengo guardado cuando aprendi a programar en PASCAL. Pascal suele ser un lenguaje de programacion que se utiliza a modo de aprendizaje. Los programas que siguen fueron escritos para la resolucion de enunciados de guias de ejercicios practicos. 

Programa numero 1. En este programa se puede visualizar claramente el uso de diferentes tipos de variables y la utilizacion de while , if sucesivos y case-of.

program banco;
var
saldoin,saldoF,montoD,montoR,saldointermedio:real;
operacion:char;
error:boolean;
begin
error:=false;
saldointermedio:=0;
writeln('Ingrese saldo Inicial');
Readln(saldoin);
saldoF:=Saldoin;
writeln('Ingrese D para deposito, R para retiro, F para finalizar');
readln(operacion);
while (operacion  <> 'f' ) do
begin
case operacion of
'd','D':
begin
writeln('Ingrese monto de deposito');
readln(montoD);
saldoIntermedio:=saldointermedio+montoD;
writeln('Indique siguiente operacion');
readln(operacion);
end;
'r','R':
begin
writeln('Ingrese monto a retirar');
readln(montoR);
saldointermedio:=saldointermedio-montoR;
if montoR>5000 then
writeln('Superaste el limite de extraccion');
operacion:='f';
error:=true;
if (saldointermedio+saldoin)<0 p="" then=""> begin
writeln('Saldo insuficiente');
operacion:='f';
error:=true;
end
else
begin
writeln('Indique siguiente operacion');
readln(operacion);
end;
end;
end;
end;
saldoF:=saldoin+saldointermedio;
if error then
writeln('Volver a iniciar el programa')
else
writeln('El monto total es: ',saldoF:6:2);
end.

-----------------------------------------------------------------------------------------------------------
Programa numero 2. En este programa se puede visualizar la utilizacion de vectores y matrices (array's). A su vez tambien se hace uso de las funciones (function) y subrutinas (procedure) propias de lenguajes de programacion mas avanzados.

program Ejercicio;
type
TV= array[1..100,1..6] of real;
Vec= array[1..100] of byte;
var
Ma:tv;
Result:Vec;
N,L:byte;
Prom:real;

procedure IngresoD(var Ma:tv; var N:byte);
var
i,j:byte;
begin
writeln('Ingrese Numero de ciudades');
readln(N);
for j:=1 to 6 do
begin
For i:=1 to N do
read(Ma[i,j]);
end;
end;

Function Promedio(Ma:tv; N,J:byte):byte;
var
i,Cont:byte;
calc,prom:real;
begin
calc:=0;
for i:=1 to N do
calc:=calc + Ma[i,j];
Prom:=(calc/N);
cont:=0;
for i:=1 to N do
if Prom > (Ma[i,j]) then
cont:=cont+1;
promedio:=cont;
end;

function Comparacion(Ma:tv; N:byte):byte;
var
Resta,Maximo:real;
NUMCIU,i:byte;
begin
maximo:=0;
for i:=1 to N do
begin
Resta:=Ma[i,1]-Ma[i,6];
if Maximo <= Resta then
begin
Maximo:=Resta;
NUMCIU:=i;
end;
end;
Comparacion:=NUMCIU;
end;

procedure PorEncima(Ma:tv;var Result:Vec; N:byte; Prom:real; var L:byte);
var
i:byte;
begin
L:=1;
for i:=1 to N do
If (Ma[i,6]-Prom)>20 then
begin
Result[L]:=i;
L:=L+1
end;
end;

Procedure LecturaM(Result:Vec; L:byte);
var
i:byte;
begin
for i:=1 to L do
write(Result[i]:10);
end;

begin
IngresoD(Ma,N);
writeln('Para el año 2000, estuvieron ',Promedio(Ma,N,1),' ciudad por debajo del promedio');
Writeln('El numero de ciudad que mas ha disminuido el porcentaje es: ',Comparacion(Ma,N));
Prom:=Promedio(Ma,N,6);
PorEncima(Ma,Result,N,Prom,L);
writeln('Las ciudades que estuvieron un 20% por encima del promedio fueron: ');
LecturaM(Result,L);
end.

---------------------------------------------------------------------------------------------------------
Ejercicio 3. En este ejercicio, a la vez que se usan de manera fluida los vectores tambien se puede apreciar el uso de la escritura por archivo. (Dificil de tratar en pascal, pero de gran utilidad para migrar hacia otros lenguajes mas avanzados).

program DonantesEjercicio;
type
TVDNI=array[1..100] of longint;
TVGS=array[1..100] of string;
TVSX=array[1..100] of char;
TVEd=array[1..100] of byte;
var
VDNI:TVDNI;
VGrupSang:TVGS;
VSexo:TVSX;
VEdad:TVEd;
N:byte;
Ganador:string;
Arch:text;

Procedure Inicializacion(var VDNI:TVDNI; var VGrupSang:TVGS; var VSexo:TVSX; var VEdad:TVEd ; var N:byte);
var
i:byte;
begin
writeln('Ingresar cantidad de donantes de sangre');
readln(N);
for i:=1 to N do
begin
writeln('Ingresar DNI');
readln(VDNI[i]);
writeln('Ingresar Grupo sanguineo');
readln(VGrupSang[i]);
writeln('Ingresar Sexo');
readln(VSexo[i]);
writeln('Ingresar edad');
readln(VEdad[i]);
end;
end;

function MenorGrup(VGrupSang:TVGS; N:byte):string;
var
i,O,A,AB,B,Lugar:byte;
x:string;
VecMin:TVEd;
Min:integer;
begin
O:=0;
A:=0;
AB:=0;
B:=0;
for i:=1 to N do 
begin
x:=VGrupSang[i];
case x of
'0','O','o': O:=O+1;
'A','a':A:=A+1;
'AB','ab':AB:=AB+1;
'B','b':B:=B+1;
end;
end;
VecMin[1]:=O;
VecMin[2]:=A;
VecMin[3]:=AB;
VecMin[4]:=B;
Min:=300;
for i:=1 to 4 do
if VecMin[i]
begin
Min:=VecMin[i];
Lugar:=i;
end;
case Lugar of 
1:MenorGrup:='O';
2:MenorGrup:='A';
3:MenorGrup:='AB';
4:MenorGrup:='B';
end;
end;

Procedure ArchivoP(N:byte; VGrupSang:TVGS; Ganador:string; VEdad:TVEd; VDNI:TVDNI);
var
i:byte;
begin
rewrite(Arch);
for i:=1 to N do
begin
if (VGrupSang[i]=Ganador) then
begin
if (VEdad[i]>=20) and (VEdad[i]<=25) then
Begin
Write(Arch, VDNI[i]:10,VEdad[i]);
writeln();
end;
end;
end;
close(Arch);
end;

begin
Inicializacion(VDNI,VGrupSang,VSexo,VEdad,N);
Ganador:=MenorGrup(VGrupSang,N);
Assign(Arch,'EJERCICIO.txt');
ArchivoP(N,VGrupSang,Ganador,VEdad,VDNI);
end.

----------------------------------------------------------------

Bueno espero que les haya servido de algo estos programas, si es que llegaron tan abajo jaja.
Es solo una parte de lo mucho que tuve que programar en este lenguaje, pero que no tiene importancia alguna puesto que es solo de aprendizaje.