Manual fortran

UNIVERSIDAD NACIONAL DEL CALLAO

METODOS
COMPUTACIONALES DE
LA FISICA
Apuntes de Clase
JUVENAL TORDOCILLO PUCHUC
CALLAO-2012

Este documento fue elaborado en Word 2010, para el semestre académico 2012-B, del curso
de Métodos Computacionales de la Física, dicho curso se imparte en Facultad de Ciencias
Naturales y Matemática de la Universidad Nacional del Callao.

Dios es real
A menos que sea declarado entero.

1.1 Comenzando a programación.
La resolución de un problema científico con una computadora, tarde o temprano,
conduce a la escritura de un programa que implemente la solución del problema. Un
programa es un conjunto de instrucciones, ejecutables sobre una computadora, que
permite cumplir una función específica. Ahora bien, ¡la creación del programa no
comienza directamente en la computadora! El proceso comienza en papel diseñando un
algoritmo para resolver el problema. Un algoritmo es un conjunto de pasos (o
instrucciones) precisos, definidos y finitos que a partir de ciertos datos conducen al
resultado del problema.

Características de un algoritmo.

 preciso: el orden de realización de cada paso está especificado,
 definido: cada paso está especificado sin ambigüedad,
 finito: el resultado se obtiene en un número finito de pasos.
 entrada/salida: dispone de cero o más datos de entrada y devuelve uno o más
resultados.

1

Para describir un algoritmo utilizaremos un pseudocódigo. Un pseudocódigo es un
lenguaje de especificación de algoritmos donde las instrucciones a seguir se especifican
de forma similar a como las describiríamos con nuestras palabras.

Consideremos, como ejemplo, el diseño de un algoritmo para calcular el área de un
círculo. Nuestro primer intento, bruto pero honesto, es:

Calcular el área de un círculo.

Sin embargo, este procedimiento no es un algoritmo, por cuanto no se especifica, como
dato de entrada, cuál es el círculo a considerar ni tampoco cual es el resultado. Un mejor
procedimiento sería:

Leer el radio del círculo.
Calcular el área del círculo de radio dado.
Imprimir el área.

Sin embargo, éste procedimiento aún no es un algoritmo por cuanto la segunda
instrucción no especifica cómo se calcula el área de un círculo de radio dado.
Explicitando la fórmula matemática tenemos finalmente un algoritmo apropiado:

Leer el radio del círculo.
Tomar p = 3.141593.
Calcular área = p*radio*radio.
Imprimir el área.

Una manera complementaria de describir un algoritmo es realizar una representación
gráfica del mismo conocida como diagrama de flujo. El correspondiente diagrama de
flujo para el algoritmo anterior se ilustra en la figura 1.1.

Una vez que disponemos del algoritmo apropiado, su implementación en la
computadora requiere de un lenguaje de programación. Un lenguaje de programación es
un lenguaje utilizado para escribir programas de computadora. Como todo lenguaje,
cada lenguaje de programación tiene una sintaxis y gramática particular que debemos
aprender para poder utilizarlo. Por otra parte, si bien existen muchos lenguajes de
programación.

Para escoger, un lenguaje adecuado para problemas científicos es el denominado
lenguaje Fortran. El proceso de implementar un algoritmo en un lenguaje de
programación es llamado codificación y su resultado código o programa fuente.
Siguiendo con nuestro ejemplo, la codificación del algoritmo en el lenguaje Fortran
conduce al siguiente programa:

2

PROGRAM calcular_area
! -------------------------------------------------
! Cálculo del área de un círculo de radio dado
! -------------------------------------------------
! Declaración de variables
! -------------------------------------------------
IMPLICIT NONE
REAL :: radio ! radio del círculo
REAL :: area ! área del círculo
REAL, PARAMETER :: PI = 3.141593 ! número pi
! -------------------------------------------------
! Entrada de datos
! -------------------------------------------------
WRITE(*,*) ’Ingrese radio del círculo’
READ(*,*) radio
! -------------------------------------------------
! Calcular area
! -------------------------------------------------
area = PI*radio**2
! -------------------------------------------------
! Imprimir resultado
! -------------------------------------------------
WRITE(*,*) ’Area = ’, area
! -------------------------------------------------
! Terminar
! -------------------------------------------------
STOP
END PROGRAM calcular_area

Aún cuando no conozcamos todavía la sintaxis y gramática del Fortran, podemos
reconocer en el código anterior ciertas características básicas que se corresponden con el
algoritmo original. En particular, notemos que los nombres de las variables involucradas
son similares a la nomenclatura utilizada en nuestro algoritmo, que los datos de entrada
y salida están presentes (junto a un mecanismo para introducirlos y mostrarlos) y que el
cálculo del área se expresa en una notación similar (aunque no exactamente igual) a la
notación matemática usual. Además hemos puesto una cantidad de comentarios que
permiten comprender lo que el código realiza.

Un algoritmo es independiente del lenguaje de programación.
Si bien estamos utilizando Fortran como lenguaje de programación debemos enfatizar que un
algoritmo es independiente del lenguaje de programación que se utiliza para su codificación.
De este modo un mismo algoritmo puede ser implementado en diversos lenguajes.

3

Nuestro programa fuente, almacenado ahora en el archivo fuente area.f90, no es todavía
un programa que la computadora pueda entender directamente. Esto se debe a que
Fortran es uno más de los denominados lenguajes de alto nivel, los cuales están
diseñados para que los programadores (es decir, nosotros) puedan escribir instrucciones
con palabras similares a los lenguajes humanos (en general, como vemos en nuestro
código, en idioma inglés). En contraste, una computadora no puede entender
directamente tales lenguajes, pues las computadoras solo entienden lenguajes de
máquina donde las instrucciones se expresan en términos de los dígitos binarios 0 y 1.

De este modo, nuestro programa fuente, escrito en un lenguaje de alto nivel, debe ser
traducido a instrucciones de bajo nivel para que la computadora pueda ejecutarlo. Esto
se realiza con ayuda de un programa especial conocido como compilador. Así pues, el
compilador toma el código fuente del programa y origina un programa ejecutable que la
computadora puede entender directamente. Este proceso es denominado compilación.

Ejercicio 1.1 Compile el programa fuente del ejercicio anterior. Verifique que se
genera, efectivamente, el programa ejecutable.

Ejercicio 1.2 Verificar que el programa da resultados correctos. En particular verificar
que para un radio igual a la unidad el área que se obtiene es y que el área se
cuadruplica cuando el radio es igual a 2.

Ejercicio 1.3 Modificar el programa para que calcule el área de una elipse de
semiejes a y b.

1.2. Cuando las cosas fallan.
Tres tipos de errores se pueden presentar: errores de compilación, errores de ejecución y
errores lógicos.
Los errores de compilación se producen normalmente por un uso incorrecto de las
reglas del lenguaje de programación (típicamente errores de sintaxis). Debido a ellos el
compilador no puede generar el programa ejecutable. Por otra parte, los errores de
ejecución se producen por instrucciones que la computadora puede comprender pero no
ejecutar. En tal caso se detiene abruptamente la ejecución del programa y se imprime un
mensaje de error. Finalmente, los errores lógicos se deben a un error en la lógica del
programa. Debido a estos errores, aún cuando el compilador nos da un programa
ejecutable, el programa dará resultados incorrectos.
Todos estos tipos de errores obligan a revisar el código, originando un ciclo de
desarrollo del programa que consta de compilación, revisión y nueva compilación hasta
que resulten subsanados todos los errores.

4

1.2.1. Ejercicios

Ejercicio 1.4 Procediendo con la compilación y ejecución, identificar que tipo de
errores se producen en las siguientes situaciones con nuestro código.

a) La sentencia WRITE(*,*) ’Ingrese el radio del círculo’ del código es cambiada por
WROTE(*,*) ’Ingrese radio del círculo’.

b) Durante la ejecución se ingresa una letra cuando se pide el radio del círculo.

c) El valor de la constante PI es asignada a 2:7182818 en el código.

1.3. Estructura general de un programa Fortran
Un programa en Fortran consiste de un programa principal (main, en inglés) y
posiblemente varios subprogramas. Por el momento asumiremos que el código consta
sólo de un programa principal. La estructura del programa principal es:

PROGRAM nombre
declaraciones de tipo
sentencias ejecutables
STOP
END PROGRAM nombre

Cada línea del programa forma parte de una sentencia que describe una instrucción a ser
llevada a cabo y tales sentencias se siguen en el orden que están escritas. En general, las
sentencias se clasifican en ejecutables (las cuales realizan acciones concretas como ser
cálculos aritméticos o entrada y salida de datos) y no ejecutables (las cuales
proporcionan información sin requerir en sí ningún cómputo, como ser las declaraciones
de tipos de datos involucrados en el programa). La sentencia (no ejecutable)
PROGRAM especifica el comienzo del programa principal. La misma está seguida de
un nombre que identifica para el programa el cual no necesita ser el mismo que el de su
código fuente ni el del programa ejecutable que genera el compilador. La sentencia (no
ejecutable) END PROGRAM indica el final lógico del programa principal. La sentencia
(ejecutable) STOP detiene la ejecución del programa.

END PROGRAM y STOP.
Es importante comprender la diferencia entre estas dos sentencias. La sentencia END
PROGRAM, siendo la última sentencia del programa principal, indica al compilador la
finalización del mismo. Por su parte, la sentencia STOP detiene la ejecución del programa,
cuando éste es ejecutado, devolviendo el control al sistema operativo. Así mientras sólo puede
existir una sentencia END PROGRAM para indicar el final del programa principal, puede haber
más de una sentencia STOP y puede aparecer en cualquier parte del programa que la
necesite. Por otra parte, una sentencia STOP inmediatamente antes de una sentencia.
END PROGRAM es, en realidad, opcional, puesto que el programa terminará cuando alcance
el fin. Sin embargo su uso es recomendado para resaltar que la ejecución del programa termina
allí.

5

Una sentencia Fortran sobre una línea puede extenderse hasta 132 caracteres. Si la
sentencia es más larga ésta puede continuarse en la siguiente línea insertando al final de
la línea actual el carácter &. De esta manera una sentencia puede ser continuada sobre
40 líneas, en Fortran 95, o 256 líneas en Fortran 2003.

 Originalmente la codificación de un programa Fortran sólo podía utilizar letras
mayúsculas. En la actualidad todos los compiladores aceptan que en el programa
haya letras minúsculas. Debe tenerse presente, sin embargo, que el compilador
Fortran no distinguirá entre las letras mayúsculas y minúsculas (excepto en las
constantes literales de carácter).

 Cualquier oración precedida de un signo de exclamación ! es un comentario. Un
comentario es una indicación del programador que permite aclarar o resaltar lo
que realiza cierta parte del código. Por lo tanto los comentarios son de gran
ayuda para documentar la operación de un programa o una parte de ella y deben
usarse profusamente. Nótese que los comentarios son ignorados por el
compilador.

 Es recomendable ser consistente con cierto estilo al escribir un programa
Fortran. Aquí adoptaremos el estilo en que las instrucciones de Fortran, tales
como PROGRAM, READ, WRITE, son escritas con mayúsculas, mientras que
las variables definidas por el programador son escritas con minúsculas.
Asimismo los nombres que sean compuestos a partir de varias palabras son
unidos con el guión bajo, como, mi_primer_programa.

Por otra parte, constantes con nombres, utilizadas para valores que no cambian durante
la ejecución del programa, como ser para almacenenar el valor del número , son
escritos con mayúsculas.

1.3.1. Ejercicios

Ejercicio 1.5 Identificar y clasificar las sentencias del programa dado en el código 1.1.

Ejercicio 1.6 Indicar los errores en el siguiente programa Fortran.

PROGRAMent
* Un simple programa
integer :: ent
ent = 12
WRITE(*,*) ’El valor del entero es ’,
ent
END PROGRAM ent
STOP
6

6

2.1. Tipos de datos simples.
Los diferentes objetos de información con los que un programa puede operar se conocen
colectivamente como datos. Todos los datos tienen un tipo asociados a ellos. La
asignación de tipos a los datos permite indicar la clase de valores que pueden tomar y
las operaciones que se pueden realizar con ellos. Fortran dispone de cinco tipos de datos
simples: enteros, reales, complejos, de carácter y lógicos (siendo los cuatro primeros
datos de tipo numérico). Esta clasificación se ilustra en la figura 2.1. Por otra parte, los
datos aparecen en el programa como constantes literales, como variables o como
constantes con nombres. Una constante literal es un valor de cualquiera de los tipos de
datos que se utiliza como tal y por lo tanto permanece invariable. Una variable, en
cambio, es un dato, referido con un nombre, susceptible de ser modificado por las
acciones del programa. Una constante con nombre es un valor referenciado con un
nombre y su valor permanece fijo, es decir, no puede ser alterado por las acciones del
programa.
Existen razones tanto matemáticas como computacionales para considerar distintos
tipos de datos numéricos.
Un dato entero permite la representación exacta de un número entero en la computadora
(dentro de cierto rango). Un dato real permite la representación de un número real,
aunque tal representación no es exacta, sino aproximada.
7

7

Precisión de los datos reales.
En las computadoras personales (PC) actuales, un dato de tipo real tiene una precisión
de no más de 7 dígitos significativos y puede representar números reales en el rango de
10-38 a 1038. Este tema es abordado más adelante.

Una constante literal entera es un número entero, como ser -1, 0, 2, y por lo tanto no
puede tener parte decimal. Una constante literal real es un número real con punto
decimal, como ser 3.14159, -18.8, 0.0056.
Números muy grandes o muy pequeños se representan en notación científica en la
forma.

Donde m.n es un número decimal y la E (de exponente) significa multiplicar por 10 a la
potencia entera .
Así, por ejemplo, se codifica como 3.49E-2.

Constantes literales numéricas.

Fortran establece la diferencia entre constantes literales enteras y reales por la presencia o
ausencia del punto decimal, respectivamente. Estas dos formas no son intercambiables puesto
que se almacenan y procesan de forma diferente en la computadora.
Por razones de claridad y estilo es conveniente utilizar el cero explícitamente al escribir
constante reales sin parte fraccionaria con parte entera nula. Así escribimos 11.0 en vez de 11.
y 0.2 en vez de .2. También resulta conveniente codificar el cero real como 0.0.

Un dato de tipo complejo permite representar un número complejo mediante un par
ordenado de datos reales: uno que representa la parte real, y otro, la parte imaginaria del
número complejo. Una constante literal compleja consiste un par ordenado de
constantes literales reales encerradas entre paréntesis y separadas por una coma. Por
ejemplo (3.5, 4.0) corresponde al número complejo con parte real 3.5 y parte imaginaria
4.0.

Un dato tipo carácter permite representar caracteres alfanuméricos, esto es letras (a, b,
A, B, etc.) y dígitos (tal como 6), y caracteres especiales (tales como $, &, *, el espacio
en blanco, etc.). Una constante literal de carácter consiste en una secuencia de caracteres
encerradas entre apóstrofes (comillas sencillas), por ejemplo:
’AbC’, o comillas dobles, "AbC" por ejemplo.

Finalmente, un dato de tipo lógico es un dato que solo puede tomar un valor entre dos
valores posibles: verdadero o falso. Sus valores literales se codifican en Fortran como
.TRUE. y .FALSE. respectivamente.

Las variables son los datos de un programa cuyo valores pueden cambiar durante la
ejecución del mismo. Existen tantos tipos de variables como tipos de datos diferentes.
Una variable, en realidad, es una región dada en la memoria de la computadora a la cual
se le asigna un nombre simbólico. El nombre simbólico o identificador se llama nombre
de la variable mientras que el valor almacenado en la región de memoria se llama valor
de la variable. La extensión de la región que ocupa la variable en la memoria viene dada

8

por el tipo de dato asociado con ella. Una imagen mental útil de la situación es
considerar a las variables como cajas o buzones, cada una de las cuales tiene un nombre
y contiene un valor.

En Fortran los nombres de las variables sólo pueden formarse con letras (incluyendo al
guión bajo _ como un carácter válido) o números pero siempre deben comenzar con una
letra. El número máximo de caracteres que permite Fortran 95 para formar el nombre de
una variables es de 31 caracteres, aunque en Fortran 2003 el límite es de 63.

Sobre los nombres de las variables
Constituye una buena práctica de programación utilizar nombres de variables que sugieran lo que ellas
representan en el contexto del problema considerado. Esto hace al programa más legible y de más fácil
comprensión.

Antes de ser utilizadas, las variables deben ser declaradas en la sección de declaración
de tipo de variables.
Para ello se utilizan las siguientes sentencias no ejecutables de acuerdo al tipo de dato
que almacenarán:

INTEGER :: lista de variables enteras
REAL :: lista de variables reales
COMPLEX :: lista de variables complejas
CHARACTER(tamaño) :: lista de variables carácter
LOGICAL :: lista de variables lógicas

Si la lista de variables cuenta con más de un elemento, las mismas deben estar separadas
por comas. Puede también usarse una sentencia de declaración de tipo por cada variable
del programa. Esto último permite introducir un comentario para el uso que se hará en el
programa, construyendo así un útil diccionario de datos que permite comprender
fácilmente el uso dado a las variables del programa.

Declaración de variables implícita y explícita.

Fortran dispone de una (desafortunada) característica cual es la declaración implícita de tipos:
nombres de variables que comienzan con las letras en el rango a-h, o-z se consideran
variables reales, mientras que el resto, es decir las que comienza con las letras en el rango i-n,
se consideran variables enteras.
Este estilo de programación es altamente desaconsejado ya que es una fuente continua de
errores. Por el contrario, nosotros propiciamos la declaración explícita de todas las variables
utilizadas en el programa.
Mas aún, con el fin de evitar completamente la posibilidad de declaraciones implícitas
utilizamos la sentencia IMPLICIT NONE al comienzo de la declaración de tipo. Con esta
sentencia el uso de variables no declaradas generará un error de compilación.

Finalmente, las constantes con nombres permiten asignar un nombre simbólico a una
constante literal y, como tal, no podrán ser alteradas. Esto resulta útil para nombrar
números irracionales tales como p o constantes físicas como la velocidad de la luz c que
aparecen repetidamente, y también para reconfigurar valores que pueden intervenir en
un algoritmo. La declaración de una constante con nombre se realiza en su declaración
de tipo como sigue:

9

tipo, PARAMETER :: nombre = constante

2.1.1. Ejercicios

Ejercicio 2.1 La siguiente lista presenta una serie de constantes válidas o inválidas en
Fortran. Indicar si cada una de ellas es válida o inválida. En el caso que sea válida,
especificar su tipo. Si es inválida indicar porque razón.

10:0, -100;000, 123E-5; ’Es correcto’, 3:14159, ’3.14159’, ’Distancia =; 17.8E+6;
13.0^2.

Ejercicio 2.2 Escribir los siguientes números como constantes literales reales.
256; 2:56; -43000; 1012; 0:000000492; -10; -10-16.

Ejercicio 2.3 Escribir los siguientes números complejos como constantes literales
complejas.
.
Ejercicio 2.4 Indicar cuales de los siguientes son identificadores aceptables para
variables en Fortran.

gamma, j79-12, epsilon, a5, 5a, is real, is_real, r(2)19, stop, _ok.

Palabras reservadas.
En la mayoría de los lenguajes de programación las palabras que constituyen instrucciones del
lenguaje no pueden ser utilizadas como nombres de variables (se dice que son palabras
reservadas). En Fortran, sin embargo, no existen palabras reservadas y, por lo tanto, por
ejemplo, es posible dar el nombre stop a una variable. Esta forma de proceder, sin embargo, no
es recomendable porque puede introducir efectos no deseados.

Ejercicio 2.5 Escriba las declaraciones de tipo apropiadas para declarar la variables
enteras i, contador, las variables reales , la variable lógica clave y la variable
carácter mensaje (la cual tendrá un máximo de 80 caracteres).

Ejercicio 2.6 Escriba sentencias de declaración apropiadas para definir como
parámetros la velocidad de la luz en el vacío c = 2:9979_108 m/s y la constante de Plank
h = 6:6256_10-34 J s.

2.2. Sentencias de asignación.
La sentencia de asignación permite asignar (almacenar) un valor en una variable. La
operación de asignación se indica tanto en el pseudocódigo de nuestros algoritmos
como en un programa Fortran en la forma general.

Aquí el signo = no debe ser interpretado como el signo de igualdad matemático, sino
que representa la operación en la cual el valor de la expresión situada a la derecha se
almacena en la variable situada a la izquierda. Por expresión entendemos aquí un

10

conjunto de variables o constantes conectadas entre sí mediante los operadores que
permiten sus tipos.

 El tipo de dato correspondiente a la expresión debe ser el mismo tipo de dato
correspondiente a la variable.
Para tipos numéricos si éste no es el caso ciertas conversiones de tipo implícitas se
realizan (las cuales serán discutidas enseguida).

 La operación de asignación es una operación destructiva para la variable del
miembro de la izquierda, debido a que cualquier valor almacenado previamente
en dicha variable se pierde y se sustituye por el nuevo valor. Por el contrario, los
valores de cualesquiera variables que se encuentren en la expresión del miembro
de la derecha de la asignación no cambian sus valores.

En una sentencia de asignación cualquier cosa distinta de un nombre de variable en el
miembro de la izquierda conduce a una sentencia incorrecta.

Entre los tipos de expresiones que podemos considerar nos interesan especialmente las
expresiones aritméticas, las cuales son un conjunto de datos numéricos (variables y
constantes) unidos por operadores aritméticos y funciones sobre los mismos. Cuando
una expresión aritmética se evalúa el resultado es un dato numérico y por lo tanto puede
ser asignada una variable de tipo numérico a través de una sentencia de asignación
aritmética.

Los operadores aritméticos son los usuales, cuya codificación en Fortran es indicada en
la tabla 2.1.
Pero además Fortran dispone de un conjunto de funciones intrínsecas que implementan
una gran variedad de funciones matemáticas, algunas de las cuales se presentan en la
tabla 2.2. Para utilizar una función se emplea el nombre de la misma seguido por la
expresión sobre la que se va a operar (argumento) dentro de un juego de paréntesis. Por
ejemplo, la sentencia y = ABS(x) calcula el valor absoluto de x y lo asigna a y.

11

2.2.1. Ejercicios

Ejercicio 2.7 Escribir sentencias de asignación que efectúen lo siguiente:

a) Incrementar en 1 el valor actual de una variable entera n y remplazar el valor de n por
dicho incremento.
Una variable entera que se incrementa en una unidad o una cantidad constante se conoce
como contador.
b) Incrementar en x (siendo x una variable numérica) el valor de la variable numérica
suma y reemplazar el valor de suma por tal incremento. Una variable que actúa de esta
forma se conoce como un acumulador.
c) Asignar a una variable lógica el valor verdadero.
d) Intercambiar el valor de dos variables a y b del mismo tipo (Ayuda: el intercambio
requiere de una tercera variable).

Ejercicio 2.8 Considere el siguiente programa Fortran.

PROGRAM problema
IMPLICIT NONE
REAL :: x,y
y = x + 1.0
WRITE(*,*) y
STOP
END PROGRAM problema

Tabla 2.2. Funciones intrínsecas importantes proporcionadas por Fortran. El tipo del
dato del argumento y del resultado que admiten es indicado por una letra
. Un asterisco en el miembro de la derecha indica que el
resultado es del mismo tipo que el argumento.

12

¿Qué sucede al ejecutarlo varias veces? ¿A qué se debe tales resultados?

Variables no inicializadas.
Una variable en el lado derecho de una sentencia de asignación debe tener un valor antes de
que la sentencia de asignación se ejecute. Hasta que una sentencia no le de un valor a una
variable, esa variable no tendrá un valor definido. Una variable a la que no se le ha dado un
valor se dice que no se ha inicializado. Entonces si, por ejemplo, x no tiene un valor antes de
ejecutarse la sentencia y = x + 1.0, se produce un error lógico. Muchos lenguajes de
programación inicializan automáticamente sus variables numéricas en cero. Sin embargo, este
no es el caso de Fortran. Así una variable sin inicializar contendrá esencialmente un valor
espurio proveniente de lo que exista en dicho momento en la posición de memoria
correspondiente a la variable. Su uso ciertamente conducirá a una situación de error en los
datos de salida.
En Fortran 95 la inicialización de una variable puede ser realizada en tiempo de compilación
asignando su valor en la sentencia de declaración correspondiente, como ser, por ejemplo,
REAL :: x = 0.0.

2.3. Orden de precedencia de las operaciones aritméticas y conversión
implícita de tipo.

 Cuando en una expresión aparecen dos o más operadores se requiere de un orden
de precedencia de las operaciones que permita determinar el orden en que se
realizaran las operaciones. En Fortran estas reglas son las siguientes:

 Todas las subexpresiones entre paréntesis se evalúan primero. Las expresiones
con paréntesis anidados se evalúan de adentro hacia fuera: el paréntesis más
interno se evalúa primero.

 Dentro de una misma expresión o subexpresión, las funciones se evalúan
primero y luego los operadores se evalúan en el siguiente orden de prioridad:
potenciación; multiplicación y división; adición, substracción y negación.

 Los operadores en una misma expresión o subexpresión con igual nivel de
prioridad se evalúan de izquierda a derecha, con excepción de la potenciación,
que se evalúa de derecha a izquierda.

Así, por ejemplo, a + b*c/d es equivalente a a + ((b*c)/d), mientras que x**y**z es
equivalente a x**(y**z).

Cuando en una expresión aritmética los operandos tienen el mismo tipo de dato
numérico, el resultado tiene el mismo tipo que éstos. En particular, la división de dos
tipos enteros es un entero, mientras que la división de dos tipos reales es un real. Si, en
cambio, los operandos tienen tipos numéricos distintos, una conversión de tipo implícita
se aplica, llevando el tipo de uno de ellos al otro, siguiendo la siguiente dirección:
enteros se convierten a reales, reales se convierten a complejos. La excepción a esta
regla es la potenciación: cuando la potencia es un entero el cálculo es equivalente a la
multiplicación repetida (por ejemplo, con x real, x**2 = x*x)
Sin embargo, si la potencia es de otro tipo numérico el cómputo se realiza
implícitamente a través de las funciones logarítmica y exponencial (por ejemplo

13

es calculado como e2.0log x). De la misma manera una conversión de tipo implícita se
realiza cuando en una sentencia aritmética la expresión y la variable difieren en tipo
numérico, en tal caso, la expresión después de ser evaluada es convertida al tipo de la
variable a la que se asigna el valor. Ciertamente, estas conversiones implícitas, producto
de la “mezcla” de tipos en una misma expresión o sentencia debe ser consideradas con
mucho cuidado. En expresiones complejas conviene hacerlas explícitas a través de las
apropiadas funciones intrínsecas de conversión de tipo que se detallan en la tabla 2.2.

2.3.1. Ejercicios

Ejercicio 2.9 Determinar el valor de la variable real a o de la variable entera i obtenido
como resultado de cada una de las siguientes sentencias de asignación aritmética.
Indicar el orden en que son realizadas las operaciones aritméticas y las conversiones de
tipo implícitas (si existen).

a) a = 2*6 + 1
b) a = 2/3
c) a = 2.0*6.0/4.0
d) i = 2*10/4
e) i = 2*(10/4)
f) a = 2*(10/4)
g) a = 2.0*(10.0/4.0)
h) a = 2.0*(1.0e1/4.0)
i) a = 6.0*1.0/6.0
j) a = 6.0*(1.0/6.0)
k) a = 1.0/3.0 + 1.0/3.0 + 1.0/3.0
l) a = 1/3 + 1/3 + 1/3
m) a = 4.0**(3/2)
n) a = 4.0**3.0/2.0
ñ) a = 4.0**(3.0/2.0)
o) i = 19/4 + 5/4
p) a = 19/4 + 5/4
q) i = 100*(99/100)
r) i = 10**(2/3)
s) i = 10**(2.0/3.0)

Ejercicio 2.10 Supongase que las variables reales a,b,c,d,e,f y la variable entera g han
sido inicializadas con los siguientes valores:

Determine el resultado de las siguientes sentencias de asignación, indique el orden en
que se realizan las operaciones.

a) resultado = a*b+c*d+e/f**g
b) resultado = a*(b+c)*d+(e/f)**g
c) resultado = a*(b+c)*(d+e)/f**g

14

Ejercicio 2.11 Escriba sentencias de asignación aritméticas para los siguientes
expresiones matemáticas.

a)
b)
c)
d)
√

e) ( )
f) ( )

Ejercicio 2.12 Considere el siguiente programa
PROGRAM test
IMPLICIT NONE
REAL :: a,b,c
! ------------------------------------
READ(*,*) a,b
c = ( (a+b)**2 - 2.0*a*b - b**2 )/a**2
WRITE(*,*) c
! ------------------------------------
STOP
END PROGRAM test

¿Cuál sería el valor esperado de c, cualesquiera sean los valores de a y b ingresados?
Ejectue el programa ingresando los pares de valores a = 0.5, b = 888.0; a = 0.0001, b =
8888.0 y a = 0.00001, b = 88888.0. ¿A qué se debe los resultados obtenidos?.

2.4. Entrada y salida por lista.
Si se desea utilizar un conjunto de datos de entrada diferentes cada vez que se ejecuta un
programa debe proporcionarse un método para leer dichos datos. De manera similar,
para visualizar los resultados del programa debe proporcionarse un mecanismo para
darles salida. El conjunto de instrucciones para realizar estas operaciones se conocen
como sentencias de entrada/salida. En los algoritmos tales instrucciones las describimos
en pseudocódigo como.

Leer lista de variables de entrada.
Imprimir lista de variables de salida.

Existen dos modos básicos para ingresar datos en un programa: interactivo y por
archivos. Aquí solo discutiremos el primero, dejando el segundo para otra práctica. En
el modo interactivo el usuario ingresa los datos por teclado mientras ejecuta el
programa. La sentencia Fortran apropiada para ésto es.

READ(*,*) lista de variables

15

donde la lista de variables, si contiene más de un elemento, está separada por comas.
Con el fin de guiar al usuario en la entrada de datos interactiva es conveniente imprimir
un mensaje indicativo previo a la lectura de los datos. Por ejemplo,

WRITE(*,*) ’Ingrese radio del círculo’
READ(*,*) radio

Para dar salida a los datos por pantalla utilizamos la sentencia

WRITE(*,*) lista de variables

Nuevamente podemos utilizar constantes literales de carácter para indicar de que trata el
resultado obtenido. Por ejemplo,

WRITE(*,*) ’Area del círculo = ’, área

2.4.1. Ejercicios

Ejercicio 2.13 Escribir la sentencia de entrada (para leer por teclado) y la sentencia de
salida (por pantalla) para los siguientes datos:

a) 0.1E13
b) (0.0,1.0)
c) ’Hola mundo!’
d) 3 1.5 -0.6
e) .TRUE.

2.5. Implementando lo aprendido.
Los siguientes ejercicios plantean diversos problemas. Para cada uno de ellos se debe
diseñar un algoritmo apropiado el cual debe ser descrito en pseudocódigo y graficado
por su diagrama de flujo. Luego implementar dicho algoritmo como un programa
Fortran. Testear el programa utilizando datos de entrada que conducen a resultados
conocidos de antemano.

Ejercicio 2.14 Dado los tres lados a, b y c de un triángulo, calcular su área A por la
fórmula de Herón,

√
Donde

Ejercicio 2.15 Dadas las coordenadas polares ( ) de un punto en el plano , se
desea calcular sus coordenadas rectangulares (x,y) definidas por:

{

Ejercicio 2.16 Calcular el área A y el volumen V de una esfera de radio r,

,

16

Implementar el algoritmo de manera de maximizar el número de multiplicadores
utilizados.

Eficiencia de un algoritmo.
Una manera de medir la eficiencia de un algoritmo (y un programa) es contabilizar el
número de operaciones utilizadas para resolver el problema. Cuanto menor sea este
número más eficiente será el algoritmo (y el programa).

Ejercicio 2.17 La temperatura medida en grados centígrados tC puede ser convertida a
la escala Farenheit según la fórmula:

Dado un valor decimal de la temperatura en la escala Celsius se quiere obtener su valor
en la escala Fahrenheit.

Ejercicio 2.18 La magnitud de la fuerza de atracción gravitatoria entre dos masas
puntuales m1 y m2, separadas por una distancia r está dada por la fórmula.

Donde es la constante de gravitación universal. Se
desea evaluar, dada la masas de dos cuerpos y la distancia entre ellos, la fuerza de
gravitación. El resultado debe estar expresados en dinas; una dina es dimensionalmente
igual a un g cm s-2.Nótese que las unidades de una fórmula deben ser consistentes, por
lo cual, en este problema, las masas deben expresarse en gramos y la distancia en
centímetros.

3.1. Estructuras de control
Las estructuras de control permiten especificar el orden en que se ejecutaran las
instrucciones de un algoritmo. Todo algoritmo puede diseñarse combinando tres tipos
básicos de estructuras de control:
secuencial: las instrucciones se ejecutan sucesivamente una después de otra, de
selección: permite elegir entre dos conjuntos de instrucciones dependiendo del
cumplimiento (o no) de una condición, de iteración: un conjunto de instrucciones se
repite una y otra vez hasta que se cumple cierta condición.

Combinando estas tres estructuras básicas es posible producir un flujo de instrucciones
más complejo pero que aún conserve la simplicidad inherente de las mismas. La
implementación de un algoritmo en base a estos tres tipos de estructuras se conoce
como programación estructurada y este estilo de programación conduce a programas
más fáciles de escribir, leer y modificar.

17

3.2. Estructura secuencial.
La estructura de control más simple está representada por una sucesión de operaciones
donde el orden de ejecución coincide con la aparición de las instrucciones en el
algoritmo (o código del programa). La figura 3.1 ilustra el diagrama de flujo
correspondiente a esta estructura. En Fortran una estructura secuencial es simplemente
un conjunto de sentencias simples unas después de otra.

3.3. Estructura de selección.
La estructura de selección permite que dos conjuntos de instrucciones alternativas
puedan ejecutarse según se cumpla (o no) una determinada condición. El pseudocódigo
de esta estructura es descrito en la forma si . . . entonces . . . sino . . . , ya que si p es una
condición y A y B respectivos conjuntos de instrucciones, la selección se describe como
si p es verdadero entonces ejecutar las instrucciones A, sino ejecutar las instrucciones B.
Codificamos entonces esta estructura en pseudocódigo como sigue.

Si condición entonces
instrucciones para condición verdadera
sino
instrucciones para condición falsa
fin_si

El diagrama de flujo correspondiente se ilustra en la figura 3.2. En Fortran su
implementación tiene la siguiente, sintaxis:

IF (condición) THEN
sentencias para condición verdadera
ELSE
sentencias para condición falsa
ENDIF

18

Sangrado (“indentación”)
Mientras que la separación de líneas en la codificación de una estructura de control es
sintácticamente necesaria, el sangrado en los conjuntos de sentencias es opcional. Sin
embargo, la sangría favorece la legibilidad del programa y, por lo tanto, constituye una buena
práctica de programación.

La condición en la estructura de selección es especificada en Fortran por una expresión
lógica, esto es, una expresión que devuelve un dato de tipo lógico: verdadero (.TRUE.)
o falso (.FALSE.). Una expresión lógica puede formarse comparando los valores de
expresiones aritméticas utilizando operadores relacionales y pueden combinarse usando
operadores lógicos. El conjunto de operadores relacionales involucra a las relaciones de
igualdad, desigualdad y de orden, las cuales son codificadas en Fortran como se indica
en la tabla 3.1. Por otro lado, los operadores lógicos básicos son la negación, la
conjunción, la disyunción (inclusiva) y equivalencia, cuya codificación en Fortran se
indica en la tabla 3.2. El operador .NOT. indica la negación u opuesto de la expresión
lógica. Una expresión que involucra dos operandos unidos por el operador .AND. es
verdadera si ambas expresiones son verdaderas. Una expresión con el operador .OR. es
verdadera si uno cualquiera o ambos operandos son verdaderos. Finalmente en el caso
de equivalencia lógica la expresión es verdadera si ambos operandos conectados por el
operador .EQV. son ambos verdaderos.1.
Cuando en una expresión aparecen operaciones aritméticas, relacionales y lógicas, el
orden de precedencia en la evaluación de las operaciones es como sigue:

19

1. Operadores aritméticos.
2. Operadores relacionales.
3. Operadores lógicos, con prioridad: .NOT., .AND. y .OR., .EQV..

Operaciones que tienen la misma prioridad se ejecutan de izquierda a derecha. Por
supuesto, las prioridades pueden ser modificadas mediante el uso de paréntesis.
En muchas circunstancias se desea ejecutar un conjunto de instrucciones sólo si la
condición es verdadera y no ejecutar ninguna instrucción si la condición es falsa. En tal
caso, la estructura de control se simplifica, codificándose en pseudocódigo como sigue
(y con un diagrama de flujo como se indica en la figura 3.3)

Si condición entonces
instrucciones para condición verdadera
fin_si

La sintaxis correspondiente en Fortran es.

IF (condición) THEN
sentencias para condición verdadera
ENDIF

Si, además, sólo debe realizarse una sentencia ejecutable cuando la condición es
verdadera, Fortran permite codificar esta situación en un if lógico:

IF (condición) sentencia ejecutable

Otra circunstancia que se suele presentar es la necesidad de elegir entre más de una
alternativa de ejecución. En este caso podemos utilizar la estructura multicondicional
cuya lógica se puede expresar en la forma si . . . entonces sino si . . . sino . . . . El
pseudocódigo correspondiente es descrito como sigue (y su diagrama de flujo se ilustra
en la figura 3.4)

20

Si condición 1 entonces
instrucciones para condición 1 verdadera
sino si condición 2 entonces
instrucciones para condición 2 verdadera
...
sino si condición N entonces
instrucciones para condición N verdadera
sino
instrucciones para todas las condiciones falsas
fin_si

Aquí, cada condición se prueba por turno. Si la condición no se se satisface, se prueba la
siguiente, pero si la condición es verdadera, se ejecutan las instrucciones
correspondientes para tal condición y luego se va al final de la estructura. Si ninguna de
las condiciones son satisfechas se ejecutan las instrucciones especificadas en el bloque
correspondientes al sino final. Debería quedar claro entonces que para que un estructura
condicional sea eficiente sus condiciones deben ser mutuamente excluyentes. La
codificación de esta estructura en Fortran se indica a continuación.

IF (condición 1) THEN
sentencias para condición 1 verdadera
ELSEIF (condición 2) THEN
sentencias para condición 2 verdadera
...
ELSEIF (condición N) THEN
sentencias para condición N verdadera
ELSE
sentencias para todas las condiciones falsa
ENDIF

21

Consideremos, como ejemplo de una estructura de selección, el diseño e
implementación de un algoritmo para calcular las raíces de una ecuación cuadrática.

√

La naturaleza de estas raíces dependerá del signo del discriminante , lo
cual nos lleva a implementar una estructura de selección: si > 0 las raíces serán
números reales, de lo contrario serán números complejos conjugados uno del otro. Por
otra parte, al ingresar los coeficientes, deberíamos asegurarnos que el coeficiente a no es
nulo, pues, de lo contario la fórmula conduciría a una división por cero. Nuevamente,
una estructura de decisión permite verificar ésto. El pseudocódigo de nuestro algoritmo
es el siguiente.

A continuación damos una implementación de este algoritmo. Nótese que no utilizamos
variables complejas sino dos variables reales que contendrán la parte real y la parte
imaginaria de las posibles raíces complejas.

Código 3.1. Cálculo de las raíces de
PROGRAM ecuadratica
! ------------------------------------------------------------------
! Se calculan las raíces de la ecuación cuadrática ax**2+bx+c=0
! ------------------------------------------------------------------
! Declaración de tipos
! ------------------------------------------------------------------
IMPLICIT NONE
REAL :: a,b,c ! coeficientes de la ecuación
REAL :: discr ! discriminante de la ecuación
REAL :: x1,x2 ! variables para soluciones
REAL :: term, den
! ------------------------------------------------------------------
! Entrada de datos
! ------------------------------------------------------------------
WRITE(*,*) ’Ingrese coeficientes a,b,c’
READ(*,*) a,b,c
IF( a == 0 ) THEN

22

WRITE(*,*) ’La ecuación no tiene término cuadrático’
STOP
ENDIF
! ------------------------------------------------------------------
! Bloque de procesamiento y salida
! ------------------------------------------------------------------
discr = b**2 - 4.0*a*c
den = 2.0*a
term = SQRT(ABS(discr))
IF (discr >= 0 ) THEN
x1 = (-b+term)/den
x2 = (-b-term)/den
WRITE(*,*) ’x1 = ’, x1
WRITE(*,*) ’x2 = ’, x2
ELSE
x1 = -b/den
x2 = term/den
WRITE(*,*) ’x1 = (’, x1, ’ ,’, x2, ’)’
WRITE(*,*) ’x1 = (’, x1, ’ ,’, -x2, ’)’
ENDIF
! ------------------------------------------------------------------
! Terminar
! ------------------------------------------------------------------
STOP
END PROGRAM ecuadratica

3.3.1. Ejercicios

Ejercicio 3.1 Dadas las variables con los valores que se indican:
a = 2.0 d = 2.5 i = 2 f = .FALSE.
b = 5.0 e = -4.0 j = 3 t = .TRUE.
c = 10.0 k = -2
Deducir el valor lógico de cada una de las expresiones lógicas siguientes. Indicar el
orden en que se evalúan.

a) t .AND. f .OR. .FALSE.
b) a**i+b <= b/c+d
c) i/j == 2+k .AND. b/c+d >= e+c/d-a**j
d) (b*j+3.0) == (d-e) .AND. (.NOT. f)

Ejercicio 3.2 Implemente una estructura de decisión para verificar si un número es
negativo o no negativo (positivo o cero).

Ejercicio 3.3 Implemente una estructura de decisión para determinar si un número
entero es par o impar (Ayuda: utilice la función MOD(x,y), la cual devuelve el resto de
la división de x por y).

23

Ejercicio 3.4 Dada una esfera de radio R, considerando su centro como origen de
coordenadas se quiere si un punto de coordenadas (x;y; z) está dentro o fuera de la
esfera. Implemente un algoritmo para éste problema.

Ejercicio 3.5 Considérese en el plano un rectángulo dado por las coordenadas (xS,yS) de
su vértice superior izquierdo y las coordenadas (xI ,yI) de su vértice inferior derecho. Se
quiere determinar si un punto (x,y) del plano está dentro o fuera del rectángulo.

Implemente la solución en un algoritmo.

Ejercicio 3.6 Dado tres números reales distintos se desea determinar cual es el mayor.
Implemente un algoritmo apropiado (Ayuda: considere ya sea un conjunto de
estructuras de selección anidadas o bien dos estructuras de selección en secuencia).

Estructuras de selección anidadas
La sentencia que comienza en el bloque de instrucciones verdadero o falso de la
estructura de selección puede ser cualquiera, incluso otra sentencia IF-THEN-ELSE.
Cuando ésto ocurre en una o ambas bifurcaciones de la estructura, se dice que las
sentencias IF están anidadas.

Ejercicio 3.7 Compile y ejecute el siguiente programa. ¿A qué puede atribuirse el
resultado que se obtiene?

PROGRAM test_igualdad
IMPLICIT NONE
REAL :: a
a = 2.0
IF (1.0/a == 0.5) THEN
WRITE(*,*) ’1/2 es igual a 0.5’
ELSE
WRITE(*,*) ’1/2 es distinto a 0.5’
ENDIF
a = 10.0
IF (1.0/a == 0.1) THEN
WRITE(*,*) ’1/10 es igual a 0.1’
ELSE
WRITE(*,*) ’1/10 es distinto a 0.1’
ENDIF
STOP
END PROGRAM test_igualdad

Igualdad entre datos reales.
Las cantidades reales que son algebraicamente iguales pueden producir un valor lógico falso
cuando se comparan los respectivos datos reales con == ya que la mayoría de los números
reales no se almacenan exactamente en la computadora.

24

Ejercicio 3.8 Implemente un algoritmo que intercambie los valores de dos números
reales si están en orden creciente pero que no realice ninguna acción en caso contrario.

Ejercicio 3.9 Implementar el cálculo del valor absoluto de un número real con un if
lógico.

Ejercicio 3.10 Implementar una estructura multicondicional para la evaluación de la
función.

{

Ejercicio 3.11 Un examen se considera desaprobado si la nota obtenida es menor que 4
y aprobado en caso contrario. Si la nota está entre 7 y 9 (inclusive) el examen se
considera destacado, y entre 9 y 10 (inclusive) sobresaliente. Implementar un algoritmo
para indicar el estatus de un examen en base a su nota.

3.4. Estructura de iteración.
La estructura de control iterativa permite la repetición de una serie determinada de
instrucciones. Este conjunto de instrucciones a repetir se denomina bucle (loop, en
inglés) y cada repetición del mismo se denomina iteración. Podemos diferenciar dos
tipos de bucles:
Bucles donde el número de iteraciones es fijo y conocido de antemano.
Bucles donde el número de iteraciones es desconocido de antemano. En este caso el
bucle se repite mientras se cumple una determinada condición (bucles condicionales).
Para estos dos tipos de bucles disponemos de sendas formas básicas de la estructura de
control iterativa. Comencemos con un bucle cuyo número de iteraciones es conocido a
priori. La estructura iterativa, en tal caso, puede expresarse en pseudocódigo como
sigue.

Desde índice = valor inicial hasta valor final hacer
instrucciones del bucle
fin_desde

El diagrama de flujo correspondiente se ilustra en la figura 3.5.
 El índice es una variable entera que, actuando como un contador, permite
controlar el número de ejecuciones del ciclo.

 Los valor inicial y valor final son valores enteros que indican los límites entre
los que varía índice al comienzo y final del bucle.

 Está implícito que en cada iteración la variable índice toma el siguiente valor,
incrementándose en una unidad. En seguida veremos que en Fortran se puede
considerar incrementos mayores que la unidad e incluso negativos.

 El número de iteraciones del bucle es N = valor final - valor inicial +1.

25

 Dentro de las instrucciones del bucle no es legal modificar la variable índice.
Asimismo, al terminar todas las iteraciones el valor de la variable no tiene
porque tener un valor definido, por lo tanto, la utilidad de la variable índice se
limita a la estructura de iteración.

En Fortran la estructura repetitiva se codifica como sigue.

DO índice = valor inicial, valor final, incremento
sentencias del bucle
ENDDO

24

Aquí índice es una variable entera, mientras que valor inicial, valor final e incremento
pueden ser variables, constantes o expresiones enteras y pueden ser negativos. Si
incremento no se especifica se asume igual a la unidad. El número de iteraciones del
bucle está dado por
[ ]

donde [ ] denota tomar la parte entera, descartando cualquier fracción decimal. Sólo si N
es mayor que 0 se ejecutará el bucle.
Consideremos ahora los bucles condicionales. Aquí, el número de iteraciones no es
conocido a priori, sino que el bucle se repite mientras se cumple una determinada
condición. En este caso, la estructura iterativa se describe en pseudocódigo de la
siguiente forma (y su diagrama de flujo se ilustra en la figura 3.6)

26

Mientras condición hacer
instrucciones del bucle
fin_mientras

La condición se evalúa antes y después de cada iteración del bucle. Si la condición es
verdadera las instrucciones del bucle se ejecutarán y, si es falsa, el control pasa a la
instrucción siguiente al bucle.
 Si la condición es falsa cuando se ejecuta el bucle por primera vez, las
instrucciones del bucle no se ejecutarán.

 Mientas que la condición sea verdadera el bucle continuará ejecutándose
indefinidamente. Por lo tanto, para terminar el bucle, en el interior del mismo
debe tomarse alguna acción que modifique la condición de manera que su valor
pase a falso. Si la condición nunca cambia su valor se tendrá un bucle infinito, la
cual no es una situación deseable.

En Fortan un bucle condicional se codifica como sigue.

DO WHILE (condición)
sentencias del bloque
ENDDO

donde condición es una expresión lógica.
Fortran, además del DO WHILE, dispone de una estructura más general para bucles
condicionales, cuya
codificación es la siguiente:

DO
sentencias del bloque pre-condición
IF (condición) EXIT
sentencias del bloque post-condición
ENDDO
25

27

El pseudocódigo correspondiente puede ser descrito como sigue (y su diagrama de flujo
se ilustra en la figura 3.7):

Repetir
instrucciones pre-condición
Si condición terminar repetir
instrucciones post-condición
fin_repetir

Las sentencias correspondientes tanto a los bloques previo y posterior al test de la
condición son ejecutadas indefinidamente mientras la condición sea falsa. Cuando la
condición resulta verdadera la repetición es terminada y la ejecución continúa con la
sentencia que sigue a la estructura de control. Nótese que si la condición es verdadera
cuando se inicia el bucle por primera vez, las sentencias del bloque pre-condición serán
ejecutadas una vez y luego el control es transferido a la sentencia siguiente a la
estructura, sin ejecutarse ninguna de las instrucciones correspondientes al bloque
posterior a la condición.

 Un bucle condicional DO WHILE

DO WHILE (condición)
ENDDO
es equivalente a un bucle condicional general de la forma
DO
IF (.NOT. condición) EXIT
ENDDO

Esto es, la condición lógica que controla la repetición del bucle es evaluada al comienzo
del bucle y es la negación lógica a la condición que controla al bucle DO WHILE.

28

 Un bucle condicional general de la forma
DO
IF (condición) EXIT
ENDDO

repetirá las sentencias del bloque hasta que la condición se haga verdadera. Pero debido
a que la condición se verifica después de que el cuerpo del bucle se ha ejecutado, las
instrucciones correspondientes se ejecutarán al menos una vez sin importar si la
condición es verdadera o falsa. Este tipo de bucle condicional es conocido como repetir
hasta que (repeat-until).

Consideremos, como ejemplo de estructura de iteración, la determinación de la suma de
los n primeros enteros positivos, esto es, el valor de ∑ . Aquí un bucle iterativo DO
permite calcular la suma puesto el número de términos a sumar es conocido de
antemano. El siguiente pseudocódigo muestra el algoritmo que realiza la suma.

Leer n
Iniciar suma = 0
Desde i = 1 hasta n hacer
Tomar suma = suma + i
fin_desde
Escribir suma
Terminar

Nótese la inicialización a cero de la variable suma utilizada como acumulador para la
suma pedida. La implementación en Fortran es como sigue.
Código 3.2. Suma de los n primeros enteros positivos
PROGRAM sumar
! ------------------------------------------------------------------
! Se calcula la suma de los n primeros enteros positivos
! ------------------------------------------------------------------
! ------------------------------------------------------------------
IMPLICIT NONE
integer :: n ! número de términos a sumar
integer :: suma ! valor de la suma
integer :: i ! indice del bucle
! ------------------------------------------------------------------
! Entrada de datos
! ------------------------------------------------------------------
WRITE(*,*) ’Ingrese el número de enteros positivos a sumar’
READ(*,*) n
! ------------------------------------------------------------------
! Bloque de procesamiento
! ------------------------------------------------------------------
suma = 0
DO i=1,n

29

suma = suma + i
ENDDO
! ------------------------------------------------------------------
! Salida de datos
! ------------------------------------------------------------------
WRITE(*,*) ’Suma = ’, suma
! ------------------------------------------------------------------
! Terminar
! ------------------------------------------------------------------
STOP
END PROGRAM sumar

Considérese ahora el problema de determinar el primer valor n para el cual la suma
∑ .
En este problema no puede utilizarse un bucle DO ya que el número de términos a
sumar no es conocido de antemano. Es claro, entonces, que debemos utilizar un bucle
condicional, tal como se muestra en el siguiente pseudocódigo.

Iniciar n = 0
Iniciar suma = 0
Mientras suma _ 10000 hacer
Tomar n = n +1
Tomar suma = suma + n
fin_mientras
Escribir n
Terminar
La implementación en Fortran de este algoritmo se muestra a continuación.

PROGRAM sumar
! ------------------------------------------------------------------
! Se determina el primer valor de n para el cual la suma de los n
! primeros enteros positivos excede a 10000.
! ------------------------------------------------------------------
! ------------------------------------------------------------------
IMPLICIT none
INTEGER :: n ! número de términos a sumar
INTEGER :: suma ! valor de la suma
INTEGER :: limite = 10000 ! limite superior de la suma
! ------------------------------------------------------------------
! Bloque de procesamiento
! ------------------------------------------------------------------
suma = 0
n=0
DO WHILE (suma <= limite)
n = n +1
suma = suma + n
ENDDO
! ------------------------------------------------------------------
! Salida de datos

30

! ------------------------------------------------------------------
WRITE(*,*) ’n = ’, n
! ------------------------------------------------------------------
! Terminar
! ------------------------------------------------------------------
STOP
END PROGRAM sumar

3.4.1. Ejercicios

Ejercicio 3.12 Imprimir una tabla de los cuadrados y cubos de los primeros N números
enteros positivos.
Ordenar la tabla primero en orden ascendente y luego en orden descendente.

Ejercicio 3.13 Calcular para
Inicialización de los acumuladores.
Siempre recordar inicializar a cero la variable que será utilizada para acumular una
suma repetida y a uno la variable que acumulará un producto repetido.

Ejercicio 3.14 Considérese el siguiente conjunto de bucles repetitivos anidados.

DO i=1,5
WRITE(*,*) ’Iteración externa = ’,i
DO j=1,4
WRITE(*,*) ’Iteración interna = ’,j
ENDDO
ENDDO

¿Cuantas iteraciones del bucle interno se realizan por cada iteración del bucle externo?
¿Cuántas iteraciones se realizan en total?

Ejercicio 3.15 Tabular la función para x en el intervalo [0;1] con un
√
paso (Ayuda: Notar que si [a;b] es el intervalo bajo consideración, los puntos
donde hay que evaluar f están dados por con siendo

Ejercicio 3.16 Determinar cuál es el primer valor de N para el cual la suma de los N
primeros números enteros positivos, ∑ , excede a 10 000.

Ejercicio 3.17 Reimplementar el ejercicio anterior con una estructura repetir hasta que.

31

3.5. Implementando lo aprendido.
Los siguientes ejercicios plantean diversos problemas. Diseñar un algoritmo apropiado
implementando su pseudocódigo y su diagrama de flujo correspondiente. Luego
codificarlo en un programa Fortran.

Ejercicio 3.18 Determinar si un año dado es bisiesto o no. Recordar que un año es
bisiesto si es divisible por 4, aunque si es divisible por 100 no es bisiesto, salvo si es
divisible por 400. Así, 1988 fue bisiesto, como también lo fue el año 2000, pero no
1800.
Ejercicio 3.19 Dado un conjunto de N números determinar cuántos de ellos son
negativos, positivos o cero.

Ejercicio 3.20 Calcular las soluciones de una ecuación cuadrática ax 2 +bx+c = 0.
Contemplar todas las alternativas posibles (raíces reales distintas, iguales y complejas).
Testear el programa para el siguiente conjunto de coeficientes:

a) a = 2;b = 2;c = -12 (raíces reales distintas, 2 y -3),
b) a = 2;b = 4;c = 2 (raíces reales iguales, -1),
c) a = 1;b = 0;c = 1 (raíces complejas conjugadas, i y -i).

Ejercicio 3.21 Dado un conjunto de N números reales determinar cuál es el máximo, el
mínimo y la media aritmética del conjunto.

Ejercicio 3.22 El máximo común divisor, mcd, (a,b) de dos número enteros positivos a
y b, con , puede ser calculado por el algoritmo de Euclides, según el cual el
mcd es igual al último resto no nulo que se obtiene por aplicación sucesiva de la
división entera entre el divisor y el resto del paso anterior. Esto es,

Implementar este algoritmo para calcular el máximo común divisor de dos números
enteros cualesquiera dados, contemplando la posibilidad de que alguno de ellos, o
ambos, sea negativo o cero (Ayuda: | || | | |y no está
definido). Verificar el programa calculando (25950,1095) = 15, (252,-1324) = 4.

Ejercicio 3.23 La fecha del domingo de Pascua corresponde al primer domingo después
de la primera luna llena que sigue al equinocio de primavera en el hemisferio norte. Los
siguientes cálculos permiten conocer esta fecha para un año comprendido entre 1900 y
2099:
a = MOD(año,19)
b = MOD(año,4)
c = MOD(año,7)
d = MOD(19*a+24,30)
e = MOD(2*b+4*c+6*d+5,7)
n = 22+d+e
Donde n indica el número de días del mes de marzo (o abril si n es superior a 31)
correspondiente al domingo de Pascua. Realizar un programa que determine esta fecha
para un año dado y comprobar que para el 2010, el domingo de Pascua corresponde al 4
de abril.

32

Ejercicio 3.24 Calcular para la siguiente expresión

Considerar tantos términos como sean necesarios para que el error cometido en la
aproximación finita sea menor que cierta tolerancia prescrita (digamos 10-8).
Observación: Testear el programa tanto con valores pequeños como con valores muy
grandes. Comentar los resultados obtenidos.

Ejercicio 3. 25 hacer un programa que ingresa 15 Notas y determinar el promedio,
máxima nota, mínima nota.

Ejercicio 3.26 Del ejercicio anterior hacer un programa si la nota obtenida es mala (0-
10), regular (11-14) y buena (15-20).

Ejercicio 3.26 En la ecuación cubica general del tercer grado

Poniendo , obtenemos una ecuación cubica sin términos cuadráticos,
cuyas raíces son las de la primera, incrementadas en . Alcanza, pues, con
considerar las ecuaciones cubicas del tipo

donde, para simplificar, supondremos que p y q son números reales. Se sigue entonces
del teorema fundamental del algebra que esta ecuación tiene o bien una única raíz real, o
bien tres raíces reales (pudiendo coincidir dos de ellas). Tales raíces reales pueden ser
calculadas como sigue. Sea

El discriminate de la ecuación cubica. Si entonces existe una única raíz real,
dada por donde
( √ )| √ | , ( √ )| √ |
Si , tendremos tres raíces reales(siendo al menos dos iguales), , dadas
por
,

donde
( )| |

Finalmente, si , habrá tres raíces reales (distintas) , dadas por

( ) , ( ) , ( )

Donde

33

√ ,

Teniendo en cuenta lo anterior implemente un algoritmo (y su programa) para calcular
las raíces reales de las ecuaciones cúbicas del tipo . Compruebe el
programa con los siguientes casos triviales:

, ,
Finalmente, encuentre las raíces reales de la ecuación

Finalmente encuentre las raíces reales de la ecuación

(Rpta: Redondeado a cinco decimales, las raíces son ), ,

34

Manual fortran

Más contenido relacionado

La actualidad más candente (20)

Destacado (17)

Similar a Manual fortran (20)

Manual fortran