Clase: Programación Modular en Fortran.
• Programación estructurada.
• Subrutinas y funciones.
• Programación modular.
• Unidades de programa. Módulos y programa principal
• Implementación en fortran. Makefile.
1
Programación modular.
Ejemplo: Declaración
Programa que lee un fichero con notas de alumnos y de variables
calcula la media y la desviación típica
Programación estructurada:
Paradigma de programación que establece que todo
programa (función computable) puede expresarse
mediante tres estructuras (secuencias de control)
básicas:
Lectura
• Secuenciación. de datos
• Selección. (Condicionales)
• Iteración. (bucles)
Ventajas: Cálculo de
• Programas son más sencillos de escribir y de depurar. la media
• Programas más fáciles de modificar/ampliar.
Cálculo de la
desviación típica
2
Programación modular.
Programación estructurada: Declaración
Paradigma de programación que establece que todo de variables
programa (función computable) …
Unidades de programa:
• Programa principal: program Lectura
• Subprogramas: de datos
• Subrutinas: subroutine
• Funciones: function
Cálculo de
la media
Programación modular:
Paradigma de programación que consiste en dividir un
programa en módulos o subprogramas con el fin de
hacerlo más legible y manejable. Cálculo de la
desviación típica
3
Programación modular.
Ejercicio:
Convertir el cálculo de la media y la Declaración
desviación típica en la llamada a dos de variables
funciones y/o dos subrutinas.
Lectura
de datos
call sub_media(nota, nalumnos, media)
Cálculo de O
la media media = f_media(nota, nalumnos)
Cálculo de la call sub_desv(...)
O
desviación típica desv = f_desv(...)
Programación modular.
Ejercicio:
Convertir el cálculo de la media y la Declaración
desviación típica en la llamada a dos de variables
funciones y/o dos subrutinas.
Lectura
de datos
call sub_media(nota, nalumnos, media)
Cálculo de O
la media media = f_media(nota, nalumnos)
Cálculo de la call sub_desv(...)
O
desviación típica desv = f_desv(...)
Programación modular.
Ejercicio:
Convertir el cálculo de la media y la Declaración
desviación típica en la llamada a dos de variables
funciones y/o dos subrutinas.
Lectura
de datos
call sub_media(nota, nalumnos, media)
Cálculo de O
la media media = f_media(nota, nalumnos)
Cálculo de la call sub_desv(...)
O
desviación típica desv = f_desv(...)
Programación modular.
Ejercicio:
Convertir el cálculo de la media y la Declaración
desviación típica en la llamada a dos de variables
funciones y/o dos subrutinas.
Lectura
de datos
call sub_media(nota, nalumnos, media)
Cálculo de O
la media media = f_media(nota, nalumnos)
Cálculo de la call sub_desv(...)
O
desviación típica desv = f_desv(...)
Si el argumento dummy es de tipo array no es necesario
(si recomendable) indicar su tamaño. Dimensión asumida.
Programación modular.
Ejercicio:
Implementación (¿Dónde ponemos las subrutinas?)
De momento (hasta que
veamos módulos) las
escribiremos a continuación
del programa principal.
Clase: Programación Modular en Fortran.
• Programación estructurada.
• Subrutinas y funciones.
• Programación modular.
• Unidades de programa. Módulos y programa principal
• Implementación en fortran. Makefile.
9
Programación modular.
¿Dónde implementamos las funciones y las subrutinas?
Módulo: Un módulo es una unidad (normalmente se almacena en un fichero diferente)
donde se encapsulan subprogramas.
module module_name
...
contains
subprogram name#1
...
end subprogram name#1
...
subprogram name#r
...
end subprogram name#r
end module module_name
10
Programación modular.
¿Dónde implementamos las funciones y las subrutinas?
Módulo: Un módulo es una unidad (normalmente se almacena en un fichero diferente)
donde se encapsulan subprogramas.
Para usar en el programa principal los
subprogramas contenidos en el módulo hay que
llamarlo antes de la declaración de las variables:
program main
use module_name
...
end program main
11
Programación modular.
¿Dónde implementamos las funciones y las subrutinas?
Módulo: Un módulo es una unidad (normalmente se almacena en un fichero diferente)
donde se encapsulan subprogramas.
Para usar en el programa principal los module subrutinas
subprogramas contenidos en el módulo hay que modulo.f95
llamarlo antes de la declaración de las variables: contains
subroutine ordenar(Vector, n)
program main integer,intent(in) :: n
integer,intent(inout) ::
use module_name Vector(n)
integer :: i, j, temp
...
do i = 1,n - 1
do j = i, n
end program main …
enddo
enddo
end subroutine ordenar
end module 12
Programación modular.
Módulo: Un módulo es una unidad (normalmente se almacena en un fichero diferente)
donde se encapsulan subprogramas.
program principal
principal.f95
use subrutinas
integer :: A(5,3) module subrutinas
integer :: i, j modulo.f95
contains
do i = 1,5
do j = 1,3 subroutine ordenar(Vector, n)
A(i,j) = i**2 +j
enddo integer,intent(in) :: n
enddo integer,intent(inout) ::
Vector(n)
! Ordenar las filas de la matriz
integer :: i, j, temp
do i = 1,5
call ordenar(A(i,:),3) do i = 1,n - 1
enddo do j = i, n
…
end program enddo
enddo
end subroutine ordenar
end module 13
Programación modular.
Módulo: Un módulo es una unidad (normalmente se almacena en un fichero diferente)
donde se encapsulan subprogramas.
program principal
principal.f95
use subrutinas
integer :: A(5,3) module subrutinas
integer :: i, j modulo.f95
contains
do i = 1,5
do j = 1,3 subroutine ordenar(Vector, n)
A(i,j) = i**2 +j
enddo integer,intent(in) :: n
enddo integer,intent(inout) ::
Vector(n)
! Ordenar las filas de la matriz
integer :: i, j, temp
do i = 1,5
call ordenar(A(i,:),3) do i = 1,n - 1
enddo do j = i, n
…
end program enddo
enddo
end subroutine ordenar
end module 14
Programación modular.
Módulo: Un módulo es una unidad (normalmente se almacena en un fichero diferente)
donde se encapsulan subprogramas.
• Los módulos sirven para agrupar unidades de programa por
funcionalidad.
• Dentro de un módulo también pueden definirse variables que
serán conocidas por todas las unidades de programa que
“usen” dicho módulo.
• Dentro de un mismo módulo todas las unidades de programa son
“visibles” y pueden llamarse entre sí.
• En el segundo semestre generaremos e iremos ampliando un
módulo algebra_lineal que contendrá todas las operaciones
matriciales que requiera el cálculo numérico.
• En cuanto a la programación colaborativa los módulos suponen un
paso más. Cada programador dentro de un grupo puede ser
responsable de un módulo (fichero).
• Un proyecto de software debe incluir información descriptiva sobre
módulos, funcionalidad, comunicaciones…
15
Clase: Programación Modular en Fortran.
• Programación estructurada.
• Subrutinas y funciones.
• Programación modular.
• Unidades de programa. Módulos y programa principal
• Implementación en fortran. Makefile.
16
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
Makefile: Fichero de texto con instrucciones para
compilar y “linkar” ficheros fuente (*.f90 o *.f95 )
y generar un programa ejecutable.
• Las instrucciones dependen del sistema
operativo de la máquina en que se ejecutan.
• El makefile determina qué ficheros compilar y
en qué orden. Si alguno se cambia solo se
vuelven a compilar los modificados.
• Para lanzarlo basta escribir make por línea de
comandos.
• El programa ejecutable recibe el nombre
asignado
17
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
# Compilador Fortran
Makefile: Fichero de texto con instrucciones para FC=gfortran
compilar y “linkar” ficheros fuente (*.f90 o *.f95 ) # LINKER
y generar un programa ejecutable. LD=gfortran
# Borrar archivos
• Las instrucciones dependen del sistema RM=del
operativo de la máquina en que se ejecutan.
# Opciones del Compilador
• El makefile determina qué ficheros compilar y FFLAGS= -O3 -fbounds-check
en qué orden. Si alguno se cambia solo se
vuelven a compilar los modificados. # Objetos
OBJS= modulo.o \
principal.o
• Para lanzarlo basta escribir make por línea de
comandos. # Ejecucion
programa : $(OBJS)
• El programa ejecutable recibe el nombre $(LD) -o $@ $(OBJS)
asignado %.o: %.f95
$(FC) -c $< $(FFLAGS) -o $@
# Limpieza
clean:
$(RM) $(OBJS) *.mod *.exe
18
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
# Compilador Fortran
Makefile: Fichero de texto con instrucciones para FC=gfortran
compilar y “linkar” ficheros fuente (*.f90 o *.f95 ) # LINKER
y generar un programa ejecutable. LD=gfortran
# Borrar archivos
• Las instrucciones dependen del sistema RM=del
operativo de la máquina en que se ejecutan. # En Linux/Mac
#RM = rm
• El makefile determina qué ficheros compilar y
en qué orden. Si alguno se cambia solo se # Opciones del Compilador
vuelven a compilar los modificados. FFLAGS= -O3 -fbounds-check
# Objetos
• Para lanzarlo basta escribir make por línea de OBJS= modulo.o \
comandos. principal.o
• El programa ejecutable recibe el nombre # Ejecucion
asignado programa : $(OBJS)
$(LD) -o $@ $(OBJS)
%.o: %.f95
$(FC) -c $< $(FFLAGS) -o $@
# Limpieza
clean:
19
$(RM) $(OBJS) *.mod *.exe
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
# Compilador Fortran
Makefile: Fichero de texto con instrucciones para FC=gfortran
compilar y “linkar” ficheros fuente (*.f90 o *.f95 ) # LINKER
y generar un programa ejecutable. LD=gfortran
# Borrar archivos
• Las instrucciones dependen del sistema RM=del
operativo de la máquina en que se ejecutan.
# Opciones del Compilador
• El makefile determina qué ficheros compilar y FFLAGS= -O3 -fbounds-check
en qué orden. Si alguno se cambia solo se
vuelven a compilar los modificados. # Objetos
OBJS= modulo.o \
principal.o
• Para lanzarlo basta escribir make por línea de
comandos. # Ejecucion
programa : $(OBJS)
• El programa ejecutable recibe el nombre $(LD) -o $@ $(OBJS)
asignado %.o: %.f95
$(FC) -c $< $(FFLAGS) -o $@
# Limpieza
clean:
$(RM) $(OBJS) *.mod *.exe
20
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
# Compilador Fortran
Makefile: Fichero de texto con instrucciones para FC=gfortran
compilar y “linkar” ficheros fuente (*.f90 o *.f95 ) # LINKER
y generar un programa ejecutable. LD=gfortran
# Borrar archivos
• Las instrucciones dependen del sistema RM=del
operativo de la máquina en que se ejecutan.
# Opciones del Compilador
• El makefile determina qué ficheros compilar y FFLAGS= -O3 -fbounds-check
en qué orden. Si alguno se cambia solo se
vuelven a compilar los modificados. # Objetos
OBJS= modulo.o \
principal.o
• Para lanzarlo basta escribir make por línea de
comandos. # Ejecucion
programa : $(OBJS)
• El programa ejecutable recibe el nombre $(LD) -o $@ $(OBJS)
asignado %.o: %.f95
$(FC) -c $< $(FFLAGS) -o $@
# Limpieza
clean:
$(RM) $(OBJS) *.mod *.exe
21
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
# Compilador Fortran
Makefile: Fichero de texto con instrucciones para FC=gfortran
compilar y “linkar” ficheros fuente (*.f90 o *.f95 ) # LINKER
y generar un programa ejecutable. LD=gfortran
# Borrar archivos
• Las instrucciones dependen del sistema RM=del
operativo de la máquina en que se ejecutan.
# Opciones del Compilador
• El makefile determina qué ficheros compilar y FFLAGS= -O3 -fbounds-check
en qué orden. Si alguno se cambia solo se
vuelven a compilar los modificados. # Objetos
OBJS= modulo.o \
principal.o
• Para lanzarlo basta escribir make por línea de
comandos. # Ejecucion
programa : $(OBJS)
• El programa ejecutable recibe el nombre $(LD) -o $@ $(OBJS)
asignado %.o: %.f95
$(FC) -c $< $(FFLAGS) -o $@
# Limpieza
clean:
$(RM) $(OBJS) *.mod *.exe
22
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
program valor # Compilador Fortran
principal.f95 FC=gfortran
use funciones
# LINKER
Orden: LD=gfortran
makefile
real :: a,b,c • 1º módulos según
dependencias.
a = -3.0 # Borrar archivos
• Último programa
b = valor_abs(a) principal RM=del
c = 1.7 # Opciones del Compilador
write(*,*) valor_abs(c) FFLAGS= -O3 -fbounds-check
modulo.f95
end program module funciones # Objetos
OBJS= modulo.o \
contains principal.o
function valor_abs(x)
# Ejecucion
real, intent(in) :: x
programa : $(OBJS)
real :: valor_abs
$(LD) -o $@ $(OBJS)
valor_abs = x %.o: %.f95
if (valor_abs < 0.0) then $(FC) -c $< $(FFLAGS) -o $@
valor_abs = -valor_abs
endif # Limpieza
clean:
end function valor_abs $(RM) $(OBJS) *.mod *.exe
end module
23
Programación modular.
¿Cómo generar un ejecutable a partir de varios ficheros fuente?
program valor # Compilador Fortran
FC=gfortran
use funciones
Nombre del módulo # LINKER
¡¡No del fichero!! LD=gfortran
makefile
real :: a,b,c
principal.f95 # Borrar archivos
a = -3.0
b = valor_abs(a) RM=del
c = 1.7 # Opciones del Compilador
write(*,*) valor_abs(c) FFLAGS= -O3 -fbounds-check
modulo.f95
end program module funciones # Objetos
OBJS= modulo.o \
contains principal.o
function valor_abs(x)
# Ejecucion
real, intent(in) :: x
programa : $(OBJS)
real :: valor_abs
$(LD) -o $@ $(OBJS)
valor_abs = x %.o: %.f95
if (valor_abs < 0.0) then $(FC) -c $< $(FFLAGS) -o $@
valor_abs = -valor_abs
endif # Limpieza
clean:
end function valor_abs $(RM) $(OBJS) *.mod *.exe
end module
24
Programación modular.
25
Programación modular.
26
Programación modular.
27
Programación modular.
28
Programación modular.
29
Programación modular.
30
Programación modular.
Compilación
ficheros
fuente
“Linkado” y
generación del
ejecutable 31
Programación modular.
32
Programación modular. Juego de la vida
El juego de la vida es el mejor ejemplo de un autómata celular,
diseñado por el matemático británico John Horton Conway en
1970.
El juego de la vida es en realidad un juego de cero jugadores,
lo que quiere decir que su evolución está determinada por el
estado inicial y no necesita ninguna entrada de datos
posterior. El "tablero de juego" es una malla formada por
cuadrados ("células") que se extiende en todas las direcciones.
Cada célula tiene 8 células vecinas, que son las que están
próximas a ella, incluso en las diagonales. Las células tienen
dos estados: están "vivas" o "muertas" (o "encendidas" y
"apagadas"). El estado de la malla evoluciona a lo largo de
unidades de tiempo discretas (se podría decir que por turnos).
El estado de todas las células se tiene en cuenta para calcular
el estado de las mismas al turno siguiente. Todas las células se
actualizan simultáneamente.
Las transiciones dependen del número de células vecinas vivas:
• Una célula muerta con exactamente 3 células vecinas vivas
"nace" (al turno siguiente estará viva).
• Una célula viva con 2 ó 3 células vecinas vivas sigue viva,
en otro caso muere o permanece muerta (por "soledad" o
"superpoblación").
33
Programación modular. program juego_vida
use modulo_vida
Juego de la vida
implicit none
character, allocatable :: Tablero(:,:)
integer :: num, niter, iter, num_cambios
real :: prob
! Tamaño del tablero
num = 10
allocate(Tablero(1:num,1:num))
! Iteraciones maximas
niter = 100
! Probabilidad de vida en casillas iniciales
prob = 0.3
!*** COMIENZO DEL JUEGO ************************
! Creamos tablero inicial
call system('cls')
call crear_tablero(Tablero,num,prob)
call mostrar_tablero(Tablero,num)
call espera(2.0)
!*** ITERACION TEMPORAL ************************
num_cambios = 0
do iter = 1, niter
call system('cls')
write(*,'(A7,i3)') 'Iter # ',iter
call siguiente_tablero(Tablero,num,num_cambios)
write(*,'(A10,i3)') 'Cambios = ', num_cambios
call mostrar_tablero(Tablero,num)
call espera(1.0)
if (num_cambios == 0) exit
enddo
end program juego_vida 34
