Introduccion a

Fortran 90

Generalidades

Variables en
Fortran 90

Expresiones

Arrays
Introduccion a Fortran 90
Bloques de
control

Programacion
estructurada

Modules

Instrucciones de
entrada/salida
18 de febrero de 2008
 Esquema que seguiremos

Introduccion a
Fortran 90

1 Generalidades
Generalidades

Variables en
Fortran 90 2 Variables en Fortran 90
Expresiones

Arrays 3 Expresiones
Bloques de
control

Programacion
4 Arrays
estructurada

Modules 5 Bloques de control

Instrucciones de
entrada/salida
6 Programacion estructurada

7 Modules

8 Instrucciones de entrada/salida
 Tipos de programas en Fortran

Introduccion a
Fortran 90 Programa fuente (nombre.f90): Es el programa que editamos y
que contiene las instrucciones del lenguaje Fortran. Para su
Generalidades
edicion, utilizaremos cualquier editor de texto (edit, emacs, vi,
Variables en
Fortran 90 pico,...).
Expresiones

Arrays
COMPILACION
Bloques de
control

Programacion Programa objeto (nombre.o): El programa fuente se hace

estructurada

Modules
comprensible al ordenador.
Instrucciones de
entrada/salida LINKADO

Programa ejecutable (nombre.out).

 Ordenes de compilacion y linkado

Introduccion a
Fortran 90
Compilacion:

> gfortran -c dicotomia.f90 ! se crea dicotomia.o

Generalidades

Variables en Pueden compilarse al mismo tiempo varios programas fuente:

Fortran 90

Expresiones > gfortran -c dicotomia.f90 auxiliar.f90

Arrays ! se crean dicotomia.o y auxiliar.o
Bloques de
control
Linkado:
Programacion
estructurada > gfortran -o dicotomia.out dicotomia.o
Modules
Se puede crear un unico ejecutable con varios programas objeto:
Instrucciones de
entrada/salida
> gfortran -o dicotomia.out dicotomia.o auxiliar.o
Todo junto (no recomendado):

> gfortran -o dicotomia.out dicotomia.f90

> gfortran -o dicotomia.out dicotomia.f90 auxiliar.f90
Ejecucion:

> ./dicotomia.out
 Empezando...

Introduccion a
Fortran 90 No hay distincion entre mayusculas y minusculas.
Los nombres de programas y variables deben tener un maximo
Generalidades
de 32 caracteres. El primer caracter tiene que ser una letra y los
Variables en
Fortran 90 siguientes pueden ser numeros, letras o subrayado.
Expresiones Comentarios: Se ponen despues del signo !.
Arrays La longitud maxima de lnea es de 132 caracteres.
Bloques de
control
Para indicar que una instruccion continua en la lnea siguiente se
Programacion pone & al final de la lnea:
estructurada
print*, &
Modules

Instrucciones de
Esto es una prueba
entrada/salida Ademas, la lnea siguiente tiene que empezar por & si
queremos continuar textos entrecomillados:
print*, &
Esta linea es muy larga &
& y por eso la dividimos
Se pueden poner varias instrucciones en la misma lnea si las
separamos por ;
A=0 ; B=0
 Variables en Fortran 90

Introduccion a
Fortran 90
Hay cinco tipos basicos de variables:
Generalidades
Enteras.
Variables en
Fortran 90 Reales.
Expresiones
Complejas.
Arrays

Bloques de Logicas.
control
Caracter.
Programacion
estructurada

Modules

Instrucciones de
entrada/salida
De forma implcita, Fortran guarda los nombres de variables que
empiecen por {i, j, k, l, m, n} para variables enteras y el resto para
variables reales de precision simple.

Es recomendable empezar un programa anulando este criterio

predefinido con la instruccion IMPLICIT NONE. As tenemos que
declarar todas las variables que utilicemos y evitaremos muchos
errores.
 Variables enteras

Introduccion a
Fortran 90
Almacenamos en ellas numeros enteros: ...,-3,-2,-1,0,1,2,3,...
Generalidades
> integer :: i, j1, j2 !Declara i,j1,j2 como variables enteras
Variables en
Fortran 90

Expresiones Dentro de las variables enteras se distinguen distintos tipos

Arrays dependiendo de la cantidad de memoria que se use para
Bloques de
control
almacenarlas. Estos tipos pueden depender de la maquina en que
Programacion estemos trabajando. En general:
estructurada
integer (kind=1) :: i ! Numeros enteros entre -127 y 127
Modules

Instrucciones de integer (kind=2) :: j ! Numeros enteros entre -32767 y 32767

entrada/salida
integer (kind=4) :: k ! Numeros enteros entre -2147483647 y
2147483647

En nuestro sistema, el tipo por defecto para variables enteras es

kind=4. De todas formas, conviene ponerlo explcitamente.
 Variables reales

Introduccion a
Fortran 90
Almacenamos en ellas numeros reales.
Generalidades

Variables en
Fortran 90 Al igual que para las variables enteras, hay distintos tipos de variables
Expresiones reales que dependen de la maquina utilizada. Habitualmente son:
Arrays
real (kind=4) :: x1 ! 7 cifras significativas (precision simple ).
Bloques de
control
real (kind=8) :: x2 ! 14 cifras significativas (precision doble).
Programacion
estructurada real (kind=16) :: x3 ! 28 cifras significativas (prec. cuadruple).
Modules

Instrucciones de
entrada/salida
Atencion!! El tipo real por defecto es kind=4. Nosotros usaremos,
salvo que se diga lo contrario, kind=8.
 Sobre las constantes reales

Introduccion a
Fortran 90

Generalidades

Variables en
Fortran 90

Expresiones real (kind=8) :: x1

Arrays x1=0.3
Bloques de print*, x1 !En pantalla: 0.300000011920929
control

Programacion
estructurada

Modules real (kind=8) :: x1

Instrucciones de
entrada/salida
x1=0.3 8
print*, x1 !En pantalla: 0.300000000000000
 Variables complejas

Introduccion a
Fortran 90
Los numeros complejos se almacenan como pares de numeros reales.
Generalidades Los tipos son los mismos que para las variables reales:
Variables en
Fortran 90 > complex (kind=4) :: c1
Expresiones

Arrays
> complex (kind=8) :: c2
Bloques de
control
> c1=(1. 4 , 2.05 4) ; c2=(0.1 8,0)
Programacion
estructurada

Modules

Instrucciones de
entrada/salida
 Variables logicas

Introduccion a
Fortran 90
Admiten dos valores posibles : .FALSE. y .TRUE.
Generalidades
> logical :: log1, log2
Variables en
Fortran 90 > log1= .true.
Expresiones > log2= .false.
Arrays

Bloques de
control

Programacion
estructurada

Modules

Instrucciones de
entrada/salida
 Variables caracter

Introduccion a
Fortran 90
Nos permiten guardar cadenas alfanumericas. Debemos especificar el
numero maximo de caracteres.
Generalidades

Variables en
Fortran 90 > character (len=10) :: fichero
Expresiones > fichero= datos
Arrays

Bloques de
control

Programacion
estructurada

Modules

Instrucciones de
entrada/salida
 Parameter

Introduccion a
Fortran 90
Sirve para almacenar un valor constante en una variable de forma que
no cambie a lo largo de todo el programa:
Generalidades

Variables en
Fortran 90 > integer, parameter :: dim=100
Expresiones

Arrays
> real, parameter :: pi simple=3.14159265
Bloques de
control
> real(kind=8), parameter :: pi= 3.14159265358979
Programacion
estructurada

Modules

Instrucciones de
entrada/salida
 Expresiones

Introduccion a
Fortran 90
Expresiones aritmeticas:
operandos aritmeticos
Generalidades

Variables en
operadores (ordenados por prioridad):
Fortran 90 **
Expresiones
*, /
Arrays
+, -
Bloques de
control El orden de prioridad puede alterarse usando parentesis.
Programacion resultado: sera del tipo del operando mas potente
estructurada

Modules
(por ej., real(kind=8)*entero(kind=4) real(kind=8))
Instrucciones de
entrada/salida
Expresiones relacionales:
operandos logicos o aritmeticos
operadores:
> o .GT. ; >= o .GE.
< o .LT. ; <= o .LE.
== o .EQ. ; /= o .NE.
resultado: .TRUE. o .FALSE.
 Expresiones

Introduccion a
Fortran 90
Expresiones logicas:
operandos: expresiones relacionales
Generalidades

Variables en
operadores: .NOT. , .AND. , .OR.
Fortran 90
resultado: .TRUE. o .FALSE.
Expresiones

Arrays Ejemplo:
Bloques de
control
> if ( (i<10).AND.(i/=5) ) . . .
Programacion
estructurada

Modules
Expresiones de caracteres:
Instrucciones de
entrada/salida operandos: cadenas de caracteres
operador: concatenacion (//)
resultado: otra cadena de caracteres

Ejemplo:
> ch1=fich
> ch2=out
> ch3=char1//char2 ! ch3=fich out
 Expresiones

Introduccion a
Fortran 90

Orden de prioridad:
Generalidades 1 aritmeticas
Variables en
Fortran 90
2 concatenacion
Expresiones 3 relacionales
Arrays
4 logicas
Bloques de
control

Programacion
estructurada

Modules

Instrucciones de
entrada/salida
 Arrays

Introduccion a
Fortran 90
Los arrays son variables dimensionadas.
Identifican un conjunto de posiciones de memoria, todas ellas de un
Generalidades
mismo tipo (real, entero, etc.).
Variables en
Fortran 90

Expresiones

Arrays
La forma de definirlas es:
Bloques de
control real, dimension(3) :: a ! tres variables reales: a(1), a(2) y a(3)
Programacion
estructurada
real (kind=8), dimension(0:2) :: b ! b(0), b(1) y b(2)
Modules

Instrucciones de
entrada/salida real, dimension(3,0:2) :: c ! c(1,0), c(2,0),c(3,0),c(1,1), ...

integer (kind=4), dimension(-1:2,2) :: d ! d(-1,1), d(0,1),...

 Asignacion de valores en un array

Introduccion a
Fortran 90 Asignacion directa de un vector:

Generalidades
real (kind=8), dimension(0:3) :: a
Variables en
a=(/1.0 8, 2.1 8, 3.9 8, 4.24 8/)
Fortran 90
Asignacion mediante un bucle implcito:
Expresiones

Arrays integer, dimension(5) :: i1,i2,i3

Bloques de i1=0
control i2(1:4)=1; i2(5)=0
Programacion
estructurada
i3(1:5)=(/(2.0*j, j=1,5)/)
Modules

Instrucciones de
Para la definicion de una matriz hay dos opciones:
entrada/salida
integer, dimension(3,2) :: i

(1) i(1,:)= (/1,2/) ; i(2,:)=(/3,4/) ; i(3,:)=(/5,6/)

(2) i=reshape( (/1,3,5,2,4,6/), shape=(/3,2/)).

Nota: El comando reshape suele llevar a errores.

 Operaciones con arrays

Introduccion a
Fortran 90 Se puede operar de manera directa:

Generalidades integer, dimension(3) :: a, b, c, d

Variables en real (kind=8), dimension(20) :: x1, x2, x3
Fortran 90
a=(/1, 2, 3/) ; b=(/4, -5, 6/)
Expresiones

Arrays
c=a+b !c = (/5, 3, 9/)
Bloques de
d=a*b !d = (/4, 10, 18/)
control ..
Programacion .
estructurada
x1=x1/3.1 8 + x2*dsqrt(x3)
Modules

Instrucciones de
entrada/salida Otra posibilidad (no recomendada) es operar elemento a
elemento en un bucle.
 Funciones predefinidas con arrays

Introduccion a
Fortran 90 where: Efectua cierta instruccion en las posiciones del array
que verifican una condicion:
Generalidades
where (a /= 0) b=b/a
Variables en
Fortran 90 where (a == 0) b=1/epsilon(b)
Expresiones
count ( (expresion logica) [,dim]): Numero de elementos
Arrays
que verifican la expresion logica. Si dim=1, da el resultado
Bloques de
control por columnas; si dim=2, por filas.
Programacion
estructurada
count (a == 0) count (mask=(a == 0))
Modules maxval(array [,dim] [,mask]): Calcula el valor maximo.
Instrucciones de
entrada/salida
maxval(a, mask=(a < 0)) ; maxval(b)
minval(array [,dim] [,mask]): Calcula el valor mnimo.
maxloc(array [,mask]): Localizacion del mayor elemento.
En este caso la posicion que resulta es absoluta.
minloc(array [,mask]): Localizacion del menor elemento.
 Funciones predefinidas con arrays

Introduccion a
Fortran 90
program max val
implicit none
Generalidades
integer, dimension(3,3) :: M
Variables en
Fortran 90 M(1,:)=(/1,2,6/) ; M(2,:)=(/4,11,3/) ; M(3,:)=(/7,8,9/)
Expresiones print*,maxval(M,dim=1) ! Imprime: 7,11,9
Arrays
print*,maxval(M,dim=2) ! Imprime: 6,11,9
Bloques de
control print*,maxval(M,dim=1,mask=(M<5)) ! Imprime: 4,2,3
Programacion end program max val
estructurada

Modules

Instrucciones de
entrada/salida
 Funciones predefinidas con arrays

Introduccion a
Fortran 90 product(array [,dim] [,mask]): Producto de los elementos
del array.
Generalidades

Variables en
sum(array [,dim] [,mask]): Suma de los elementos del array.
Fortran 90
dot product(vec 1, vec 2): Producto escalar.
Expresiones

Arrays matmul(matriz a, matriz b): Multiplicacion matricial.

Bloques de
control
transpose(matriz): Matriz transpuesta.
Programacion
estructurada
El producto escalar permite simplificar muchos sumatorios:
Modules
xsum=0.0 8
Instrucciones de
entrada/salida do i=1,n
xsum=dot product(a(1:n),b(1:n))
xsum=xsum+a(i)*b(i)
end do
Norma eucldea de un vector:
norm=sum(vec*vec) norm=dot product(vec,vec)
norm=dsqrt(norm)
 Dimensionamiento dinamico

Introduccion a
Fortran 90
Fortran 90 permite reservar memoria en tiempo de ejecucion. Para
ello tenemos las instrucciones allocate y derivadas.
Generalidades

Variables en real, dimension(:), allocatable :: a,b

Fortran 90
read*, n
Expresiones allocate(a(n)) ; allocate(b(0:n))
Arrays [. . .]
Bloques de
control
deallocate(a) ; deallocate(b)
Programacion Para comprobar si hubo algun problema en la reserva o liberacion de
estructurada

Modules
memoria, se usa el comando stat. El resultado es 0 si no hay
Instrucciones de
problemas.
entrada/salida
[. . .]
allocate (a(n), stat=testeo)
if (testeo /= 0) stop
Para comprobar si una variable allocatable tiene reservada memoria
se usa la instruccion allocated:
if (allocated(a)) deallocate(a)
if (.not. allocated(a)) allocate(a(n))
 Bloque de control if

Introduccion a
Fortran 90
Estructura tipo:
Generalidades
[nombre:] if (expresion logica) then
Variables en
Fortran 90 ..
Expresiones
.
Arrays
else if (expresion logica) then [nombre]
Bloques de
..
control .
Programacion else [nombre]
estructurada
..
Modules .
Instrucciones de
entrada/salida
end if [nombre]

Otra opcion, en ocasiones mas comoda, es:

if (expresion logica) {una sola orden (sin then)}

 Ejemplo de uso de if

Introduccion a
Fortran 90
program aprobar CN
implicit none
Generalidades
real(kind=8) :: nota teor, nota prac
Variables en
Fortran 90

Expresiones
print*,Nota de teoria?
Arrays
read*, nota teor
Bloques de
print*,Nota de practicas?
control
read*, nota prac
Programacion
estructurada if ((nota teor>=4.5 8).and.(nota prac>=0.5 8)) then
Modules print*,ENHORABUENA! Has aprobado &
Instrucciones de & las dos partes de la asignatura
entrada/salida
else if ((nota teor+nota prac==5.0 8).and.(nota prac>=0.5 8)) &
then
print*,Por los pelos... pero pasas
else
print*,Nos vemos en septiembre
end if
end program aprobar CN
 Bloque de control case

Introduccion a
Fortran 90
Ejecuta un bloque de sentencias u otro segun el valor que pueda
tomar una expresion o variable.
Generalidades

Variables en
Fortran 90
[nombre:] select case (expresion o variable)
Expresiones

Arrays
case (...) [nombre]
..
Bloques de
control
.
Programacion case (...) [nombre]
estructurada
..
Modules .
Instrucciones de case default [nombre]
entrada/salida
..
.
end select [nombre]

Nota: La opcion case default no tiene que ir necesariamente en

ultimo lugar.
 Ejemplo de uso de case

Introduccion a
Fortran 90
program que hacemos hoy
implicit none
Generalidades
integer(kind=4) :: dia
Variables en
Fortran 90 do
Expresiones print*,Introduzca el dia de la semana (lunes=1, etc.)
Arrays
read*, dia
Bloques de
control if ((dia>=1).and.(dia<=7)) exit
Programacion end do
estructurada
print*,Hoy toca...
Modules

Instrucciones de
select case (dia)
entrada/salida case (1,2,3,4)
print*,chapar
case (5)
print*,chapar
case default
print*,chapar en casa
end select
end program que hacemos hoy
 Bucles: do

Introduccion a Estructura tipo:

Fortran 90

Generalidades
[nombre:] do (variable de control = vinicial,vfinal,incremento)
Variables en
..
Fortran 90 .
Expresiones end do [nombre]
Arrays

Bloques de Un ejemplo:
control

Programacion
estructurada integer (kind=4):: it
Modules do it = 0, 10, 2
Instrucciones de ..
entrada/salida .
end do

En este caso el bucle va de 0 a 10 incrementando en 2 la variable de

control cada vez que llega al end do.
Si el incremento es 1 se puede omitir.
La variable de control no puede modificarse dentro del bucle.
 Bucles: do

Introduccion a
Fortran 90
Hay dos comandos importantes que pueden emplearse en la
estructura DO:
Generalidades

Variables en
Fortran 90 EXIT: abandona el bucle (pasa a la primera lnea despues
Expresiones
de END DO).
Arrays

Bloques de
CYCLE: aumenta el contador (pasa a la lnea END DO).
control

Programacion
estructurada

Modules
Una posibilidad interesante es prescindir del bloque de control y
Instrucciones de
poner un exit combinado con un if:
entrada/salida

do
..
.
if (...) exit
end do
 Bucles: do

Introduccion a
Fortran 90
program acertar numero entero
implicit none
Generalidades
integer (kind=4) :: i,num,pru
Variables en
Fortran 90

Expresiones
num=68
Arrays do i=1,10
Bloques de
control
print*,Intento ,i
Programacion print*,Teclea un numero del 1 al 100
estructurada
read*,pru
Modules
if (pru==num) then
Instrucciones de
entrada/salida print*,Acertaste!
exit
end if
end do
if (i==11) print*,No ha habido suerte
end program acertar numero entero
 Bucles: do

Introduccion a
Fortran 90
program acertar numero entero
implicit none
Generalidades
integer (kind=4) :: i,num,pru
Variables en
Fortran 90

Expresiones
num=68
Arrays do i=10,1,-1
Bloques de
control
print*,Te quedan ,i, intentos
Programacion print*,Teclea un numero del 1 al 100
estructurada
read*,pru
Modules
if (pru==num) then
Instrucciones de
entrada/salida print*,Acertaste!
exit
end if
end do
end program acertar numero entero
 Bucles: do

Introduccion a
Fortran 90
program acertar numero entero
implicit none
Generalidades
integer (kind=4) :: i,num,pru
Variables en
Fortran 90

Expresiones
num=68
Arrays i=0 ; print*,De esta cae...
Bloques de
control
do
Programacion print*,Llevas ,i, intentos
estructurada
print*,Teclea un numero del 1 al 100
Modules
read*,pru
Instrucciones de
entrada/salida if (pru==num) then
print*,Acertaste!
exit
end if
i=i+1
end do
end program acertar numero entero
 Procedimientos

Introduccion a
Fortran 90
En Fortran 90 hay dos tipos de procedimientos:
Generalidades Funciones.
Variables en
Fortran 90
Subrutinas.
Expresiones

Arrays

Bloques de Los procedimientos pueden ser internos o externos:

control

Programacion
Internos:
estructurada
Antes de la lnea de end program, se escribe contains y se
Modules
anaden los procedimientos.
Instrucciones de
entrada/salida
Externos:
El procedimiento se situa fuera del cuerpo del programa
principal, ya sea en el mismo fichero o en otro distinto.
 Funciones
Las funciones permiten calcular un valor a partir de otros dados.
Introduccion a
Fortran 90 Es la traduccion informatica de la idea de funcion matematica.
program posit negat
Generalidades
implicit none
Variables en
Fortran 90 real(kind=8) :: x,y,z
Expresiones print*,Introduce la abscisa ; read*,x
Arrays
print*,Introduce la ordenada ; read*,y
Bloques de
control z=f(x,y)
Programacion if (z>= 0) then
estructurada
print*,Resultado positivo
Modules

Instrucciones de
else
entrada/salida print*,Resultado negativo
end if
contains
function f(x,y)
real(kind=8) :: f,x,y
f=dsin(x*y)*dcos(x*y)
end function f
end program posit negat
 Funciones
Ejemplo de funcion usando result (recomendado):
Introduccion a
Fortran 90
program posit negat
Generalidades implicit none
Variables en real(kind=8) :: x,y,z
Fortran 90

Expresiones
print*,Introduce la abscisa; read*,x
Arrays
print*,Introduce la ordenada; read*,y
Bloques de z=f(x,y)
control
if (z>= 0) then
Programacion
estructurada print*,Resultado positivo
Modules else
Instrucciones de
entrada/salida
print*,Resultado negativo
end if
contains
function f(x,y) result (res)
real(kind=8) :: x,y,res
res = dsin(x*y)*dcos(x*y)
end function f
end program posit negat
 Subrutinas
Permiten aislar una parte del programa, facilitando la programacion
Introduccion a
Fortran 90 estructurada.

Generalidades

Variables en
Fortran 90 program suma
Expresiones
implicit none
Arrays
real (kind=8):: a , b , res
Bloques de
call lee datos
control call calculos(a,b,res)
Programacion print*,res: ,res
estructurada
contains
Modules subroutine lee datos
Instrucciones de
entrada/salida
read*,a
read*,b
end subroutine lee datos
subroutine calculos(x1,x2,x3)
real(kind=8) :: x1,x2,x3
x3=x1+x2
end subroutine calculos
end program suma
 Recursividad

Introduccion a
Fortran 90
Tanto las funciones como las subrutinas pueden llamarse a s mismas:
Generalidades

Variables en recursive function factorial(n) result(res)

Fortran 90 integer (kind=4):: n
Expresiones real(kind=8) :: res
Arrays if (n==1) then
Bloques de res=1.0 8
control
else
Programacion
estructurada
res=n*factorial(n-1)
Modules
end if
Instrucciones de
end function factorial
entrada/salida
 Procedimientos internos

Introduccion a
Fortran 90
Los procedimientos internos heredan las variables del programa
principal, lo que puede dar lugar a errores. Las variables que sean
Generalidades
locales a un procedimiento deben definirse en este.
Variables en
Fortran 90

Expresiones
MAL! BIEN
Arrays
program prueba
Bloques de
control
program prueba implicit none
Programacion
implicit none integer (kind=4) :: i
estructurada integer (kind=4) :: i do i=1,10
Modules do i=1,10 print*,i: ,i
Instrucciones de print*,i: ,i call sub int
entrada/salida call sub int end do
end do contains
contains subroutine sub int
subroutine sub int integer (kind=4) :: i
do i=1,5 do i=1,5
print*,i en sub: ,i print*,i en sub: ,i
end do end do
end subroutine sub int end subroutine sub int
end program prueba end program prueba
 Procedimientos externos

Introduccion a
Fortran 90
En este caso, no hay transferencia implcita de variables. Se debe
incluir en el programa que realiza la llamada un bloque interface,
Generalidades
para detectar incompatibilidades de tipos.
Variables en
Fortran 90

Expresiones program suma

Arrays
implicit none
Bloques de
real (kind=8):: a, b, res
control interface
Programacion subroutine calculos (x1,x2,x3)
estructurada
real (kind=8) :: x1,x2,x3
Modules
end subroutine calculos subroutine calculos(x1,x2,x3)
Instrucciones de
end interface implicit none
entrada/salida
call int datos real(kind=8) :: x1,x2,x3
call calculos(a,b,res) x3=x1+x2
end subroutine calculos
print*,res: ,res
contains
subroutine int datos
read*,a ; read*,b
end subroutine int datos
end program suma
 Apuntes importantes

Introduccion a
Fortran 90
1 En cualquier momento en un procedimiento (interno o externo)
se puede utilizar el comando return para devolver el control al
Generalidades
programa principal.
Variables en
Fortran 90
2 Las variables que se pasan como argumentos se pueden (y se
Expresiones
deben) clasificar en funcion de si son de entrada (in, no se
Arrays
pueden modificar), de salida (out) o de entrada/salida
Bloques de
control (inout). Hacerlo as facilita la comprension de los codigos.
Programacion
estructurada
Para ello, se usa el comando intent:
Modules

Instrucciones de
subroutine calculos(x1,x2,x3)
entrada/salida implicit none
real(kind=8), intent(in) :: x1
real(kind=8), intent(inout) :: x2
real(kind=8), intent(out) :: x3
x3=x1+x2
x2=x1*x2
end subroutine calculos
 Argumentos desordenados

Introduccion a
Fortran 90
Al llamar a un procedimiento, los argumentos se pueden colocar en
cualquier orden si se indica en la llamada el nombre de los argumentos
Generalidades
virtuales. En este caso es obligatorio el uso del bloque interface.
Variables en
Fortran 90 program desordena
Expresiones implicit none; real(kind=8) :: x1,x2,dif,x
Arrays
interface
Bloques de
control subroutine escritura resultados(resultado,error)
Programacion real(kind=8), intent(in) :: resultado, error
estructurada
end subroutine escritura resultados
Modules

Instrucciones de
end interface
entrada/salida [. . .]
call escritura resultados(error=dif,resultado=x)
end program desordena
subroutine escritura resultados(resultado,error)
implicit none
real(kind=8), intent(in) :: resultado, error
print*,error ,error ; print*,resultado ,resultado
end subroutine escritura resultados
 Dimensiones asumidas

Introduccion a
Fortran 90
Al pasar un array a un procedimiento se pueden asumir las
dimensiones superiores (por defecto, la inferior es 1).
Generalidades

Variables en
Fortran 90 real(kind=8), dimension(10) :: a,b
Expresiones real(kind=8), dimension(0:10,-1:2) :: c
Arrays call opera(a,b,c)
Bloques de
control
...
Programacion contains
estructurada
subroutine opera(a,b,c)
Modules
real(kind=8), dimension(:) :: a,b
Instrucciones de
entrada/salida real(kind=8), dimension(0:,-1:) :: c
..
.

Si el procedimiento es externo y queremos asumir dimensiones, es

obligatorio usar un bloque interface en el programa que llama a
la subrutina donde se asumen dimensiones, excepto si usamos un
modulo, como veremos mas adelante.
 Transferencia de variables allocatables

Introduccion a Cuando a un procedimiento se le pasa como argumento un array

Fortran 90
allocatable, debe recibirse como un array de dimension asumida y es
Generalidades
obligatorio el uso de un bloque interface. En este caso, hay que
Variables en alocatar el array en el programa principal.
Fortran 90

Expresiones
real(kind=8), dimension(:), allocatable :: a
Arrays
integer(kind=4) :: n
Bloques de
interface
control subroutine asignar(v,n)
Programacion real(kind=8), dimension(:) :: v
estructurada
integer(kind=4) :: n
Modules
end subroutine
Instrucciones de
entrada/salida
end interface
read*, n
allocate(a(n))
call asignar (a,n)
..
.
subroutine asignar(v,n)
real(kind=8), dimension(:) :: v
integer(kind=4) :: i,n
v=(/ (i*2.0 8, i=1,n) /)
 Arrays automaticos

Introduccion a
Fortran 90
Si en una subrutina necesitamos un array auxiliar, podemos definirlo
en la misma subrutina con argumentos conocidos en tiempo de
Generalidades
ejecucion (por ejemplo, relativos al tamano de otro array):
Variables en
Fortran 90

Expresiones

Arrays
subroutine calculos (x,y)
Bloques de
implicit none
control
real(kind=8), dimension(:), intent(in) :: x,y
Programacion
estructurada real(kind=8), dimension(size(x)) :: aux
Modules [...]
Instrucciones de end subroutine calculos
entrada/salida
 Arrays como resultado de funciones

Introduccion a
Fortran 90
El resultado de una funcion puede ser un array (allocatable o no). En
este caso no es posible recibirlo como de dimension asumida; s es
Generalidades
posible dimensionarlo en funcion de una variable.
Variables en
Fortran 90

Expresiones

Arrays
function potencia(a,b) result(c)
Bloques de
implicit none
control
integer, dimension(:), intent(in) :: a,b
Programacion
estructurada integer, dimension(size(a)) :: c
Modules c = a**b
Instrucciones de end function potencia
entrada/salida
 Modulos

Introduccion a
Fortran 90

Los modulos son una estructura muy importante en Fortran 90

Generalidades
porque permite compartir variables y procedimientos, facilitando
Variables en
Fortran 90 tanto una transferencia sencilla de variables como la creacion de
Expresiones libreras propias.
Arrays

Bloques de
control module nombre
Programacion ..
estructurada .
Modules contains
Instrucciones de ..
entrada/salida .
end module nombre
 Modulos para compartir variables

Introduccion a
Fortran 90
La estructura module permite pasar variables comunes a distintos
procedimientos de una forma sencilla. Se facilita as la transferencia
Generalidades
de parametros y de variables dimensionadas.
Variables en
Fortran 90

Expresiones
module variables
Arrays
implicit none
Bloques de
control real(kind=8), dimension(:), allocatable :: a
Programacion end module variables
estructurada

Modules
program alocatar
Instrucciones de
entrada/salida use variables subroutine asignar(n)
implicit none use variables
integer(kind=4) :: n implicit none
read*, n integer(kind=4) :: n
allocate (a(n)) a=(/ (i*2.0 8, i=1,n) /)
call asignar(n) end subroutine asignar
end program alocatar
 Modulos para compartir variables

Introduccion a
Fortran 90
Podemos restringir el acceso a las variables de un modulo con el
comando only:
Generalidades

Variables en
Fortran 90
module variables
Expresiones implicit none
Arrays real(kind=8), dimension(:), allocatable :: a,b
Bloques de end module variables
control

Programacion
estructurada subroutine asignar(n)
Modules
use variables, only : a
Instrucciones de
entrada/salida implicit none
integer(kind=4) :: n
a=(/ (i*2.0 8, i=1,n) /)
end subroutine asignar
 Modulos para compartir variables

Introduccion a
Fortran 90
Y tambien con only podemos cambiarles localmente el nombre:
Generalidades
module variables
Variables en
Fortran 90 implicit none
Expresiones real(kind=8), dimension(:), allocatable :: a,b
Arrays end module variables
Bloques de
control

Programacion subroutine asignar(n)

estructurada
use variables, only : vector => a
Modules
implicit none
Instrucciones de
entrada/salida integer(kind=4) :: n
vector=(/ (i*2.0 8, i=1,n) /)
end subroutine asignar
 Modulos para compartir procedimientos

Introduccion a
Fortran 90
Ademas, en un modulo se pueden incluir procedimientos que luego se
compartiran de forma sencilla con otras partes del programa.
Generalidades
Podemos evitar as el uso de muchos bloques interface.
Variables en
Fortran 90

Expresiones module asignacion

Arrays contains
Bloques de
subroutine asignar(v,n)
control implicit none
Programacion integer::i,n
estructurada
real(kind=8), dimension(:) :: v
Modules
vector=(/ (i*2.0 8, i=1,n) /)
Instrucciones de
entrada/salida
end subroutine asignar
end module asignacion
program probamos
use asignacion
implicit none;
real(kind=8), dimension(:), allocatable :: a
read*, n; allocate(a(n))
call asignar (a,n)
end program probamos
 Otras posibilidades...

Introduccion a
Fortran 90
Los modulos tambien permiten redefinir operaciones o trabajar con
nuevos tipos que nosotros podemos crear.
Generalidades

Variables en
Fortran 90 No detallaremos mas sus posibilidades. Para los que esten interesados
Expresiones recomendamos leer las referencias en la pagina web:
Arrays

Bloques de
control
http://www.cs.rpi.edu/ szymansk/OOF90/main.html
Programacion
estructurada

Modules o el libro (que esta en la bibliografa):

Instrucciones de
entrada/salida
W.S. Brainerd, Ch.H. Goldberg, J.C. Adams,
Programmers guide to Fortran 90, Unicomp, 1994.
 Instrucciones de Entrada / Salida

Introduccion a
Fortran 90
Transfieren informacion entre la memoria principal y la externa o
auxiliar. Son de 3 tipos:
Generalidades

Variables en Apertura y cierre de ficheros: open, close

Fortran 90

Expresiones
Transferencia de datos: read, write, print
Arrays Posicionado en el fichero: backspace, rewind, endfile
Bloques de
control Un fichero se compone de registros, los cuales tienen varios campos.
Programacion
estructurada Tipos de registros:
Modules Formateados
Instrucciones de No formateados
entrada/salida
EOF (fin de fichero)
Tipos de ficheros:
Formateados
No formateados
Formas de acceso a un fichero:
Secuencial
Directa
 Apertura, cierre y posicionado

Introduccion a
Fortran 90 open: Establece una conexion entre una unidad logica y un
fichero, definiendo las propiedades de la misma.
Generalidades

Variables en open (unit, file, status, access, form)

Fortran 90
unit: Expresion entera (1 n 255) que define la unidad logica
Expresiones
file: Nombre del fichero (cadena de caracteres)
Arrays
status: new, old, unknown
Bloques de
control access: direct, sequential
Programacion form: formatted, unformatted
estructurada

Modules
open (unit=1, file=alumnos.dat, status=old)
Instrucciones de
open (2, file=notas.out, status=unknown)
entrada/salida
close: Cierra la conexion entre fichero y unidad logica.
close(1)
close(unit=2)
rewind: Rebobina y se coloca en el primer registro de la
unidad.
rewind(1)
 Transferencias de datos

Introduccion a
Fortran 90
Componentes de una sentencia de transferencia de datos:
Generalidades 1 Orden: read, write, print.
Variables en
Fortran 90
2 Lista de control: especificaciones.
Expresiones
2.1. Unidad de fichero.
Arrays 2.2. Formato para la lectura o escritura.
Bloques de
control
3 Lista de entrada/salida: nombre de variables que leemos o
Programacion
escribimos.
estructurada

Modules

Instrucciones de
entrada/salida
 Transferencias de datos: Lectura

Introduccion a
Fortran 90
read (secuencial): Lee datos de registros secuenciales.
Generalidades
Formateados: lee, convierte a binario y asigna.
Variables en No formateados: lee y asigna.
Fortran 90

Expresiones

Arrays read (1,100) a

Bloques de 100 format (F5.3)
control

Programacion
estructurada read (5,*) a
Modules read*, a
Instrucciones de
entrada/salida
read 100, a

La unidad 5 es la predefinida para la lectura de datos por

teclado.
 Transferencia de datos: Escritura

Introduccion a
Fortran 90 write: Transfiere datos de la memoria a unidades auxiliares
(pantalla /ficheros). Puede ser secuencial o de acceso directo.
Generalidades

Variables en
Fortran 90 write (1,100) a
Expresiones 100 format (F5.3)
Arrays

Bloques de
control write (6,*) a
Programacion write*, a
estructurada
write 100, a
Modules

Instrucciones de
entrada/salida
La unidad 6 es la predefinida para la escritura de datos por
pantalla.

print: Transferencia de datos desde la memoria principal a la

pantalla. Pueden escribirse formateados o sin formatear:
print*, hola
print 200, a
200 format (...)
 Sentencias de especificacion de formato

Introduccion a
Fortran 90
Indican como se encuentran formateados los datos que leemos o
como queremos escribirlos en el fichero o en pantalla.
Generalidades
Existen tres maneras de especificar el formato:
Variables en
Fortran 90
Usando una expresion caracter:
Expresiones

Arrays
write(2, (1x,F8.2)) a
Bloques de Mediante una etiqueta con la sentencia que contiene el formato:
control
write (2,100) a
Programacion
estructurada 100 format (F5.3)
Modules
En formato libre:
Instrucciones de
entrada/salida write (2,*) a
Veremos a continuacion los tipos de codigos para datos.
 Formato i (valores enteros)

Introduccion a i: Formato para valores enteros.

Fortran 90
Sintaxis: in[.m]
Generalidades
n : constante entera que indica el numero de posiciones del
Variables en campo.
Fortran 90
m : escribe al menos m caracteres, rellenando con ceros si fuera
Expresiones
necesario (es opcional).
Arrays

Bloques de
control
Ejemplo (entrada):
Programacion
estructurada
Valor externo Formato Valor interno
Modules 8235 i4 8235
Instrucciones de b/-67 i4 -67
entrada/salida
-346 i4 -346
4530 i3 453
Ejemplo (entrada):
Cadena externa: -23b/4783+15
Sentencia: read(1,100) k1,k2,k3
100 format (i3, i3, i2)
Resultado: k1=-23, k2=47, k3=83
 Formato i (valores enteros)

Introduccion a
Fortran 90
i: Formato para valores enteros.
Sintaxis: in[.m]
Generalidades
n : constante entera que indica el numero de posiciones del
Variables en
Fortran 90 campo.
Expresiones m : escribe al menos m caracteres, rellenando con ceros si fuera
Arrays
necesario (es opcional).
Bloques de
control
Ejemplo (salida):
Programacion
estructurada

Modules
Valor interno Formato Valor externo
Instrucciones de
824 i4 b/824
entrada/salida
0 i3 b/b/0
1273 i3 ***
Ejemplo (salida):
k=128
write(6,100) k
100 format(i7.5)
b/b/00128
 Formato f (forma decimal)

Introduccion a f: Formato para numeros reales en forma decimal.

Fortran 90
Sintaxis: fn.d
Generalidades
n : numero total de dgitos incluyendo el signo y el punto
Variables en
decimal (si existen).
Fortran 90 d : numero de dgitos de la parte decimal.
Expresiones
Observaciones (referentes a la salida):
Arrays
Los caracteres se ajustan a la derecha.
Bloques de
control Si el numero tiene mas de d decimales se redondea.
Programacion Si tiene mas de n caracteres, escribe asteriscos.
estructurada
Ejemplo (entrada):
Modules

Instrucciones de Valor externo Formato Valor interno

entrada/salida
43305E-2 f6.2 433.05
43305E-2 f8.0 433.05
Ejemplo (salida):
Valor interno Formato Valor externo
25.338 f9.3 b/b/b/25.338
25.338 f6.1 b/b/ 25.3
-12.345 f5.3 *****
 Formato e

Introduccion a
Fortran 90

e: Numeros reales en formato exponencial.

Generalidades

Variables en
Fortran 90

Expresiones
Sintaxis: en.d
Arrays n : numero total de posiciones del campo (ha de incluirse el
Bloques de signo, el punto decimal y el exponente, ademas de la mantisa).
control
d : numero de cifras decimales de la mantisa.
Programacion
estructurada

Modules

Instrucciones de Ejemplo (salida):

entrada/salida
Valor interno Formato Valor externo
83.974 e10.2 b/b/0.84E+02
e10.4 0.8397E+02
e9.4 *********
 Formatos a, x y especiales

Introduccion a
Fortran 90 a: Manejo de cadenas de caracteres.
character (len=6) :: variable
Generalidades
variable= musica
Variables en
Fortran 90 write (6,100) musica
Expresiones 100 format (a6) musica
Arrays 100 format (a7) musicab/
Bloques de
control
100 format (a4) musi
Programacion 100 format (a) musica
estructurada
x : Espacios en blanco.
Modules 
(entrada) n= numero de caracteres que se salta
Instrucciones de nx:
entrada/salida (salida) n= numero de blancos que escribe
t: Tn lee o escribe en la n-esima columna.
/ : Salto de lnea.
$ : Elimina el retorno de carro (solo se usa en salida).
 Ejemplo

Introduccion a
Fortran 90
32
Generalidades 15.245 728.346
matriz.dat
Variables en 2.5 7.8654
Fortran 90

Expresiones
14.324 1025.22
Arrays

Bloques de
control
program trasponer
Programacion implicit none
estructurada
integer(kind=4) :: nf,nc,iter
Modules
real(kind=8),dimension(:,:),allocatable::m
Instrucciones de
entrada/salida open(1,file=matriz.dat,form=formatted)
rewind(1)
read(1,*)nf,nc
allocate(m(nf,nc))
do iter=1,nf
read(1,*) m(iter,1:nc)
end do
close(1)
 Ejemplo

Introduccion a
Fortran 90 open(2,file=matriz tras.dat,form=formatted)
rewind(2)
Generalidades
write(2,(i2,1x,i2))nc,nf
Variables en
Fortran 90 do iter=1,nc
Expresiones write(2,100) m(1:nf,iter)
Arrays end do
Bloques de
control
close(2)
Programacion
100 format(99(F6.2,1x))
estructurada end program
Modules

Instrucciones de
entrada/salida 2 3
15.24 2.50 14.32 matriz tras.dat
728.35 7.87 ******
 Otro ejemplo

Introduccion a
Fortran 90

32
Generalidades 15.245 728.346
matriz.dat
Variables en
Fortran 90
2.5 7.8654
Expresiones 14.324 1025.22
Arrays

Bloques de program trasponer

control

Programacion
implicit none
estructurada integer(kind=4) :: nf,nc,iter
Modules real(kind=8),dimension(:,:),allocatable::m
Instrucciones de
entrada/salida
open(1,file=matriz.dat,form=formatted)
rewind(1)
read(1,*)nf,nc
allocate(m(nf,nc))
do iter=1,nf
read(1,*) m(iter,1:nc)
end do
close(1)
 Otro ejemplo

Introduccion a
Fortran 90 open(2,file=matriz tras.dat,form=formatted)
rewind(2)
Generalidades
write(2,2(i3,1x))nc,nf
Variables en
Fortran 90 do iter=1,nc
Expresiones write(2,100) m(1:nf,iter)
Arrays end do
Bloques de
control
close(2)
Programacion
100 format(99(E12.6,1x))
estructurada end program
Modules

Instrucciones de
entrada/salida
matriz tras.dat:
2 3
0.152450E+02 0.250000E+01 0.143240E+02
0.728346E+03 0.786540E+01 0.102522E+04
 Introduccion a
Fortran 90 Un programa de ordenador presenta muchas similitudes con una obra
musical, un libro, una pelcula o un plato de cocina. Su estructura, su
Generalidades ritmo, su estilo y sus ingredientes permiten identificar o, al menos,
Variables en acercarse mucho, al autor que esta detras. Un hacker no es sino una
Fortran 90
persona que practica la programacion informatica con un cierto tipo de
Expresiones
pasion estetica y que se identifica con un cierto tipo de cultura que no se
Arrays
reduce simplemente a una forma de ser, vestir o vivir, sino tambien a una
Bloques de
control manera especial de ver el codigo, de comprender la belleza de su
Programacion composicion y la perfeccion de su funcionamiento. Para que el codigo de
estructurada
un programa presente esa belleza solo tiene que cumplir dos normas
Modules
elementales: simplicidad y claridad. Si puedes hacer que el ordenador
Instrucciones de
entrada/salida ejecute una orden con una sola instruccion, para que utilizar cien, o mil?
Si puedes encontrar una solucion brillante y limpia a un problema concreto,
para que copiar pedazos de codigo de otras aplicaciones y malcasarlos con
remiendos? Si puedes clasificar las funciones una detras de otra de forma
clara, para que complicar el codigo con saltos y vueltas que solo sirven
para ralentizar su funcionamiento?
Matilde Asensi. El origen perdido (2003)