Algoritmo 1: convertir grados Fahrenheit a grados Celsius
Entrada: Entrada: número real f, los grados Fahrenheit.
Salida: Salida: el equivalente de f en grados Celsius.
Diagrama de flujo: flujo:
Código: Código: program convertir_fahrenheit implicit none real :: f real :: c read *, f
c = (f - 32 32) ) * 5 / 9 print *, c end program convertir_fahrenheit
Algoritmo 2: calcular el valor absoluto
Entrada: Entrada: número real x.
Salida: Salida: el valor absoluto de x.
Diagrama de flujo: flujo:
Código: 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. .false.
.false. .true.
.false.
.false. .false. .false.
.true.
.false.
.true. .true.
.true.
.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 e . x
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 2 3 4 5 6 7 8 9 10
program circulo implicit none real :: radio real, parameter :: pi = 3.14159 print *, 'Ingrese el radio del circulo' read *, radio print *, 'El perimetro es ', 2 * pi * radio print *, 'El area es ', pi * radio * radio end program circulo
En este caso, se ha declarado la constante pi con el valor π. intentara cambiar su valor, el compilador arrojaría un error.
Comentarios
Si se
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', print *, c, case ('A', 'E', print *, c, case ('b', 'c', 'k', 'l', 's', 't', print *, c, case ('B', 'C', 'K', 'L', 'S', 'T', print *, c, case ('0', '1', '5', '6', print *, c, case default print *, c, end select
'i', ' es 'I', ' es 'd', 'm', 'v', ' es 'D', 'M', 'V', ' es '2', '7', ' es
'o', 'u') una vocal minuscula' 'O', 'U') una vocal mayuscula' 'f', 'g', 'h', 'j', & 'n', 'p', 'q', 'r', & 'w', 'x', 'y', 'z') una consonante minuscula' 'F', 'G', 'H', 'J', & 'N', 'P', 'Q', 'R', & 'W', 'X', 'Y', 'Z') una consonante mayuscula' '3', '4', & '8', '9') un digito'
' es un simbolo'
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 print print print end do
*, *, *, *,
i 'Seno: ', sin(real(i)) 'Coseno: ', cos(real(i)) 'Tangente:', tan(real(i))
