Algoritmo 1: convertir grados Fahrenheit a

grados Celsius
 Entrada: número real f, los grados Fahrenheit.

 Salida: el equivalente de f en grados Celsius.

 Diagrama de flujo:

Código:

program convertir_fahrenheit
implicit none
real :: f
real :: c

read *, f

c = (f - 32) * 5 / 9

print *, c
end program convertir_fahrenheit
Algoritmo 2: calcular el valor absoluto

 Entrada: número real x.

 Salida: el valor absoluto de x.

 Diagrama de flujo:

 Código:

 program valor_absoluto
 implicit none
 real :: a, x

 read *, x

 if (x < 0) then
 a = -x
 else
 a = x
 end if

 print *, a
 end program valor_absoluto
Algoritmo 3: calcular potencia

 Entrada: número real b, número entero positivo n.

 Salida: la n-ésima potencia de b.

 Diagrama de flujo:
 Código:

 program potencia
 implicit none
 real :: base, resultado
 integer :: exponente, i

 read *, base
 read *, exponente

 resultado = 1
 do i = 1, exponente
 resultado = resultado * base
 end do

 print *, resultado
 end program potencia
Tipos de datos
Un tipo de datos es una propiedad de un conjunto de valores que
indica cuáles son los valores válidos, qué operaciones se pueden
efectuar sobre ellos y cómo son representados internamente por el
computador.

En un programa, cada variable tiene asociado un tipo. Sólo se puede

asignar valores de ese tipo a la variable.

En el lenguaje Fortran, los siguientes son los tipos de datos básicos.

Tipo entero
El tipo integer permite representar números enteros.

No todos los enteros son representables como un valor integer. El rango

de valores permitidos depende del computador, del compilador y del
sistema operativo, pero generalmente los valores permitidos están
entre -2147483648 y 2147483647.

En el código, los enteros literales se representan como una secuencia de

dígitos, precedidos por un signo opcional:

142857
-123
+1935

Sobre valores de tipo integer pueden ser aplicadas las operaciones

artiméticas y relacionales.
Tipo real
El tipo real permite representar números reales.

En el código, los reales literales se representan escribiendo las partes

entera y fraccional separadas por un punto, y precedidos por un signo
opcional:

3.141592654
-0.345

Además, se puede utilizar notación científica, indicando con una letrae la

potencia de 10 usada:

6.02e23
9.1094e-31

Estos valores son respectivamente iguales a 6,02·1023 (el número de

Avogadro) y 9,1094·10−31 (la masa del electrón en kilógramos).

No todos los números reales son representables por el tipo real.

Internamente, el computador representa los números reales usando la
representación de coma flotante, que permite expresar números de
distintos niveles de precisión. Esta representación no es exacta; todos
los números reales y las operaciones que aparecen en un programa son
aproximaciones. Por ejemplo, en muchos computadores el siguiente
código entrega como resultado 0.99999994:

print *, 41.0 * (1 / 41.0)

Sobre valores de tipo real pueden ser aplicadas las operaciones

artiméticas y relacionales.
Tipo lógico
El tipo logical permite representar los valores verdadero y falso.

En el código, los valores verdadero y falso se representan

respectivamente como:

.true.
.false.

al imprimirlos usando print, estos valores aparecen por pantalla

respectivamente como T y F.

Sobre valores de tipo logical pueden ser aplicadas sólo operaciones

lógicas.

Tipo caracter
El tipo character permite representar símbolos como letras, dígitos,
puntuación, etc.

Los caracteres literales se representan entre comillas simples:

'a'
'!'
'7'

Si se pone más de un caracter entre las comillas, se obtiene unacadena

de caracteres, que permite representar texto:

'En un lugar de La Mancha'

Ejemplo
El siguiente programa ilustra la declaración de variables de cada uno de
los tipos básicos y sus asignaciones usando valores literales:

program literales
implicit none
integer :: n
real :: x
logical :: p
character :: c

n = 142857
n = -1234

x = 3.141592654
x = 6.02e23 ! notacion cientifica

p = .true.
p = .false.

c = 'a'
c = '#'
c = '!'
end program literales
Expresiones
Una expresión es una combinación de valores y operaciones que, al
ser evaluados, entregan un valor.

Algunos elementos que pueden formar parte de una expresión son:

valores literales (como 2, 'hola', .true. o 5.7), variables, operadore
sy llamadas a funciones.

Por ejemplo, la expresión 4 * 3 - 2 entrega el valor 10 al ser evaluada.

El valor de la expresión n / 7 + 5 depende del valor que tiene la

variable n en el momento de la evaluación.

Una expresión está compuesta de otras expresiones, que son evaluadas

recursivamente hasta llegar a sus componentes más simples, que son
los literales y las variables.

Por ejemplo, en la expresión:

b * b - 4 * a * c

las subexpresiones que son evaluadas son las siguientes:

b * b
b
4 * a * c
4 * a
4
a
c

Ejercicio: ¿por qué no a * c?

Operadores
Un operador es un símbolo en una expresión que representa una
operación aplicada a los valores sobre los que actúa.

Los valores sobre los que actúa un operador se llaman operandos.

Un operador binario es el que tiene dos operandos, mientras que un
operador unario es el que tiene sólo uno.

Por ejemplo, en la expresión 2.0 + x el operador + es un operador

binario que representa la suma, y sus operandos son 2.0 y x.

Los operadores en Fortran se pueden clasificar en: aritméticos,

relacionales y lógicos.

Operadores lógicos
Los operadores lógicos tienen operandos lógicos y resultado lógico.

Los operadores lógicos son:

 .and. (en español: «y») representa la conjunción lógica;

 .or. (en español: «o») representa la disyunción lógica.
 .not. (en español: «negación») representa la negación lógica.

Los operadores .and. y .or. son binarios, mientras que .not. es unario.

La siguiente tabla muestra todos los resultados posibles de las

operaciones lógicas. Las primeras dos columnas representan los valores
de los operandos, y las siguientes tres, los resultados de las
operaciones.
p q p .and. q p .or. q .not. p

.true. .true. .true. .true. .false.

.true. .false. .false. .true.

.false. .true. .false. .true. .true.

.false. .false. .false. .false.

Operadores aritméticos
Los operadores aritméticos son los que representan operaciones
numéricas. Sus operandos pueden ser enteros o reales.

Los operadores aritméticos binarios son:

  la suma +;
 la resta -;
 la multiplicación *;
 la división /;
 la exponenciación ** («elevado a»).

El operador - también funciona como operador unario, cambiando el

signo de su operando.

Operadores relacionales
Los operadores relacionales son los que permiten comparar valores.
Sus operandos son cualquier cosa que pueda ser comparada, y sus
resultados siempre son valores lógicos.

Los operadores relacionales son:

 el igual a ==;
 el distinto a /=;
 el mayor que >;
 el mayor o igual que >=;
 el menor que <;
 el menor o igual que <=.

Precedencia de operadores
La precedencia de operadores es una regla que especifica en qué
orden deben ser evaluadas las operaciones de una expresión.

(Por escribir)

Llamadas a funciones
Una función es un tipo de operación que, en vez de estar representada
por un símbolo, tiene un nombre. Los operandos de una función se
llaman parámetros o argumentos.
Por ejemplo, la función exp tiene un parámetro real x, y entrega como
resultado ex.
Para usar la función, hay que poner el nombre de la función, y a
continuación los argumentos entre paréntesis. Esta operación se
denomina llamar a la función.

Funciones intrínsecas
Fortran provee varias funciones que son propias del lenguaje. Se les
denomina funciones intrínsecas.

Las siguientes funciones reciben un argumento real y entregan un

resultado real:

 sqrt(x): la raíz cuadrada de x.

 exp(x): la exponencial de x.
 log(x): el logaritmo natural de x.
 sin(x): el seno de x.
 cos(x): el coseno de x.

La función abs puede recibir un argumento real o entero, y entrega un

resultado del mismo tipo:

 abs(x): el valor absoluto de x.

Las siguientes funciones sirven para convertir números reales a

enteros. Se diferencian en el criterio que usan para redondear:

 int(x): trunca el número real x.

 nint(x): aproxima el número real x al entero más cercano.
 ceiling(x): aproxima el número real x hacia arriba.
 floor(x): aproxima el número real x hacia abajo.

En matemáticas y ciencias de la computación, las últimas dos funciones

se llaman respectivamente techo y piso, y se representan
como ⌈x⌉ y ⌊x⌋.

La función mod (módulo) recibe dos argumentos del mismo tipo, pero
generalmente la usaremos con argumentos enteros positivos:
  mod(a, b): entrega el resto de la división entre a y b.

Dos usos importantes de la función mod son:

1. verificar si un número n es divisible por d usando la

condiciónmod(n, d) == 0, y
2. obtener el último dígito de un número entero n usando la
expresión mod(n, 10).

Más adelante aprenderemos cómo crear nuestras propias funciones.

Estructura de un programa Fortran
Los programas en Fortran tienen la siguiente estructura:

program nombre_del_programa

implicit none

! declaraciones de variables

! código del programa

end program nombre_del_programa

El nombre del programa puede ser cualquiera, pero siempre es

conveniente pensar un nombre que represente lo que el programa hace.

Las líneas en blanco son ignoradas. Se puede agregar u omitir todas las
que se quiera.

Las palabras que son parte del lenguaje pueden ser escritas
indistintamente en mayúsculas o minúsculas. Por ejemplo, es válido
escribir PROGRAM, Program o pRoGrAm en vez de program.

El código del programa es una secuencia de sentencias (simples y de

control).

Declaración de variables
En la sección de declaración de variables, todas las variables que son
utilizadas por el programa deben ser declaradas junto con su tipo.

La sintaxis de una declaración es:

tipo :: variable

Por ejemplo, el siguiente programa declara tres variables, de las cuales

dos son reales y una entera:

program ejemplo
implicit none
real :: x
real :: y
 integer :: n

read *, x, y, n
print *, (x * x + y * y) ** n
end program ejemplo

Cuando varias variables tienen el mismo tipo, pueden ser especificadas

en la misma declaración separadas por comas. Por ejemplo, las
declaraciones de x e y en el programa de arriba pueden ser juntadas
así:

real :: x, y

Declaración de constantes
Además de las variables, que pueden cambiar de valor durante la
ejecución, es posible ponerle nombres a valores inmutables que serán
utilizados por el programa. Estos nombres se llaman constantes.

La declaración de una constante tiene la siguiente sintaxis:

tipo, parameter :: variable = valor

Por ejemplo, el siguiente programa calcula el area y el perimetro de un

circulo cuyo radio fue ingresado por el usuario:

1 program circulo
2 implicit none
3 real :: radio
4 real, parameter :: pi = 3.14159
5
6 print *, 'Ingrese el radio del circulo'
7 read *, radio
8 print *, 'El perimetro es ', 2 * pi * radio
9 print *, 'El area es ', pi * radio * radio
10 end program circulo

En este caso, se ha declarado la constante pi con el valor π. Si se

intentara cambiar su valor, el compilador arrojaría un error.

Comentarios
Un comentario es una sección del código que es ignorada por el
compilador. Un comentario puede ser utilizado por el programador para
dejar un mensaje en el código que puede ser útil para alguien que tenga
que leerlo en el futuro.

En Fortran, los comentarios comienzan con el símbolo !. Todo lo que

esté entre el ! y el final de la línea es ignorado:

! aquí puedo poner cualquier cosa

b = 15

a = 1 ! esto es un comentario

Sentencias simples en Fortran

Recordemos que una sentencia es cada una de las
instrucciones que componen un programa.

Las sentencias más simples que forman un programa son

las asignaciones, la entrada y la salida.

En un programa, cada línea de código representa una

sentencia.

Asignaciones
Las asignaciones en Fortran son representadas con la
sintaxis que ya presentamos:

variable = expresión

Salida
En Fortran, un programa puede imprimir cosas en la
pantalla usando la sentencia print.

La sintaxis es:

print *, mensaje
El mensaje puede ser cualquier un valor de cualquier tipo.
Por ejemplo, el siguiente código escribe el
mensaje Hola mundo en la pantalla:

print *, 'Hola mundo'

Una sentencia print también puede escribir varios

mensajes en la misma línea, que hay que poner separados
por comas. El ejemplo también podría haber sido escrito
así:

print *, 'Hola ', 'mundo'

A veces es conveniente usar variables y expresiones como

mensaje. Por ejemplo:

a = 2
b = 3
print *, 'La suma de ', a, ' y ', b, ' es ', a + b

Entrada
En Fortran, un programa puede leer los datos que el
usuario ingresa con el teclado usando la sentencia read.

La sintaxis es:

read *, variable

Cuando el programa llega a una sentencia read, queda

bloqueado hasta que el usuario ingrese datos y presione
enter.

El texto ingresado por el usuario debe corresponder a la

representación de un valor del tipo de la variable. Si esto
no se cumple, ocurre un error y el programa termina.

Por ejemplo, el siguiente código le pide al usuario que

ingrese los valores de a, b y c para resolver la ecuación
cuadrática:

print *, 'Ingrese a, b y c: '

read *, a
read *, b
read *, c

a, b y c deben haber sido declaradas previamente con

tipo real.

Para llenar los datos, el usuario podría tipear:

5
2.5
-3

En este caso, la variable a tomará el valor 5.0, la

variable b el valor2.5, y la variable c el valor -3.0.

También se puede leer datos escritos en una única línea.

Para eso, hay que poner todas las variables en
el read separadas por comas. Por ejemplo:

print *, 'Ingrese a, b y c: '

read *, a, b, c

En este caso, el usuario debe tipear los tres valores en la

misma línea, separados por espacios en blanco:

5 2.5 -3

Continuación de línea
Cada sentencia debe ocupar una línea de código. Sin
embargo, a veces conviene separar una sentencia en
varias líneas para hacer el programa más claro. Para
indicar que una sentencia continúa en la línea siguiente,
hay que poner un símbolo & al final de la línea:

a = 1 + x + x ** 2 + x ** 3 + &
x ** 4 + x ** 5 + &
 x ** 6 + x ** 7

En este ejemplo, la variable a toma el resultado de la

expresión1+x+x2+x3+x4+x5+x6+x7.

Sentencias de control en Fortran

Además de las sentencias simples, que son ejecutadas en
secuencia, existen sentencias de control que permiten
modificar el flujo del programa introduciendo ciclos y
condicionales.

Una secuencia de control incluye otra sentencia dentro de

sí. Por ejemplo, una sentencia condicional incluye la
sentencia que puede o no ejecutarse dependiendo de una
condición.

Al escribir las sentencias que van dentro de una sentencia

de control, se acostumbra a comenzar el renglón varias
columnas más adelante. Esto se llama indentación, y es
crucial para entender programas complejos. Para indentar,
lo típico es usar cuatro espacios. Todos los ejemplos en
esta sección están debidamente indentados.

Condicional if-then
La sentencia if-then (en español: «si-entonces») ejecuta
instrucciones sólo si se cumple una condición. Si la
condición es falsa, no se hace nada.

La sintaxis es la siguiente:

if (condición) then
! qué hacer cuando la condición es verdadera
end if

Por ejemplo, el siguente programa felicita a alguien que

aprobó la asignatura:
program aprobado
implicit none
integer :: nota

print *, 'Que nota obtuvo: '

read *, nota

if (nota >= 55) then

print *, 'Felicitaciones'
end if
end program aprobado

Condicional if-then-else
La sentencia if-then-else («si-entonces-o-si-no») decide
entre dos secuencias de instrucciones a ejecutar
dependiendo si una condición es verdadera o falsa. La
sintaxis es la siguiente:

if (condición) then
! qué hacer cuando la condición es verdadera
else
! qué hacer cuando la condición es falsa
end if

Por ejemplo, el siguiente programa recibe como entrada un

año e indica si es bisiesto o no:

program bisiesto
implicit none
integer :: year

print *, 'Ingrese el año: '

read *, year

if (mod(year, 4) == 0 .and. (mod(year, 100) /= 0)

.or. &
(mod(year, 400) == 0))
then
print *, 'El año ', year, ' es bisiesto'
else
print *, 'El año ', year, ' no es bisiesto'
end if
end program bisiesto

Condicional select-case
La sentencia select-case («seleccionar-caso») decide qué
instrucciones ejecutar dependiendo del valor de una
expresión. Es una manera abreviada de escribir
varios ifs uno después del otro.

La sintaxis es la siguiente:

select case (expresión)

case (valor1)
! qué hacer cuando expresión == valor1
case (valor2)
! qué hacer cuando expresión == valor2
...
case default
! qué hacer cuando no se cumplió
! ninguno de los caso anteriores
end select

Por ejemplo, el siguiente programa recibe un número

entero como entrada e indica si es par o impar:

program par
implicit none
integer :: n

print *, 'Ingrese un numero'

read *, n

select case (mod(n, 2))

case (0)
print *, 'El numero es par'
case (1)
print *, 'El numero es impar'
end select

end program par

En un mismo caso es posible poner varios valores

separados por comas. Por ejemplo, el siguiente programa
recibe como entrada un caracter, y lo clasifica como vocal,
consonante, dígito o símbolo:

program clasifica_letras
implicit none
character :: c

print *, 'Ingrese un caracter'

read *, c

select case (c)

case ('a', 'e', 'i', 'o', 'u')
print *, c, ' es una vocal minuscula'
case ('A', 'E', 'I', 'O', 'U')
print *, c, ' es una vocal mayuscula'
case ('b', 'c', 'd', 'f', 'g', 'h', 'j', &
'k', 'l', 'm', 'n', 'p', 'q', 'r', &
's', 't', 'v', 'w', 'x', 'y', 'z')
print *, c, ' es una consonante minuscula'
case ('B', 'C', 'D', 'F', 'G', 'H', 'J', &
'K', 'L', 'M', 'N', 'P', 'Q', 'R', &
'S', 'T', 'V', 'W', 'X', 'Y', 'Z')
print *, c, ' es una consonante mayuscula'
case ('0', '1', '2', '3', '4', &
'5', '6', '7', '8', '9')
print *, c, ' es un digito'
case default
print *, c, ' es un simbolo'
end select

end program clasifica_letras

Ciclo do-while
El ciclo do-while («hacer mientras») ejecuta una
secuencia de instrucciones mientras una condición sea
verdadera.

La sintaxis es:

do while (condición)
! qué hacer mientras la condición se cumple
end do
Por ejemplo, el siguiente código toma un número, y lo
eleva al cuadrado hasta pasar de mil:

do while (n < 1000)

n = n ** 2
end do

En general, el ciclo do while se utiliza cuando no se puede

saber de antemano cuántas veces se ejecutará un ciclo,
pero sí qué es lo que tiene que ocurrir para que se
termine.

La condición es evaluada al comienzo de cada iteración. Si

la condición deja de ser verdadera en medio de la
iteración, el ciclo no termina, sino que continúa hasta el
final. Por ejemplo, el siguiente ciclo se ejecuta tres veces,
a pesar de que la condición siempre deja de cumplirse
después de la primera asignación:

n = 2
do while (n < 10)
n = n * 6
n = n - 9
end do

Ciclo do
El ciclo do («hacer») ejecuta una secuencia de
instrucciones un número determinado de veces. Para llevar
la cuenta, utiliza unavariable de control que toma
distintos valores en cada iteración.

La sintaxis es:

do variable = inicio, final

! qué hacer para cada valor de la variable de
control
end do

En la primera iteración, la variable de control toma el

valor inicio. Al final de cada iteración, el valor de la
variable de control aumenta automáticamente. Cuando se
pasa de largo del valor final, el ciclo termina.

Por ejemplo, el siguiente programa muestra los cubos de

los números del 1 al 20:

do i = 1, 20
print *, i, i ** 3
end do

Si el valor final es menor al inicial, el ciclo nunca es

ejecutado.

Además, el ciclo do puede recibir un tercer valor que

representa el incremento de la variable de control, es
decir, en cuánto cambiará su valor después de cada
iteración.

Por ejemplo, el siguiente programa muestra los cuadrados

de los números impares menores que 100:

do i = 1, 100, 2
print *, i, sqrt(real(i))
end do

También es posible hacer ciclos que van hacia atrás:

do i = 10, 1, -1
print *, i
end do
print *, 'Feliz an~o nuevo!'

Tanto la variable de control como los valores inicial, final y

de incremento deben ser de tipo entero. La variable de
control es una variable como cualquier otra, y debe ser
declarada apropiadamente al comienzo del programa.

Un ciclo do es una manera abreviada de escribir un tipo

especial de ciclo do while. Los siguientes dos ciclos son
equivalentes (cuando inces positivo):
do i = inicio, fin, inc
print *, i
end do

i = inicio
do while (i <= fin)
print *, i
i = i + inc
end do

Salir de un ciclo
Además de las condiciones de término propias de los
ciclos do y dowhile, siempre es posible salir de un ciclo en
cualquier momento usando la sentencia exit. Lo lógico es
que sea usada dentro de un condicional, para evitar que
todos los ciclos se terminen a la primera.

Por ejemplo, en el programa para determinar si un número

es primo o no, la búsqueda de divisores puede ser
terminada prematuramente apenas se encuentra el
primero de ellos:

es_primo = .true.
do d = 2, n - 1
if (mod(n, d) == 0) then
es_primo = .false.
exit
end if
end do

Saltar a la siguiente iteración

La sentencia cycle se usa para saltar a la iteración
siguiente sin llegar al final de la que está en curso.

Por ejemplo, el siguiente programa muestra el seno, el

coseno y la tangente de los números del 1 al 30, pero
omitiendo los que terminan en 7:

do i = 1, 30
 if (mod(i, 10) == 7) then
cycle
end if

print *, i
print *, 'Seno: ', sin(real(i))
print *, 'Coseno: ', cos(real(i))
print *, 'Tangente:', tan(real(i))
end do