Aprendiendo A Programar en Fortran90-Jose Ojeda BASICO

Aprendiendo a programar en
Fortran90
Jose Ojeda
http://www.udec.cl/jojeda
Presentacion del libro
Aprendiendo a programar en Fortran90
Primera edicion (Enero de 2006), tercera reimpresion (Abril 2006).
Esta obra fue escrita por:
Jose Ojeda
Alumno de Ciencias Fsicas y Astronomicas,
Departamento de Fsica,
Facultad de Ciencias Fsicas y Matematicas,
Universidad de Concepcion.
Concepcion, CHILE.
Prefacio
La base de este libro fue bastante rudimentaria, pues se trata de algunas guas que es-
crib cuando realice mi primera ayudanta en la Universidad. Esta ayudanta fue para
la asignatura de Computacion Cientca, a la cual asisten alumnos de Ciencias Fsicas
y Astronomicas, Licenciatura en Matematica e Ingeniera Estadstica. Esta asignatura
considera dentro de su malla de contenidos, la programacion en Fortran.
Este libro es resultado de un gran trabajo y dedicacion, por lo que estoy muy orgulloso
de poder presentar este texto al p ublico en general. A partir de aqu, se podran ad-
quirir la mayora de los conocimientos necesarios para que las personas se desempe nen
a nivel de usuario normal, dentro de lo que es el mundo de la programacion en Fortran.
Primero se presenta una introduccion a este lenguaje de programacion, y luego se
dedica un apartado completo a los fundamentos de programacion. Luego se presentan
aspectos un poco mas complicados de Fortran.
Jose Ojeda, Enero de 2006.
Novedades en esta reimpresion
Se corrigieron algunas palabras mal tipeadas y se mejoro el formato del libro: se au-
mento el area del texto en cada hoja, El formato predeterminado de L
A
T
E
X(lenguaje
en el que se escribio este libro) utiliza considerable espacio para los bordes.
Aprendiendo a programar en Fortran90 - Jose Ojeda - www.udec.cl/jojeda 3
Indice
I Introduccion a Fortran 5
1. Introduccion y preliminares 5
1.1. Que es un compilador . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2. Breve rese na sobre Fortran . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3. Como esta organizado este libro . . . . . . . . . . . . . . . . . . . . . . 5
2. Pensar como programador 6
2.1. Planicacion del programa . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2. Plantearse las preguntas adecuadas . . . . . . . . . . . . . . . . . . . . 6
3. Desarrollo del programa hola mundo 7
3.1. Empleo de un editor de codigo fuente . . . . . . . . . . . . . . . . . . . 7
3.2. Hola Mundo! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
II Fundamentos de programacion 8
4. Sentencias basicas 9
4.1. La sentencia program . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2. La sentencia write(*,*) . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3. La sentencia read(*,*) . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5. Variables, constantes y operadores basicos de Fortran 11
5.1. Tipos de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5.2. Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.3. Asignando valores a las variables . . . . . . . . . . . . . . . . . . . . . 14
5.4. Operadores basicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
III Estructuras de control e iterativas 16
6. Estructuras de control 16
6.1. Estructura secuencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6.2. Estructura alternativa . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6.3. Estructura bialternativa . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.4. Estructura multialternativa . . . . . . . . . . . . . . . . . . . . . . . . 18
7. Estructuras iterativas 19
7.1. Iteracion con contador . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
7.2. Iteracion condicional . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
IV Funciones intrnsecas, funciones y subrutinas 21
8. Funciones intrnsecas 22
9. Sentencia contains, funciones y subrutinas 23
9.1. Sentencia contains . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
9.2. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
9.3. Subrutinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
10.El efecto colateral 27
5
Parte I
Introduccion a Fortran
1. Introduccion y preliminares
1.1. Que es un compilador
Un compilador es un software que hace literalmente la funci on de traductor. El
programador, al enfrentarse a un problema, genera un algoritmo para poder resolver-
lo. Este algoritmo es escrito en un lenguaje de programacion especco. Luego, para
poder traducir este codigo que ha generado el programador, al lenguaje de maquina
(que es el que entiende el computador), se necesita un compilador. Cada lenguaje de
programacion es diferente y para cada uno de estos tambien existen distintos compi-
ladores. Por ejemplo, para Fortran existen variados compiladores, tales como Compaq
VisualFortran o Intel Fortran for Linux; cada uno de estos genera el mismo resulta-
do, pero estos dos son bastante diferentes entre s. Existen variados compiladores de
Fortran que se pueden bajar de forma gratuita desde Internet.
1.2. Breve rese na sobre Fortran
Existen muchas versiones de Fortran, entre ellas, Fortran77, Fortran90 y ahora
ultimo ha salido al mundo de la programacion Intel Fortran. Este lenguaje de pro-
gramacion ya lleva muchsimos a nos en el mercado, y ha demostrado ser uno de los
mas versatiles en cuanto a la simplicidad de la sintaxis. Por ejemplo, cuando uno ve
un codigo fuente escrito en este lenguaje de programacion, no es muy difcil entender
que es lo que hace; sin embargo en otros lenguajes esta tarea es algo mas difcil y
engorrosa.
Es muy utilizado en el ambito cientco, y posee una amplia variedad de funcio-
nes que permiten llevar a cabo los mas diversos procesos, como calculos matematicos
complicados, en un tiempo muy reducido.
1.3. Como esta organizado este libro
Este libro cuenta con algunas convenciones que es conveniente recordar a medida
que se va leyendo:
Codigo de programa y salida en pantalla: En este tipo de letra monoespa-
ciada apareceran los listados correspondientes a codigo de programa, tal como si
se estuviesen escribiendo en un programa editor de texto. Tambien con este tipo
de letra se presentaran los mensajes de salida que emita en pantalla el programa.
Ejemplo:
program mensaje
write(*,*) "Este es el mensaje"
end program
Otro ejemplo:
Introduzca el vector para determinar su norma:
Instrucciones de codigo: Es el mismo estilo del primero presentado en esta
lista, pero las palabras estan encerradas con llaves ({ }). Cuando se enfrente a
la situacion real de estar programando, debera reemplazar estas palabras por la
instruccion contenida en ellas. Por ejemplo:
program mensaje
write(*,*) "{texto de mensaje}"
end program
Aqu debera reemplazar {texto de mensaje} por el texto de mensaje que desea
presentar en pantalla. Si estuviesemos en una situacion real, y Ud. quisiera pre-
sentar el mensaje Esto es una prueba en pantalla, debera escribir lo siguiente:
program mensaje
write(*,*) "Esto es una prueba"
end program
2. Pensar como programador
2.1. Planicacion del programa
El primer paso, antes de entrar de lleno a programar, es planicar el programa. La
idea es determinar con exactitud la tarea que realizara el programa. Inicialmente este
paso puede ser un poco tedioso, pero con la practica se va automatizando. La frase
que siempre prima en el ambiente de la programacion es pensar antes de actuar. Esto
ayudara a programar de mejor manera. La planicacion del programa implica necesa-
riamente hacerse algunas preguntas con respecto al programa que se quiere hacer.
La forma de resolver un problema se llama algoritmo; y siempre la idea es hallar
este algoritmo y traducirlo al lenguaje de programacion - que en este caso es Fortran
- para poder obtener un resultado.
2.2. Plantearse las preguntas adecuadas
Las siguientes preguntas son trascendentales a la hora de iniciar la planicacion de
un programa:
Cual es el objetivo del programa que se esta haciendo?
Quien utilizara el programa?
Que informacion se debera introducir al programa?
De que forma procesara el programa la informacion introducida?
Que y como mostrara el programa el resultado de los procesos?
Se pueden agregar otras preguntas, pero estas son las mas generales. Los programas
com unmente necesitan que el usuario ingrese informacion para que la procese y nal-
mente muestran un resultado en pantalla, o en algunos casos generan un archivo de
texto o envan el resultado a una impresora.
3. Desarrollo del programa hola mundo
3.1. Empleo de un editor de codigo fuente
Para poder generar un programa y ejecutarlo, en primera instancia debemos crear
un codigo fuente. Este codigo fuente es un archivo de texto plano; es decir, no con-
tiene formatos especiales (colores, imagenes, tipografas, etc.). Este tipo de archivo,
por lo general lleva la extension .txt. En el caso de un codigo fuente para Fortran90,
sera conveniente guardar estos archivos con la extension .f o .f90, para identicar los
codigos fuente de los archivos de texto ordinarios.
Para elegir un editor de codigo fuente adecuado, es completamente necesario que
pueda abrir y guardar los archivos en el formato mencionado en el parrafo anterior.
Para Windows, se recomiendan los siguientes editores:
Bloc de notas
WordPad
En el caso de Linux, trabajar en la edicion de codigos fuente de Fortran es muchsimo
mas comodo, pues casi todos los editores de texto en forma predeterminada colorean
el texto, de acuerdo al tipo de instruccion que representan las palabras insertas en el
mismo. Se recomiendan para este sistema operativo, los siguientes editores:
KWrite
Kate
Por cierto hay otros editores mas avanzados, pero la idea es trabajar con los programas
que trae de forma predeterminada el sistema operativo. Si ha comprado un software
especial, puede obviamente usarlo en reemplazo de los programas mencionados ante-
riormente.
3.2. Hola Mundo!
Ahora, ya sabemos que para crear un programa, debemos tener un codigo fuente.
En este codigo fuente colocamos las instrucciones que deseamos que el computador
realice. En programacion se habla del programa hola mundo, como aquel primer pro-
grama que una persona hace, en un lenguaje de programacion que recien esta apren-
diendo. Ahora, Ud. dira hola mundo! al mundo de la programacion en Fortran90.
Para esto, debera iniciar un editor de texto, que tenga las caractersticas indicadas
en la subseccion anterior. Luego, escriba lo siguiente:
program hola
write(*,*) "Hola mundo!"
end program hola
Ahora, debe guardar el archivo, como hola.f90 (u hola.f). Luego de esto debe com-
pilar el programa, para generar un archivo ejecutable para el computador (el codigo
fuente no puede ser ejecutado por el computador, pero el archivo ejecutable asociado
al mismo, s). Para esto, tiene que ir al Smbolo de sistema (Windows) o a la Termi-
nal (Linux). Luego, tiene que situarse en la carpeta en donde ha guardado el archivo
y escribir el comando que permite compilar el codigo fuente. Existen varios compila-
dores para Fortran90, por lo que el comando para compilar variara dependiendo del
compilador. Por ejemplo, en el caso de Intel Fortran para Linux, hay que escribir:
ifort hola.f90 -o salida, donde salida es el nombre del archivo ejecutable que
sera resultado de la compilacion.
Ahora, luego de haber compilado, solo basta con poner en la lnea de comando el
nombre del archivo ejecutable y presionar Enter. En pantalla debera aparecer lo
siguiente:
Hola mundo!
Si es as, felicitaciones!. Ha hecho su primer programa en el lenguaje de programacion
Fortran90.
En la siguiente parte, se deniran los fundamentos para poder programar en For-
tran90.
9
Parte II
Fundamentos de programacion
4. Sentencias basicas
4.1. La sentencia program
Toda vez que deseemos crear un programa, la primera lnea que este tenga en su
codigo fuente, debera ser: program {nombre}; mientras que siempre la ultima debe
ser end program {nombre}. Estas sentencias le indican a Fortran en donde comienza
y termina el programa, respectivamente. Entonces, todos los programas para Fortran
son de la siguiente forma:
program {nombre}
{sentencias a ejecutar}
end program {nombre}
Aqu, {nombre} corresponde al nombre del programa, el cual debe obligatoriamen-
te comenzar con un caracter alfabetico y no debe contener caracteres extra nos, y
{sentencias a ejecutar} corresponde a las sentencias que se ejecutaran en el pro-
grama. En el ejemplo del programa Hola mundo!, se nota inmediatamente que el
programa se llama hola, al igual que las sentencias que se ejecutan (en este caso es
solamente la que muestra el mensaje en pantalla).
4.2. La sentencia write(*,*)
De manera intuitiva, ya sabemos que la sentencia write(*,*) nos permite mostrar
un mensaje en pantalla. A continuacion se dene formalmente su uso:
write(*,*) "{mensaje a mostrar en pantalla}"
Notese que el mensaje que deseamos presentar va encerrado en comillas dobles. Esto
debe ser siempre de esta forma.
Existe otra forma de utilizar esta sentencia, la cual permite mostrar el valor de una
variable (en la proxima seccion se tratara esto ultimo). Para poder realizar esta tarea,
utilizamos la sentencia write(*,*) en esta forma:
write(*,*) {variable}
Adicionalmente, si buscamos que se muestren varias variables a la vez, debemos sepa-
rarlas con comas, tal como sigue:
write(*,*) {variable 1}, {variable 2}, ..., {variable n}
El resultado en pantalla es de tal forma que, los valores escritos se muestran de iz-
quierda a derecha, en el mismo orden en que se colocaron en el codigo fuente. Si el
espacio en la pantalla no alcanza para presentar todo en una misma lnea, el contenido
que no alcanza a aparecer, es colocado en la lnea siguiente. Esto ocurre cuantas veces
sea necesario, hasta que se presente toda la informacion.
Si hacemos uso reiterado de esta sentencia, tenemos que los valores se organizan en
columnas. Por ejemplo, si tenemos el siguiente programa:
program numeros
var1=1
var2=22
var3=333
write(*,*) var1, var2, var3
var1=4
var2=55
var3=666
write(*,*) var1, var2, var3
end program numeros
La salida en pantalla sera:
1.000000 22.00000 333.0000
4.000000 55.00000 666.0000
Que era lo que esperabamos. Los n umeros aparecieron ordenados y en columnas. Cabe
destacar que este truco no funciona bien si alguno o todos los write(*,*) muestran
informacion tal que en pantalla sobrepasa una lnea.
4.3. La sentencia read(*,*)
A veces, necesitamos que el usuario ingrese ciertos datos para que un programa
pueda realizar un determinado proceso. La sentencia read(*,*) permite realizar esta
tarea, y se utiliza de la siguiente forma:
read(*,*) {variable}
En donde {variable} es la variable en donde se guardara el dato introducido por el
usuario. Si se ejecuta el programa, cuando se llegue al read(*,*), esta se detendra a
la espera de que el usuario introduzca la informacion requerida (el cursor quedara par-
padeando e inmovil). Al escribir la informacion, el usuario debera presionar Enter
para continuar la ejecucion.
Por otra parte, si necesitamos que se ingresen mas datos y no queremos repetir la
sentencia read(*,*), podemos escribir:
read(*,*) {variable 1}, {variable 1}, ..., {variable n}
Ahora, el usuario debera ingresar los valores separados por Enter; es decir, introduce
un primer valor y presiona Enter, luego un segundo valor y presiona la misma tecla, y
as sucesivamente hasta que se haya establecido el valor de las variables que acompa nan
a read(*,*). El ejemplo siguiente permite ilustrar el uso de esta sentencia:
program espejo
write(*,*) "Ingrese un numero:"
read(*,*) a
write(*,*) "Se ingreso el numero:", a
end program espejo
Aqu se solicita al usuario que ingrese un n umero que sera guardado en la variable a,
y luego el programa muestra en pantalla el n umero que se ingreso al mismo. La salida
en pantalla es similar a la que sigue:
Ingrese un numero:
3.4
Se ingreso el numero: 3.400000
En primer lugar, aparecio el mensaje Ingrese un numero:, y el cursor quedo par-
padeando debajo de esta frase. Luego, el usuario ingreso el n umero 3.4 mediante el
teclado y presiono Enter, causando que este valor se haya guardado en a. Finalmente,
el programa muestra el mensaje Se ingreso el numero: 3.400000 como resultado
del proceso.
5. Variables, constantes y operadores basicos de
Fortran
5.1. Tipos de variables
Hasta ahora, hemos hablado de variables sin especicar exactamente de que se
tratan. Las variables son nombres que se usan dentro del entorno de la programacion,
para hacer referencia a un n umero, cadena de texto, u otro objeto. En el caso de
Fortran90, los nombres de las variables no deben tener mas de 31 caracteres y adicio-
nalmente deben, obligatoriamente, comenzar con un caracter alfabetico. En Fortran90
existen 5 tipos de datos basicos, que se enumeran a continuacion:
Tipo integer: Se utiliza para n umeros enteros. Para declarar una variable en-
tera, se escribe:
integer:: {nombre variable entera}
donde nombre variable entera es el nombre de la variable entera. Si por acci-
dente le se intentara asignar un n umero real, Fortran le asignara la parte entera
del n umero real. En el siguiente ejemplo se muestra como declarar una variable
entera:
program crear_variable
integer::num_entero
end program crear_variable
Aqu se declaro a la variable num entero como una de tipo entero. De forma
similar se hace para los otros tipos de datos que siguen.
Tipo real: Tipo de variable usado para n umeros reales. Para este tipo, es posible
asignarle precision simple o doble. La diferencia entre ambas precisiones, es que
la segunda entrega mas decimales (es mas precisa) que la primera. La precision
predeterminada es la simple. Si deseamos declarar a una variable como real, lo
hacemos de la siguientes formas:
real:: {nombre variable real simple precision}
real*8:: {nombre variable real doble precision}
Si bien la precision simple proporciona buenos resultados, en calculos mas deli-
cados, es muy conveniente utilizar precision doble.
Tipo complex: Se utiliza para n umeros complejos. Al igual que el tipo real,
tambien admite una especicacion de la precision:
complex:: {nombre variable compleja simple precision}
complex*8:: {nombre variable compleja doble precision}
Este tipo de variables son de la forma (parte real,parte imag.), donde parte
real es la parte real del n umero complejo, y parte imag. es la parte imaginaria
del n umero.
Tipo logical: Este tipo de variable puede asumir solo 2 valores: .true. o
.false.:
logical:: {nombre variable logica}
Tipo character: Se usa para que la variable pueda contener caracteres alfabeti-
cos. A este tipo de variable debe especicarsele un parametro adicional que tiene
relacion con el n umero de caracteres maximo que puede contener la variable. Es-
to se hace colocando *n, donde n es un n umero entero que indica la longitud
maxima del texto. Para declarar una variable de este tipo, escribimos:
character*{n}:: {nombre variable character}
De este modo se declara una variable de tipo character, que podra contener
un maximo de n caracteres. Si se le asignara un texto que contiene mas de n
caracteres, Fortran recortara el texto que se le intenta asignar a la variable,
dejando solamente los primeros n caracteres, comenzando desde la izquierda del
texto. Observese el siguiente ejemplo:
program caracter
character*4::texto
texto="Hola"
write(*,*) texto
texto="Adios"
write(*,*) texto
end program caracter
Aqu declaramos a texto como una variable de tipo character con una longi-
tud maxima de 4 caracteres. Luego, en dos ocasiones asignamos una cadena de
texto a la variable y la mostramos en pantalla. La salida es la que se muestra a
continuacion:
Hola
Adio
El mensaje Adios aparecio cortado, pues la longitud maxima con que fue decla-
rada la variable es de 4 caracteres.
Una ultima cosa a destacar es que cuando deseamos asignar un texto a una
variable del tipo character, es necesario que este este encerrado entre comillas
dobles, tal como se puede apreciar en el ejemplo anterior.
Cabe destacar que se puede declarar mas de una variable del mismo tipo, en una
misma lnea. Generalmente, esto de hace as:
tipo variable:: {variables separadas por comas}
Por ejemplo, si desearamos declarar las variables reales numreal1, numreal2 y numreal3
en una misma lnea, deberamos escribir:
real:: numreal1,numreal2,numreal3
5.2. Constantes
Para declarar una variable como constante, se tiene que utilizar la palabra clave
parameter, de la siguiente forma:
real,parameter:: pi=3.1415926
Aqu se declaro la variable pi como una constante, y con valor 3.1415926. De forma
similar se hace con los otros tipos de variables existentes en Fortran.
Las constantes, no pueden ser modicadas por instruccion alguna, despues de haber
sido declaradas.
5.3. Asignando valores a las variables
Ahora que ya sabemos como declarar el tipo de dato de un variable, deseamos
asignarle un valor. Para este efecto, podemos utilizar read(*,*) de forma pertinente,
y tambien se puede usar el signo igual (=). Para esta ultima forma existe hecho muy
importante: Fortran asigna el valor del lado derecho del signo igual, a la variable que
esta a la izquierda. Esto se ilustra mejor en el siguiente ejemplo:
real::a,b
a=4
b=5
En el ejemplo, se declaro como variables enteras a a y b, y luego se les asignaron los
valores 4 y 5 respectivamente. Ahora, si hacemos lo siguiente:
b=a
El valor de a es asignado a b y no al reves; el valor de b ahora sera 4.
Esa es una caracterstica muy importante que hay que recordar de aqu en adelan-
te, para evitar errores.
5.4. Operadores basicos
Ahora que sabemos asignarle valores a las variables, deseamos saber como operar
con ellas (sumarlas, restarlas... etc.). Tambien podramos querer compararlas entre s.
Existen principalmente 3 tipos de operadores:
Tipo Aritmetico: Tal como su nombre lo indica, permite trabajar aritmetica-
mente las variables. A continuacion se presenta una tabla que contiene todos los
tipos de operadores aritmeticos:
Nombre Operador Ejemplo Resultado
Suma + a=2+1 a=3
Resta - a=2-1 a=1
Multiplicacion * a=2*3 a=6
Division / a=4/2 a=2
Exponenciacion ** a=2**3 a=8
Los operadores aritmeticos solo estan denidos para variables numericas. No
para tipo logico ni de caracteres.
Tipo Relacional: Permite relacionar dos variables. Dentro de este tipo est an
los operadores:
Nombre Operador
Mayor que >, o .GT.
Mayor o igual que >=, o .GE.
Menor que <, o .LT.
Menor o igual que <=, o .LE.
Equivalencia =, o .EQ.
Inequivalencia ! =, o .NEQ.
Al igual que el tipo de operador anterior, estos estan denidos solo para n umeros
enteros y reales. Mas adelante se dara un ejemplo del uso de estos operadores.
Tipo Logico: Este tipo de operadores esta denido para expresiones logicas.
Nombre Operador
Negacion .NOT.
Conjuncion .AND.
Disyuncion .OR.
Equivalencia =, o .EQ.
Inequivalencia ! =, o .NEQ.
Estos operadores cobran relevancia cuando se usan en estructuras de control
alternativas y repetitivas. Se comportan en forma identica a los presentados en
la logica matematica (si no tiene conocimientos de logica, se recomienda estudiar
el tema antes de continuar). Notese que la equivalencia y la inequivalencia son los
unicos operadores que estan denidos tanto para n umeros como para expresiones
logicas.
Los operadores de tipo relacional y logico, producen un resultado logico. Es decir,
pueden indicarnos si la respuesta de la operacion relacional o logica entre dos variables
es verdadera o falsa. El siguiente ejemplo ayuda a ilustrar esta situacion:
program operador
real::a,b,c
write(*,*) "Ingrese 3 numeros:"
read(*,*) a,b,c
if (a>b .and. b>c) then
write(*,*) "a es mayor que b, y b es mayor que c."
end if
end program operador
En primer lugar, se declaran las variables a, b, c. Luego, se muestra en pantalla un
mensaje que le pide al usuario que ingrese 3 n umeros, el usuario los ingresa y nalmente
el programa muestra un mensaje siempre cuando a sea mayor que b y esta ultima
variable sea mayor que c. Recordando un poco de logica matematica, tenemos que la
expresion a>b es verdadera si a es mayor que b, y de manera similar para b>c. Luego,
el operador de conjuncion proporciona un valor verdadero s y solo si las expresiones
16
logicas relacionadas son verdaderas. Por ejemplo, si ingresamos los n umeros de tal
modo que se tengan las igualdades: a=1, b=2 y c=3, el programa mostrara el mensaje,
pues a>b asume el valor verdadero (.true.) y lo mismo pasa con b>c. Luego, a>b
.and. b>c es verdadero. Por causa de esto, se muestra el mensaje (mas adelante se
vera como funciona la estructura if).
Parte III
Estructuras de control e iterativas
6. Estructuras de control
6.1. Estructura secuencial
Este tipo de estructura, es aquella en la que las sentencias contenidas en el codigo
fuente se ejecutan en forma secuencial. Es decir, luego de ejecutarse una sentencia, se
pasa a la inmediatamente siguiente (de arriba hacia abajo); y as sucesivamente. Otra
manera de decir lo anterior, es que no hay saltos en la ejecucion de las sentencias.
De acuerdo a lo precedente, entonces podemos decir que la forma de este tipo de
estructura, es la que se indica a continuacion:
{sentencia 1}
{sentencia 2}
...
{sentencia n}
Un ejemplo de este tipo de estructura es el siguiente:
program secuencial
integer::a,b
a=1
b=2
write(*,*) a
write(*,*) b
end program secuencial
Aqu, el programa declara las variables como enteras, luego establece sus valores y
nalmente escribe en pantalla el valor de las variables a y b. Para realizar esto, las
sentencias se ejecutaron de forma secuencial. No hubo ning un salto en el orden de
ejecucion de las sentencias contenidas en el codigo fuente.
6.2. Estructura alternativa
A veces, es necesario desviar literalmente el orden de ejecucion de las sentencias
de un programa, de acuerdo a si se da una situacion especca u otra. Para esto,
utilizamos la estructura alternativa. Esta nos permite ejecutar ciertas sentencias s y
solo si se produce cierta situacion. Estas situaciones son en realidad expresiones
logicas, que si son verdaderas, desencadenan la ejecucion de las sentencias encerradas
en la estructura alternativa. La forma de este tipo de estructura es la siguiente:
if ({condicion}) then
{sentencias a ejecutar si la condicion es verdadera}
end if
Donde {condicion} corresponde a una expresion logica. Si esta expresion l ogica es
verdadera (asume el valor .true.), se ejecutaran las sentencias que estan dentro de la
estructura if. De lo contrario, si es falsa, no se ejecutaran las sentencias dichas ante-
riormente, y se seguiran ejecutando las sentencias que estan inmediatamente despues
del end if. Para ejemplicar el uso de esta estructura, podemos ver lo siguiente:
program alternativo
integer::a,b
write(*,*) "Ingrese dos numeros:"
read(*,*) a,b
if (a != b) then
write(*,*) "Los numeros a y b son distintos!"
end if
end program alternativo
Este programa pide al usuario que ingrese dos n umeros y luego muestra un mensaje
si los n umeros mencionados anteriormente son distintos. Es decir, emite esta notica-
cion si y solo si a!=b es verdadero. Si esta expresion logica fuese falsa, las sentencias
contenidas entre if y end if no se ejecutaran.
6.3. Estructura bialternativa
La estructura alternativa permite solamente ejecutar un grupo de sentencias si la
condicion dada es verdadera. Ahora, si queremos que esta estructura ademas contenga
sentencias a ejecutar si la condicion dada sea falsa, debemos utilizar la estructura
bialternativa. Este tipo de estructura es de la siguiente forma:
if ({condicion}) then
{sentencias a ejecutar si la condicion es verdadera}
else
{sentencias a ejecutar si la condicion es falsa}
end if
Ahora, si deseamos modicar el ejemplo anterior, de tal modo que muestre pueda
mostrar un mensaje en el caso de que los n umeros son iguales y tambien en el caso de
que sean distintos, debemos tener lo siguiente:
program bialternativo
integer::a,b
write(*,*) "Ingrese dos numeros:"
read(*,*) a,b
if (a != b) then
write(*,*) "Los numeros a y b son distintos!"
else
write(*,*) "Los numeros a y b son iguales!"
end if
end program bialternativo
Entonces, este programa mostrara un mensaje si a != b es verdadero, pero tambien
mostrara uno diferente si la expresion logica anterior es falsa. Aunque podramos obte-
ner el mismo resultado si colocamos una estructura alternativa que muestre un mensaje
si los n umeros son iguales y otra que nos diga si son diferentes, notamos que la estruc-
tura bialternativa es una forma compacta de escribir lo dicho anteriormente. Luego,
es mas conveniente, para esta tarea especca, utilizar la estructura bialternativa. Se
utilizan menos lneas, y se obtiene el mismo resultado.
6.4. Estructura multialternativa
En ciertos algoritmos no basta con 2 alternativas y se necesitan varias. Para estos
casos, se utiliza la estructura multialternativa. Esta tiene una forma un tanto diferente
a las alternativa y bialternativa. El argumento para poder utilizarlas (en el ejemplo,
es {variable}), ya no es de tipo logico, sino tiene que ser necesariamente de valor
numerico o de caracter.
select case ({variable})
case ({valor 1})
{sentencias a ejecutar {variable} es igual a {valor 1}}
case ({valor 2})
{sentencias a ejecutar {variable} es igual a {valor 2}}
...
case ({valor n})
{sentencias a ejecutar {variable} es igual a {valor n}}
case default
{sent. a ejec. si ninguna de las igualdades anteriores se da}
end select
Lo que hace esta estructura es comparar el valor de {variable} con los valores consi-
derados para los diferentes casos (case es una palabra inglesa que quiere decir caso).
Si se da la situacion de que el valor de la variable sea igual al considerado para un
caso, las sentencias asociadas para este caso se ejecutaran. Las sentencias a ejecutar
para cada caso, son aquellas que estan entre case ({valor}) y el comienzo de otro
caso. Luego de esto, las sentencias que se ejecutaran son aquellas que siguen a conti-
nuacion de end select. En el caso de que no se de ninguna igualdad, se ejecutaran
las sentencias consideradas dentro de case default
Es importante destacar que no es obligatorio el uso de case default en la estruc-
tura multialternativa, por lo que se puede prescindir de esta, cuando no se necesite.
El siguiente ejemplo ayuda a comprender los aspectos importantes de este tipo de
estructura:
program multialternativo
integer::num_mes
write(*,*) "Ingrese numero de mes, para ver cuantos dias tiene:"
read(*,*) num_mes
select case (num_mes)
case(1,3,5,7,8,10,12)
write(*,*) "El mes tiene 31 dias."
case(4,6,9,11)
case(2)
case default
write(*,*) "Numero de mes incorrecto!"
end select
end program multialternativo
Este programa permite ver el n umero de das que tiene un mes. El mes se identica
con un n umero, de tal forma que el n umero 1 corresponde a Enero, el 2 a Febrero, y
as sucesivamente hasta llegar a Diciembre, que le corresponde el n umero 12. Cuando
la variable num mes asume uno de los valores: 1,3,5,7,8,10,12, entonces el programa
muestra un mensaje diciendo que el mes introducido tiene 31 das. De manera similar
se explican los otros casos. Notese que si ingresamos el n umero 0, o tal vez el n umero
13, el programa muestra el mensaje: Numero de mes incorrecto!, pues en ning un
caso se consideran esos valores.
De aqu, tambien podemos inferir que a cada caso le podemos asignar mas de un
valor. Debemos separarlos con comas tal como se muestra en el ejemplo, para los
casos en que el mes introducido tiene 30 o 31 das.
7. Estructuras iterativas
En muchas oportunidades, necesitaremos que el programa repita varias veces un
conjunto de sentencias. Por ejemplo, si deseamos mostrar un determinado n umero de
terminos de una sucesion matematica. Para este tipo de tareas, tenemos que Fortran
nos ofrece las estructuras iterativas.
7.1. Iteracion con contador
Este tipo de estructura iterativa, permite repetir un n umero determinado de veces
un cierto grupo de sentencias. En este caso, el n umero de veces que se debe iterar,
no se puede modicar mientras la iteracion esta en proceso. Este tipo de estructura
iterativa posee la siguiente forma:
do {variable contadora}={valor inicial}, {valor final}
{sentencias a repetir}
end do
Aqu, {variable contadora} es una variable de tipo entero, {valor inicial} y
{valor final} son n umeros enteros. En el siguiente ejemplo se ilustra el uso de esta
estructura:
program iteracion_contador
integer::i
real::x
x=2.8
do i=0, 5
write(*,*) x**i
end do
end program iteracion_contador
Este programa debera producir la siguiente salida en pantalla:
1.000000
2.800000
7.840000
21.95200
61.46560
172.1037
Que corresponden a los terminos de la sucesion 2,8
i
con i entero y variando entre 0 y
5.
7.2. Iteracion condicional
La estructura iterativa condicional, luego de comenzar a iterar, contin ua iterando
hasta que la condicion que se le asocia se torna falsa. O de manera equivalente, sigue
iterando mientras la condicion sea verdadera. A diferencia de la estructura iterativa
con contador, no es necesario especicar el n umero de veces que deben repetirse las
sentencias. Hay que tener precaucion al utilizar este tipo de estructura, pues si la
condicion nunca se tornase falsa, entonces las iteraciones jamas acabaran. Entonces,
para este caso, es necesario que las sentencias consideradas en la estructura iterativa
condicional sean capaces de hacer que la condicion sea falsa, luego de algunas iteracio-
nes; y de esa forma se contin ua con la ejecucion normal del programa. El esqueleto
de este tipo de estructura es el que a continuacion se indica:
do while ({condicion})
{sentencias a ejecutar mientras la condicion sea verdadera}
end do
Aqu, {condicion} es una expresion logica. Un ejemplo de la utilizacion de esta es-
tructura es el siguiente: deseamos hacer un programa que muestre los terminos de la
sucesion 2,8
i
(la misma que la del ejemplo anterior), pero esta vez queremos sea desde
i = 0 y que las iteraciones se detengan si el termino correspondiente a esta es mayor
que 1000:
program iteracion_condicional
integer::i
real::x,y
x=2.8
i=0
do while (y<1000)
y=x**i
write(*,*) y
i=i+1
end do
end program iteracion_condicional
En este caso, la salida del programa en pantalla, muestra hasta el n umero 1349.293.
Esto ocurre as porque cuando y fue mayor que 1000, se terminaron de ejecutar las sen-
tencias correspondientes a esta iteracion, y luego se ejecutaron las que vienen despues
de end do. Es decir, cuando y se torna mayor que 1000, la ejecucion de las sentencias
no se interrumpe ah mismo, sino hasta que la iteracion termina (las sentencias a re-
petir se ejecutan por completo). Por esta razon, a pesar de que 1349.293 es mayor que
1000, igual fue mostrado en pantalla.
Ademas, notese que la variable i desempe na el mismo papel que en el ejemplo anterior
a este: nos permite saber el n umero de iteracion en que se encuentra (es un contador).
En el ejemplo anterior, el incremento de la variable i no es automatico como en una
iteracion con contador, y por eso se tuvo que agregar al nal de la sentencias a repetir,
la lnea i=i+1. De esto, podemos decir que aunque utilizemos iteraciones condicio-
nales tenemos la posibilidad, al igual que en la estructura iterativa con contador, de
disponer de un contador.
22
Parte IV
Funciones intrnsecas, funciones y
subrutinas
8. Funciones intrnsecas
Hasta ahora solo hemos visto que para manejar n umeros, disponemos de los ope-
radores aritmeticos. Pero Fortran posee ademas, de forma intrnseca, la mayora de
las funciones matematicas. Al igual que las calculadoras, para poder utilizar estas
funciones en Fortran, debemos evaluarlas en un argumento. Por ejemplo, si deseamos
mostrar el valor de sen(
3,14
2
), debemos escribir:
program calcular_seno
write(*,*) "El valor de sen(3.14/2) es:"
write(*,*) sin(3.14/2)
end program calcular_seno
Aqu, 3,14/2 es el argumento de la funcion seno, que en Fortran se llama con el nom-
bre sin.
A continuacion se presenta una tabla con las funciones matematicas mas importantes
que posee Fortran:
Funcion Expresion Nombre en Fortran
Logaritmo en base 10 log
10
(x) o log(x) log10(x)
Logaritmo en base e ln(x) log(x)
Seno sen(x) sin(x)
Coseno cos(x) cos(x)
Tangente tan(x) tan(x)
Exponencial en base e e
x
o exp(x) exp(x)
Valor absoluto |x| abs(x)
Seno hiperbolico senh(x) sinh(x)
Coseno hiperbolico cosh(x) cosh(x)
Con x siendo un n umero real de simple precision. En el caso de necesitarse un re-
sultado con doble precision, basta con anteponer una d a cada una de las funciones
mencionadas en la tabla. Por ejemplo, si necesitamos el valor de sin(x) con mas de-
cimales, escribimos: dsin(x). Por lo menos, para estas funciones, cuando necesitamos
que estas muestren resultados con doble precision, el argumento en que las evaluamos
tambien debe ser de doble precision. A continuacion se muestran algunos ejemplos:
program exponencial
real::valor
write(*,*) "Ingrese el valor de x para evaluar e(x):"
read(*,*) valor
write(*,*) "e(x)=", exp(valor)
end program exponencial
Aqu se le pidio al usuario ingresar un valor para evaluar e
x
; la funcion exp fue evaluada
en el argumento valor. Si necesitamos obtener un valor de esta funcion pero con doble
precision, debemos hacer algunas modicaciones al programa anterior:
program dexponencial
real*8::valor
write(*,*) "Ingrese el valor de x para evaluar e(x):"
read(*,*) valor
write(*,*) "e(x)=", dexp(valor)
end program dexponencial
La variable valor en este caso, fue declarada como real con doble precision. Luego, es
evaluada en la version de doble precision de exp, es decir, dexp.
De manera similar se utilizan las otras funciones presentadas. Se coloca el nombre
de la funcion y luego, entre parentesis, escribimos el argumento. Este argumento pue-
de ser directamente un n umero como tambien puede ser una variable. Hay que recordar
nuevamente que en la mayora de los casos la precision del valor del argumento debe
ser la misma con que la funcion muestra el resultado.
Una ultima cosa que hay que destacar es que las funciones no son comandos. Es
decir, no tiene sentido colocar lo siguiente:
program sin_sentido
sinh(3.3)
end program sin_sentido
De seguro, al compilar parecera un error. Pero s tiene sentido escribir:
program con_sentido
write(*,*) sinh(3.3)
end program con_sentido
Dando como resultado la aparicion del valor de sinh(3,3) en pantalla. Este compor-
tamiento es propio de las funciones. Solo nos propocionan un valor numerico y nada
mas. Siempre deben ser utilizadas con write(*,*) o cuando deseamos dar un valor a
una variable.
9. Sentencia contains, funciones y subrutinas
Algunas veces los programas resultan demasiado largos y los algoritmos asociados
a ellos no son muy claros, o bien son muy engorrosos. Para remediar esto, podemos
descomponer al programa en partes mas peque nas que realizan tareas especcas. De
esta forma hacemos del algoritmo algo mas entendible. En la mayora de los casos,
tambien esta descomposicion hace que el programa se vea reducido en cuanto a lneas,
lo cual permite agilizar los procesos que debe realizar para entregar el resultado nal.
En el caso de las funciones, son particularmente utiles cuando deseamos calcular un
valor varias veces mediante una formula muy complicada, pero sin introducir esta
ultima nuevamente; por otra parte, las subrutinas permiten ejecutar un conjunto de
sentencias que realizan una determinada tarea, pero sin la necesidad de colocar todas
estas cada vez que necesitamos realizar la misma tarea. Para ambos casos solo basta
llamar a la funcion o subrutina. Este procedimiento solo requiere de una lnea en el
codigo. En resumen, las funciones y subrutinas permiten reducir en forma signicativa
el n umero de lneas del programa, y de esta forma se puede agilizar de forma notoria
la realizacion de las tareas que tiene que hacer. Producto de esto, el programa demo-
rara menos en entregar el resultado esperado. Adicionalmente permiten modularizar
el funcionamiento de un programa.
9.1. Sentencia contains
Antes de implementar una funcion o subrutina, debemos introducir la sentencia
contains. Esta sentencia se utiliza en la siguiente forma:
program {nombre}
...
contains
{subrutinas y/o funciones}
end program {nombre}
Al nal del codigo del programa, colocamos esta sentencia. Inmediatamente despues de
esta, comenzamos a escribir las funciones y subrutinas que se necesiten. Mas adelante
se proporcionan ejemplos del empleo de esta sentencia.
9.2. Funciones
Tal como se menciono anteriormente, las funciones permiten realizar calculos, sin
la necesidad de introducir directamente la formula en la lnea en que se requiere el
calculo. En Fortran, las funciones son de la siguiente forma:
{tipo variable} function {nombre} ({arg 1},{arg 2},...,{arg n})
{tipo variable 1}::{arg 1}
{tipo variable 2}::{arg 2}
...
{tipo variable n}::{arg n}
{sentencias a ejecutar por la funcion}
{nombre}={valor a entregar}
end function {nombre}
Donde {arg 1},{arg 2},...,{arg n} son los argumentos en que valuaremos a la
funcion, y {tipo variable} permite declarar a la funcion con cierto tipo de dato.
Podemos reemplazar esto por: integer, real, complex y sus variantes correspon-
dientes para doble precision. Ademas, se tiene que todos los tipos de los argumentos
deben ser declarados. Luego de declararlos, colocamos las sentencias que permiten
calcular el resultado que se busca. Finalmente, este valor se le asigna a una variable
que tiene el mismo nombre que la de la funcion. Esta lnea siempre debe estar an-
tes de end function (esto siempre debe ser as). Por ejemplo, si tenemos la funcion
f(x, y) = cos(x) exp(y) (una funcion de dos variables, cuya graca se encuentra en
R
3
) y deseamos evaluarla en valores que introduzca el usuario, escribimos algo similar
a lo que sigue:
program funcion_dosvariables
real::x,y
write(*,*) "Ingrese valor de x para evaluar f(x,y)":
read(*,*) x
write(*,*) "Ingrese valor de y para evaluar f(x,y)":
read(*,*) y
write(*,*) func(x,y)
contains
real function func (arg1,arg2)
real::arg1,arg2
func=cos(arg1)*exp(arg2)
end function func
end program funcion_dosvariables
Aqu colocamos inmediatamente la lnea en que a la variable con el nombre de la
funcion (func) se le asigna el valor nal. Para el siguiente ejemplo, imaginemos que no
sabemos que Fortran trae de forma intrnseca a la funcion sinh(x). Por esto, debemos
hacer empleo de su denicion, que por cierto se trata de la siguiente formula: sinh(x) =
e
x
e
x
2
. Ahora queremos hacer lo mismo que en el ejemplo anterior, pero esta vez para
seno hiperbolico:
program senohiperbolico
real::x
write(*,*) "Ingrese valor de x para evaluar sinh(x)":
read(*,*) x
write(*,*) senohip(x)
contains
real function senohip (valor)
real::valor,y
y=exp(valor)-exp(-valor)
y=y/2
senohip=y
end function func
end program senohiperbolico
De este ejemplo, podemos decir que es posible trabajar el valor nal, antes de asig-
narlo al nombre de la funcion. Ahora, si necesitaramos calcular mas veces el valor de
sinh(x) durante la ejecucion de un programa, no tendremos que escribir las tres lneas
que se necesitaron para calcularlo, sino que solamente senohip({argumento}). Esto
representa un gran ahorro de lneas en el codigo fuente del programa y adicionalmente
permite connar la tarea de calcular el valor de la sinh(x) a una funcion, mejorando
el algoritmo.
Una ultima cosa que vale la pena destacar, es que las funciones tienen el mismo
comportamiento que las funciones intrnsecas. Solo entregan un valor numerico y se
utilizan para proporcionar un valor a una variable, o si deseamos presentar inmedia-
tamente un valor en pantalla, las usamos con write(*,*).
9.3. Subrutinas
En el caso de las subrutinas, permiten resumir la ejecucion de una tarea especca
(o mas de una) en un solo comando. Las subrutinas no son funciones, pero la idea de
ambas es similar: ahorrar lneas y ayudar a ordenar el programa. El modo de crear
una subrutina es el siguiente:
subroutine {nombre} ({argumento 1},{argumento 2},...,{argumento n})
{tipo variable}::{argumento 1}
{tipo variable}::{argumento 2}
...
{tipo variable}::{argumento n}
{sentencias a ejecutar por la subrutina}
end subroutine {nombre}
Aqu, al igual que en las funciones, debemos declarar todos los tipos de dato de los
argumentos. Como las subrutinas son algo diferentes a las funciones, se emplean de
otra forma: para poder ejecutar una subrutina, debemos hacer empleo de la sentencia
call {nombre subrutina}, donde {nombre subrutina} es el nombre de la subrutina
a la cual deseamos llamar. Esta caractersica es la diferencia fundamental entre una
subrutina y una funcion. En el siguiente ejemplo se ilustra de mejor manera lo expuesto
hasta ahora:
program subrutina
real::a,b
write(*,*) "Introduzca a:"
read(*,*) a
write(*,*) "Introduzca b (distinto de cero!):"
read(*,*) b
call calculos(a,b)
write(*,*) "Listo!"
contains
subroutine calculos (x,y)
real::x,y
write(*,*) "a+b=", x+y
write(*,*) "a-b=", x-y
write(*,*) "a*b=", x*y
write(*,*) "a/b=", x/y
end subroutine calculos
end program subrutina
Este programa recoje los valores necesarios para ejecutar la subrutina calculos. Luego
de esto, calcula y muestra en pantalla la suma, resta, multiplicacion y division de los
n umeros introducidos en el orden indicado en el codigo. En este caso, la subrutina no
devolvio ning un valor al programa (como en las funciones), y presento el resultado
en pantalla inmediatamente. En el caso de que se necesitara realizar esta tarea mas
veces, no sera necesario repetir las mismas veces el codigo que hace esto, sino que
simplemente podremos llamar a la subrutina calculos con los argumentos adecuados,
lo que constituye una reduccion importante en el n umero de lneas, que respecto a un
mismo algoritmo que no utilizara esta subrutina.
10. El efecto colateral
Algo muy peculiar en Fortran, es el efecto colateral. Este efecto se produce cuan-
do modicamos el valor de una variable del programa principal (sentencias antes de
contains), dentro de una subrutina o funcion. No es conveniente hacer esto, pues
desordena el programa (y con esto, el algoritmo del mismo).
Las variables del programa principal deben ser modicadas dentro del mismo, y por
ning un motivo en funciones ni subrutinas. A continuacion se muestran dos recomen-
daciones para evitar el efecto colateral:
Los nombres de las variables dentro de una subrutina o funci on deben ser dife-
rentes a las que existen en el programa principal.
Como se dijo anteriormente, nunca modicar el valor de una variable del pro-
grama principal dentro de las sentencias de una funcion o subrutina.
De esta forma mantendremos un programa ordenado. Cabe destacar que esta es una
caracterstica propia de Fortran. En la mayora de los lenguajes de programacion, este
efecto colateral no existe; es decir, las variables dentro de funciones y modulos no se
mezclan con las del programa principal. Esto, a pesar de que existan variables tengan
el mismo nombre que las del programa principal.
A modo de comentario nal, esto evitar el efecto colateral es encarecidamente reco-
mendado por programadores que poseen gran experiencia en esto de la programacion
en Fortran, por lo que vale la pena poner en practica lo expuesto en esta seccion.

Aprendiendo A Programar en Fortran90-Jose Ojeda BASICO

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Aprendiendo A Programar en Fortran90-Jose Ojeda BASICO

Uploaded by

Copyright:

Available Formats

Aprendiendo a programar en

You might also like