manual fortran parte1
TRANSCRIPT
Facultad de Ciencias Exactas, Ingeniería y Agrimensura Universidad Nacional de Rosario
Laboratorio de Informática
Autores Laura Angelone
Ma. Alicia Morelli
Claudia Reynares
Año
2008
Manual de FORTRAN
Parte 1
Manual de FORTRAN Parte 1 – pag. 2 de 21
Tabla de contenidos
1. AMBIENTE DE PROGRAMACIÓN............................................................................................................. 3 1.1 Manejo del ambiente de programación Fortran............................................................................................. 3 Elija la pestaña General y obtendrá: .................................................................................................................... 7 1.2 Guardar el programa...................................................................................................................................... 7 1.3 Compilar el programa.................................................................................................................................... 7 1.4 Ejecutar el programa...................................................................................................................................... 7 1.5 Generar el ejecutable ..................................................................................................................................... 7
2. INTRODUCCIÓN AL LENGUAJE FORTRAN............................................................................................ 8 2.1 Qué es FORTRAN ........................................................................................................................................ 8 2.2 Estructura general de un programa FORTRAN ............................................................................................ 8 2.3 Caracteres permitidos .................................................................................................................................... 9 2.4 Palabras reservadas........................................................................................................................................ 9 2.5 Identificadores ............................................................................................................................................... 9 2.6 Tipos de Datos............................................................................................................................................... 9 2.6 Operadores aritméticos ................................................................................................................................ 11 2.7 Expresiones aritméticas ............................................................................................................................... 11 2.8 Funciones numéricas ................................................................................................................................... 12 2.9 Operaciones con caracteres ......................................................................................................................... 13 2.10 Expresiones lógicas y operadores relacionales ......................................................................................... 13
3. Sentencia de ASIGNACIÓN ......................................................................................................................... 14
4. Sentencias de ENTRADA/SALIDA sencillas ............................................................................................... 14 4.1 Sentencia WRITE................................................................................................................................... 15 4.2 Sentencia READ...................................................................................................................................... 16
5. SENTENCIAS DE CONTROL: bifurcaciones y bucles ............................................................................... 17 5.1 Bifurcaciones............................................................................................................................................... 17
5.1.1 Sentencia IF .......................................................................................................................................... 17 5.1.2 Sentencia CASE ................................................................................................................................... 19
5.3 BUCLES...................................................................................................................................................... 20 5.3.1 Bucles DO controlados por contador.................................................................................................... 21 5.3.2 Bucle DO controlados por expresión lógica ......................................................................................... 21
Manual de FORTRAN Parte 1 – pag. 3 de 21
1. Comenzando a trabajar con Fortran
1. AMBIENTE DE PROGRAMACIÓN
1.1 Manejo del ambiente de programación Fortran En este tipo de ambientes de programación se crea un espacio de trabajo y dentro del éste se abren proyectos. Cada proyecto puede estar compuesto por uno o más programas. A continuación veremos paso a paso como realizarlo. En PROGRAMAS seleccionar Compaq Visual Fortran 6.0 y luego Developer Studio
Aparece la siguiente ventana:
Ahora para crear un espacio de trabajo (Workspace), en la barra de Menú, seleccione FILE y NEW
Manual de FORTRAN Parte 1 – pag. 4 de 21
Elija la pestaña WORKSPACES para crear un Workspace En Workspace name escriba un nombre para el área de trabajo, por ejemplo trabajo1. Observe que en Location, por defecto aparece el siguiente path: C:\ProgramFiles\MicrosoftVisualStudio\MyProjects es la carpeta donde se guardarán los proyectos. Se puede cambiar en este momento. Luego hace clic en Black Workspaces y OK.
Para crear un Proyecto dentro del Workspace, elija nuevamente File -New, y seleccione la pestaña Projects y la opción Fortran Console Application.
Escribe un nombre para el Proyecto, por ej, proyecto1. En Location se posiciona en la carpeta Trabajo1, selecciona ADD to currentv workspace para agregarlo a tu área de trabajo y OK.
Manual de FORTRAN Parte 1 – pag. 5 de 21
Verá la primer ventana. Finish y aparece la segunda ventana
Seleccionar OK y el ambiente de trabajo resulta el siguiente. Donde se observa trabajo1 (Workspace) y proyecto1 files (Project)
Ahora está en condiciones para crear un programa. File New y en la pestaña File elegir la opción FORTRAN FREE FORMAT SOURCE FILE
Antes de elegir OK, en File Name: escriba el nombre al archivo (que contendrá el código fuente del programa) con extensión .F90, por ejemplo: eje1.f90. NO OLVIDAR ESCRIBIR punto f90 !!! Finalizado todos los pasos anteriores se está en el editor de texto para poder empezar a escribir el programa.
Manual de FORTRAN Parte 1 – pag. 6 de 21
Para abrir un área de trabajo existente,
deberá seguir los siguientes pasos: Debe ir al menú File, y elegir la opción Open Workspace, aparece la siguiente ventana:
En esta ventana, en Buscar en se posiciona en la carpeta de trabajo (en nuestro ejemplo trabajo1) y selecciona trabajo1.dsw. Luego elige abrir y aparece:
En esta ventana, selecciona el proyecto y el archivo deseado.
Comenzar a escribir el código fuente PROGRAM Nombre
Manual de FORTRAN Parte 1 – pag. 7 de 21
Si en la carpeta Source File, hay más de un archivo, deberá elegir cual es el ejecutable. Porque en un proyecto solo puede haber un único archivo ejecutable. Para esto, deberá hacer:
• Clic derecho sobre cada uno de los archivos que quiera excluir. • Elegir Setting y aparecerá la siguiente ventana:
Elija la pestaña General y obtendrá:
Seleccione la opción
Exclude file from build
y luego diga OK. Observe que el icono correspondiente al file eje1.f90 a cambiado.
1.2 Guardar el programa Vaya escribiendo el programa, y guarde eligiendo la opción SAVE AS (si es la primera vez que lo guarda) ó SAVE (si guarda con modificaciones).
1.3 Compilar el programa Para compilar el programa debe pulsar el botón en la parte superior de la barra de herramientas o pulse la combinación de teclas Ctrl y F7
1.4 Ejecutar el programa Para ejecutar el programa debe pulsar el botón en la parte superior de la barra de herramientas o pulse la combinación de teclas Ctrl y F5
1.5 Generar el ejecutable Para generar el .exe debe pulsar el botón o pulse F7
Manual de FORTRAN Parte 1 – pag. 8 de 21
2. INTRODUCCIÓN AL LENGUAJE FORTRAN
2.1 Qué es FORTRAN La palabra FORTRAN deriva de FORmula TRANslation. (Traductor de fórmulas). Fortran se creó y se ha desarrollado como un lenguaje especializado en cálculos técnicos y científicos. Las bibliotecas matemáticas y numéricas existentes para Fortran son probablemente las más completas y eficientes. Fortran fue el primer lenguaje científico de alto nivel utilizado en la historia de los computadores. La primera versión fue desarrollada para el IBM 704 por John Backus y colaboradores entre 1954 y 1957. Poco a poco se empezaron a desarrollar versiones mejoradas, de las cuales muchas obtuvieron Normas Internacionales ANSI (America Nacional Standard Institute) para definir un Fortran estándar aprobado por la ISO (Internacional Standards Organization). Fortran, ha evolucionado incorporando ideas de otros lenguajes más modernos. La evolución de los compiladores FORTRAN se resumen en el siguiente listado:
1958 FORTRAN I II y III 1966 FORTRAN IV o Fortran 66 – 1er. NORMA ANSI 1977 FORTRAN V o Fortran 77 - Revision NORMA ANSI 1990 FORTRAN 90 Normas ISO y ANSI 1994 Primer compilador Fortran 90 1995 FORTRAN 95 1997 FORTRAN 95 y Normas ISO y ANSI 2002 FORTRAN 2000 GNU FORTRAN versión de software Libre FORTRAN 2003 Object Oriented Programming FORTRAN 2008 (no está en Mercado) parallel processing model and BIT data type
2.2 Estructura general de un programa FORTRAN La primera y la última línea de un programa son respectivamente:
PROGRAM program_name ... END PROGRAM program_name
Es habitual obligarse a declarar todas las variables que se vayan a utilizar poniendo como segunda línea del programa con IMPLICIT NONE
Cada renglón o línea del programa pueden tener hasta 132 caracteres. Una línea puede contener varias sentencias, separadas por el carácter punto y coma (;). Las líneas de comentario empiezan por el carácter ! Se admiten comentarios al final de una sentencia ejecutable, pues el compilador ignora todo lo que aparece en una línea a continuación del carácter !, excepto si este carácter aparece en el interior de una cadena de caracteres. Ejemplos 1) PROGRAM suma ! Este programa suma dos números enteros
IMPLICIT NONE
INTEGER a,b,c ! Se definen a las variables a, b y c como enteras read(*,*) a ! Lee el valor de la variable a desde el teclado read(*,*) b ! Lee el valor de la variable b desde el teclado c = a+b ! Asigna a la variable c el resultado del valor de a más el valor de b write(*,*) c ! Escribe por pantalla el valor de la variable c
END PROGRAM ! Finaliza el programa 2) PROGRAM prod ! Éste programa lee dos números, los multiplica y muestra el resultado
IMPLICIT NONE
REAL num1,num2,resul
WRITE(*,*) 'Introduzca los números:'
READ(*,*) num1,num2
resul=num1*num2
WRITE(*,*) 'El resultado es ',resul
END PROGRAM
Manual de FORTRAN Parte 1 – pag. 9 de 21
2.3 Caracteres permitidos Los caracteres permitidos en Fortran son los siguientes:
0,1,2,3,4,5,6,7,8,9 A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z ' " ( ) + - * / : = ! & $ ; < > % ? , . (incluye blanco, punto, coma, y punto y coma)
Es importante tener en cuenta que Fortran no distingue entre mayúsculas y minúsculas.
2.4 Palabras reservadas Como todos los lenguajes de programación, Fortran, tiene palabras reservadas al lenguaje específico. Las palabras reservadas son:
CALL, CASE, CHARACTER, COMPLEX, DEFAULT, DIMENSION, DO,
END, ELSE, EXIT, FUNCTION, IF, IMPLICIT, IN, INOUT,
INTEGER, INTENT, LOGICAL,OPEN, OUT,
PARAMETER, PROGRAM,
READ, REAL, RESULT, RETURN
SAVE, SELECT, STOP, SUBROUTINE, THEN, TYPE, WHERE, WRITE
Observación: no se incluyen las funciones de biblioteca.
2.5 Identificadores Los identificadores son nombres que se utilizan para identificar programas, variables, constantes, funciones de biblioteca, funciones del usuario, etc. Los identificadores deben empezar por una letra, y pueden ir seguidos por hasta 30 caracteres (letras, dígitos y guión bajo). En los identificadores no se distingue entre mayúsculas y minúsculas. Es habitual escribir con mayúsculas las palabras clave del lenguaje (IF, DO, END, …). Para el nombre de las variables es habitual utilizar minúsculas, con la primera letra en mayúscula. Con frecuencia se unen varias palabras poniendo la primera letra en mayúscula o separándolas con un guión bajo.
Es una buena práctica usar nombres que identifiquen su uso en el programa.
2.6 Tipos de Datos Los programas en FORTRAN manejan dos objetos diferentes: las constantes y las variables. Las constantes tienen un valor fijo que se define al comienzo del programa y que no puede modificarse. Las variables pueden cambiar de valor durante la ejecución del programa. Constantes y variables deben tener tipos de dato específicos que indican al programa como almacenarlas y manejarlas. Fortran soporta los siguientes tipos de datos: INTEGER, REAL, COMPLEX, CHARACTER y LOGICAL. Las variables se declaran en la forma:
INTEGER :: i, j, hora, minutos=60
REAL :: pi=3.141592654, velocidad, valorMedio=0.
Manual de FORTRAN Parte 1 – pag. 10 de 21
Es posible inicializar las variables en el momento de declararlas. Si no se inicializan contienen basura informática y su uso resulta imprevisible. Fortran permite trabajar con constantes y variables de tipo INTEGER o REAL con distinta precisión, es decir, con distinto número de cifras o rango. Por ejemplo, si se utilizan variables INTEGER con 16 bits se pueden representar números entre -32768 y 32767; con 32 bits se pueden representar enteros entre -2147483648 y 2147483647. También las variables REAL se pueden representar con 32 ó 64 bits; en el primer caso se tienen unas 7 cifras decimales equivalentes y en el segundo caso 16. Las constantes se definen en la forma:
PARAMETER pi=3.1415927
Enteras o INTEGER Son los números enteros (precedidos del signo - si son negativos). El tipo de dato INTEGER que se desea utilizar se puede especificar en el momento de declarar la variable
INTEGER*1 Enteros de 8 bits: entre -128 y 127
INTEGER*2 Enteros de 16 bits: entre -32768 y 32767
INTEGER*4 Enteros de 32 bits: entre -2147483648 y 2147483647
Reales o REAL Son los números reales (con parte fraccionaria). Estos pueden expresarse con o sin exponente. Sin exponente es la forma normal, es decir 1.23 , -34.567 , etc. Con exponente se expresan mediante un número entero o real seguido de la letra E y de uno o dos números que indican la potencia de diez por la que se multiplica la primera parte, ejemplo: 0.0000023 puede ponerse como 0.023E-4 , 23E-7 , etc ; 45000=4.5E4 ; y así todos. Si queremos usar una variable llamada suma y que sea real escribiremos: El tipo de dato REAL que se desea utilizar se puede especificar en el momento de declarar la variable
REAL*4 Variables de simple precisión, con 24 bits para la mantisa y 8 para el exponente. Se pueden representar números decimales con unas 7 cifras, entre 10-38 y 1038. REAL*8 Variables de doble precisión, con 53 bits para la mantisa y 11 para el exponente. Se pueden representar números decimales con unas 15~16 cifras, entre 10-308 y 10308.
Lógicas o LOGICAL En Fortran hay dos constantes lógicas: .TRUE. y .FALSE. (los puntos antes y después de la correspondiente palabra son obligatorios). Las variables lógicas se declaran con la palabra LOGICAL y se les asigna valor por medio de expresiones lógicas. Las variables lógicas pueden imprimirse con la sentencia PRINT sin formato, y en este caso se imprimen como una T ó una F, precedidas normalmente por un espacio en blanco. También es posible leerlas con una sentencia READ sin formato. En este caso los puntos son opcionales y sólo se tiene en cuenta la primera letra de la palabra (es lo mismo ".F" que "F", que "FALSE" y que ".FALSO."). Caracter o CHARACTER Las cadenas de caracteres van entre "—" ó '—'. El carácter de cierre debe ser el mismo que el de apertura. En una cadena definida con "-" el apóstrofo ' se considera como tal, es decir como un carácter más de la cadena. Para las variables CHARACTER se puede declarar la longitud de la cadena que contendrán. Por ejemplo para definir tres variables caracter de longitudes (número de caracteres) 10,10 y 8 respectivamente y llamadas var1,var2 y var3 escribiremos:
CHARACTER *10 var1, var2, var3 * 8 ó CHARACTER var1 * 10,var2 * 10,var3 * 8
Otra forma puede ser: CHARACTER * 20 nombre, primerApellido, segundoApellido
que es lo mismo que CHARACTER (20) nombre, primerApellido, segundoApellido
que es lo mismo que CHARACTER nombre*20, primerApellido*20, segundoApellido*20
Manual de FORTRAN Parte 1 – pag. 11 de 21
También es posible definir una longitud general y establecer excepciones: CHARACTER(20) nombre*30, primerApellido, segundoApellido, iniciales*3 Complejas o COMPLEX Fortran 90 permite trabajar con constantes y variables complejas. Las constantes complejas se definen mediante dos constantes reales entre paréntesis, separadas por una coma:
(1.23, -3.12), (1e-02, .324e-02)
Las variables complejas se pueden combinar con los operadores +, −, *, / y **. De todos los operadores relacionales, sólo los operadores == y /= se pueden utilizar con variables complejas. También muchas funciones de biblioteca que se pueden aplicar a variables complejas, como por ejemplo SQRT, ABS, SIN, COS, LOG y EXP. Estas funciones son generales, en el sentido que su argumento puede ser una variable REAL . Otras funciones intrínsecas están especialmente dirigidas a variables complejas, como por ejemplo CONJG(c), que calcula el complejo conjugado; REAL(c) e AIMAG(c) que devuelven las partes real e imaginaria de un complejo c manteniendo la clase; CMPLX(x, KIND=k) y CMPLX(x, y, KIND=k), que convierten una o dos variables numéricas de cualquier tipo en un número complejo de la clase especificada, con parte imaginaria nula cuando sólo se da un argumento numérico. Las variables complejas pueden ser leídas con READ. Cuando no se incluye formato, las partes real e imaginaria deben ir entre paréntesis, separadas por una coma. Si la lectura es con formato no se incluye el paréntesis. En la escritura sin formato con PRINT * o WRITE (*,*) los valores complejos se muestran entre paréntesis, separados por una coma. Los valores numéricos de la parte real e imaginaria se definen como los números reales. IMPORTANTE
Fortran no obliga a declarar las variables que se van a utilizar. Realiza una convención de nombre implícita, Cuando encuentra en el programa una variable que no fue declarada le fija el tipo de dato del valor o la expresión que tiene asignada.
Es una buena práctica de programación declarar todas las variables que se usen en el programa.
Para que el compilador Fortran nos informe si existe alguna variable que no ha sido declarada se coloca la sentencia IMPLICIT NONE.
2.6 Operadores aritméticos Los operadores aritméticos binarios son: Suma (+), Resta (-), Multiplicación (*), División (/) y Potenciación (**) No se pueden poner nunca dos operadores consecutivos. Si es preciso se utilizan los paréntesis para separarlos.
2.7 Expresiones aritméticas Las expresiones aritméticas se definen mediante una combinación de variables, constantes numéricas, paréntesis, llamadas a función y operadores aritméticos. El orden de las operaciones aritméticas en una expresión es el siguiente: 1. Se evalúa en primer lugar el operador potencia (**). Si hay varios, se ejecutan de derecha a izquierda. 2. Se evalúan a continuación las multiplicaciones y divisiones. Si hay varios operadores de este tipo se evalúan de izquierda a derecha. 3. Finalmente se evalúan las sumas y restas, también de izquierda a derecha. Los paréntesis cambian el orden de realización de las operaciones: en primer lugar se realizan las operaciones del paréntesis más interior. Las operaciones se realizan con el tipo de datos de los operandos. Por ejemplo, la suma de INTEGER es un INTEGER; la división de dos INTEGER es otro INTEGER, lo que quiere decir que se trunca el cociente.
Manual de FORTRAN Parte 1 – pag. 12 de 21
Las operaciones mixtas (u operaciones en modo mixto) son operaciones entre variables o constantes de distinto tipo. Lo más habitual es combinar INTEGER con REAL. En las operaciones mixtas el dato INTEGER se convierte antes en REAL, y el resultado es de tipo REAL. Por ejemplo, 5/2 es 2, mientras que 5/2.0 es 2.5. Un caso particular interesante es el que concierne al operador potencia (**). Si el exponente es INTEGER el resultado se obtiene por multiplicación repetida. Por el contrario, si el exponente es de tipo REAL el resultado se obtiene mediante la aplicación de logaritmos; esto quiere decir que la base no puede ser un número negativo, porque los números negativos no tienen logaritmo. La prioridad de los operadores unarios es la misma que la de los operadores binarios correspondientes. A igualdad de prioridad, se trabaja de izquierda a derecha. Por ejemplo, si tomamos la igualdad a = 4.+5.**4./2. la variable a tomará el valor 316.5, mientras que para a = 4.+5.**(4./2.) la variable a tomará el valor 29. Ejemplo: PROGRAM variables
IMPLICIT NONE REAL a,b a=1/3 b=1./3. write (*,*) a, b
END PROGRAM Si bien las variables a y b son de tipo real, el resultado de la primer división es un integer (0) y el de la segunda un real (0.3333333E0). Es por ello que es muy importante el uso correcto de los tipos de variables.
2.8 Funciones numéricas Fortran dispone de funciones numéricas para evaluar las funciones matemáticas más habituales. Todas las funciones numéricas se utilizan incluyendo su nombre, seguido de los argumentos entre paréntesis y separados por comas, en alguna expresión aritmética. La función se evalúa y el resultado se incluye en dicha expresión aritmética. FORTRAN cuenta con una serie de funciones matemáticas pre-definidas llamadas “funciones intrínsecas”. Una lista de algunas de ellas (no todas) es: Función Significado
Sqrt(x) Raíz cuadrada de x
abs(x) Valor absoluto de x
sin(x) Seno de x
cos(x) Coseno de x
tan(x) Tangente de x
Asin(x) Arco seno de x
Acos(x) Arco coseno de x
Atan(x) Arco tangente de x
Exp(x) Exponencial de x
Alog(x) Logaritmo natural de x
Alog10(x) Logaritmo en base 10 de x
int(x) Parte entera de x
Nint(x) Redondea al entero más próximo
Mod(div, divis) Resto de la división entera
Manual de FORTRAN Parte 1 – pag. 13 de 21
2.9 Operaciones con caracteres Las cadenas de caracteres van entre apóstrofos o entre dobles comillas. El operador de concatenación es la doble barra //. A partir de una variable de tipo cadena de caracteres se puede extraer una subcadena por medio del carácter (:). Por ejemplo si la variable Especie tiene como valor "rinoceronte", la subcadena Especie(:4) es "rino", Especie(3:8) es "nocero" y Especie(9:) es "nte". Hay otras funciones para manejo de cadenas de caracteres, algunas de ellas son: Función Significado Tipo
argumento Tipo resultado
ACHAR(I) Carácter I del código ASCII INTEGER CHARACTER CHAR(I, kind) Carácter en posición I. El valor de retorno tiene la
clase KIND especificada por el argumento opcional INTEGER CHARACTER
LEN(str) longitud de una cadena de caracteres CHARACTER INTEGER LEN_TRIM(str) Longitud de una cadena sin contar los blancos CHARACTER INTEGER REPEAT(str, n) Formar una cadena como resultado de concatenar str
n veces CHARACTER CHARACTER
TRIM(str) Elimina los blancos que van por delante CHARACTER CHARACTER
2.10 Expresiones lógicas y operadores relacionales Las expresiones lógicas pueden ser simples o compuestas. Se llaman expresiones lógicas simples las que constan de una constante lógica (.TRUE. y .FALSE.) o de una variable lógica, o bien de una expresión relacional en la forma:
expresión1 operador_relacional expresión2
donde tanto expresión1 como expresión2 son expresiones aritméticas, de caracteres o lógicas, y operador_relacional es uno de los siguientes:
Símbolo Significado
< o .LT. Menor que > o .GT. Mayor que == o .EQ. Igual que <= o .LE. Menor o igual que >= o .GE. Mayor o igual que /= o .NE. Distinto de Cada uno de los operadores relacionales tiene dos formas, que se pueden usar indistintamente. Para comparar cadenas de caracteres se utiliza el código ASCII de cada carácter; si es necesario, la cadena más corta se completa con blancos por la derecha Las expresiones lógicas compuestas constan de dos o más expresiones lógicas combinadas mediante los operadores lógicos. Los operadores lógicos son: Operador Significado
.NOT. Negación
.AND. Conjunción lógica
.OR. Disyunción lógica Estos operadores sirven para expresar condiciones tras las cuales se hará algo o no dependiendo del resultado de evaluar la condición, que puede ser verdadero o falso. Por ejemplo: Si A y B son variables lógicas con valores .TRUE. y .FALSE. respectivamente, y hacemos C=.NOT. A , entonces C sería .FALSE
Manual de FORTRAN Parte 1 – pag. 14 de 21
Si C fuese igual a (B .AND. A) .OR. B , entonces C=.FALSE. Las equivalencias se expresan en la siguiente tabla:
A B .NOT. A .NOT. B A .AND. B A .OR. B A .EQV. B A .NEQV. B
F F V V F F V F
F V V F F V F V
V F F V F V F V
V V F F V V V F
Los operadores de relación tienen prioridad sobre los lógicos pero no sobre los aritméticos.
3. Sentencia de ASIGNACIÓN La forma general de las sentencias de asignación hace uso del operador (=) en la forma:
Variable = expresión
Si Variable es de tipo REAL y la expresión es de tipo INTEGER, el resultado de la expresión se convierte a REAL antes de hacer la asignación. En el caso contrario de que el resultado de una expresión de tipo REAL deba ser asignado a una variable INTEGER, se trunca la parte decimal o fraccional de la expresión y la parte entera se asigna a la variable INTEGER.
4. Sentencias de ENTRADA/SALIDA sencillas Fortran permite utilizar sentencias de entrada/salida muy sencillas, en las que casi todas las opciones son las de defecto. Existen otras sentencias de entrada/salida más complejas que no usaremos en este curso. La sentencia read es usada para la entrada y la sentencia write para la salida. El formato es:
read (núm_unidad, c_ f ormato) lista_de_variable
write(núm_unidad , c_formato) lista_de_variables
El número de unidad se puede referir a la salida estándar, entrada estándar o a un archivo. Nosotros dejamos por el momento *, ya que es la unidad de entrada teclado. El c_formato se refiere a un formato para manejar la alineación de los datos en pantalla. Es posible simplificar estas sentencias usando asteriscos (*) para algunos argumentos, como lo que se ha hecho en los ejemplos anteriores. A lo anterior se le conoce como una lectura/escritura de lista dirigida. read (*,*) lista_de_variables
write (*,*) lista_de_variables La primera sentencia leerá valores de la entrada estándar y asignará los valores a las variables que aparecen en la lista, y la segunda escribe la lista en la salida estándar. Ejemplos Se muestra un segmento de código de un programa de Fortran: integer m, n real x, y read (*,*) m, n read (*,*) x, y
Manual de FORTRAN Parte 1 – pag. 15 de 21
Se ingresan los datos a través de la entrada estándar (teclado), o bien, redireccionando la entrada a partir de un archivo. Un archivo de datos consiste de registros de acuerdo a los formatos válidos de Fortran. En el ejemplo, cada registro contiene un número (entero o real). Los registros están separados por espacios en blanco o comas. Por lo que una entrada válida al programa anterior puede ser: -1 100 -1.0 1e+2 O se pueden agregar comas como separadores: -1, 100 -1.0, 1e+2 Observar que la entrada en Fortran es sensible a la línea, por lo que es importante contar con el número apropiado de elementos de entrada (registros) en cada línea. Por ejemplo, si se da la siguiente entrada en una sola línea -1, 100, -1.0, 1e+2 entonces a m y a n se asignarán los valores de -1 y 100 respectivamente, pero los dos últimos valores serán descartados, dejando a x e y sin definir.
4.1 Sentencia WRITE Como ya dijimos, la sentencia WRITE permite mostrar variables y constantes en la salida estándar (consola) desde la que se está ejecutando el programa. Uso sencillo:
WRITE (*, *) lista de variables y constantes
Ejemplo: PROGRAM nombre
IMPLICIT NONE CHARACTER*20 nom WRITE(*,*) WRITE(*,*) '¿COMO TE LLAMAS?' WRITE(*,*) READ(*,*) nom WRITE(*,*) WRITE(*,*) 'HOLA ', nom WRITE(*,*)
END PROGRAM Uso MEJORADO: write(núm_unidad , c_formato) lista_de_variables Códigos comunes de formato Las letras para códigos de formato más comunes son: A - cadena de texto D - números de doble precisión, notación científica E - números reales, notación científica F - números reales, formato de punto fijo I - entero X - salto horizontal (espacio) / - salto vertical (nueva línea) Formatos Significado
Iw Constantes y variables INTEGER Fw.d Datos REAL con notación decimal Ew.d Datos REAL con notación exponencial A ó Aw Caracteres Lw Datos LOGICAL Tc, Ln, TRn Tabuladores Nx Espacios en horizontal / Espaciado vertical : Control para lectura de caracteres El código de formato F (y similarmente D y E) tiene la forma general Fw.d donde w es una constante entera indicando el ancho del campo y d es un entero constante que indica el número de dígitos significativos.
Manual de FORTRAN Parte 1 – pag. 16 de 21
Para los enteros solamente el campo de ancho es indicado, por lo que la sintaxis es Iw. En forma parecida las cadenas de caracteres pueden ser especificadas como Aw pero el campo de ancho por lo general no es usado. Si un número o cadena no llena todo el ancho del campo, se agregan espacios. Usualmente el texto será ajustado a la derecha, pero las reglas exactas varían de acuerdo a los códigos de formato. Para un espaciado horizontal, el código nX es usado. Donde n indica el número de espacios horizontales. Si n es omitido se asume n=1. Para espaciado vertical (nuevas líneas) se usa el código /. Cada diagonal corresponde a una nueva línea. Observar que cada sentencia read o write por defecto termina con un salto de línea.
Algunos Ejemplos x = 0.025 write(*,*)'x=', x write(*,’(A,F)’) 'x=', x write(*,’ (A,F5.3)’) 'x=', x write(*,’ (A,E)’) 'x=', x write(*,’ (A,E8.1)’) 'x=', x genera la siguiente salida una vez que es ejecutado:
Observación Los espacios en blanco son automáticamente puestos del lado izquierdo y que el ancho del campo por default para números tipo real es de usualmente de 14. Se puede ver también que Fortran sigue la regla de redondeo donde los dígitos del 0-4 son redondeados hacia abajo y los dígitos del 5-9 son redondeados hacia arriba.
4.2 Sentencia READ La sentencia READ hace que se adquieran ciertos valores (normalmente desde teclado) desde una o más líneas de
entrada y que se asignen a la lista de variables de la sentencia. Cuando el programa llega a una sentencia READ espera a que el usuario introduzca los valores de las variables que deben ser leídas. Por este motivo siempre es conveniente, antes de llamar a la sentencia READ, mostrar un mensaje por la consola solicitando los datos. Formato
READ (*,*) lista de variables separadas por comas Ejemplo READ (*,*) velocidad, tiempo Una línea de entrada es un conjunto de valores de distinto tipo que terminan con un carácter Intro. Una línea de entrada se puede introducir desde teclado, o se puede leer desde un archivo. Se pueden leer cadenas de caracteres poniéndolas entre comillas simples o dobles.
Manual de FORTRAN Parte 1 – pag. 17 de 21
Cada vez que se ejecuta la sentencia READ se procesa una nueva línea de datos de entrada. Los distintos datos se separan mediante comas, o mediante uno o más espacios en blanco. Si en la línea de entrada (hasta que se pulsa Intro) hay menos datos que en la lista, se continúan procesando nuevas líneas de entrada hasta obtener valores para todas las variables de la lista. Si hay más valores en la línea de entrada que variables a leer, se asignan valores a todas las variables y se ignoran los restantes valores de la línea. Ejemplo: PROGRAM separa ¡ programa que le un número real y lo separa en parte entera y fraccionaria IMPLICIT NONE REAL num, frac INTEGER ent write (*,*) 'Escribí un número real:' read (*,*)num ent=num frac=num-ent write (*,*) 'Parte entera:',ent write (*,*) 'Parte fraccionaria:',frac END PROGRAM
Observación Una sentencia READ (*, *) sola, espera a que se presione una tecla para continuar.
5. SENTENCIAS DE CONTROL: bifurcaciones y bucles En ausencia de otros tipos de indicaciones, las sentencias de un programa Fortran se ejecutan de modo secuencial, es decir cada una a continuación de la anterior. Las sentencias de control permiten modificar esta ejecución secuencial. Las principales sentencias de control corresponden a estas dos categorías:
• Bifurcaciones: Dependiendo de que se cumpla o no cierta condición, permiten ejecutar o no una parte del código, o bien permiten ejecutar alternativamente unas u otras sentencias.
• Bucles: Los bucles ejecutan repetidamente un conjunto de sentencias. Algunos bucles utilizan un contador para ejecutarlas un número determinado de veces y otros utilizan una condición de salida o de terminación.
En ambas sentencias de control las expresiones lógicas constituyen una parte importante, porque permiten controlar la ejecución de dichas sentencias.
5.1 Bifurcaciones
5.1.1 Sentencia IF La forma más sencilla de la bifurcación IF es la siguiente:
IF ( exp_logica ) THEN
bloc1
[ELSE
bloc2]
END IF
• exp_logica : es una expresión de tipo lógica • bloc#: es un conjunto de sentencias válidas Las sentencias que están dentro del bloque se ejecutan sólo si expresión_lógica es VERDADERA
Manual de FORTRAN Parte 1 – pag. 18 de 21
Ejemplos: 1) PROGRAM condicion
IMPLICIT NONE REAL a READ(*,*) a IF (a > 0) THEN
write (*,*)'Es un numero mayor a cero' ELSE
write (*,*)'Es un numero menor o igual a cero' ENDIF
END PROGRAM 2) PROGRAM condicion
IMPLICIT NONE REAL a READ(*,*) a IF (a > 0) THEN
WRITE(*,*) 'Es un numero mayor a cero' ELSE
IF (a = = 0 ) THEN WRITE(*,*) 'Es un numero igual a cero' ELSE WRITE(*,*)'Es un numero menor que cero' ENDIF
ENDIF END PROGRAM 3) PROGRAM operaciones
IMPLICIT NONE INTEGER opcion REAL a,b,res WRITE(*,*)'Ingrese dos numeros' READ(*,*) a,b WRITE(*,*) '[1] SUMA' WRITE(*,*) ‘[2] RESTA' WRITE(*,*) '[3] MULTIPLICACION' WRITE(*,*) '[4] DIVISION' WRITE(*,*) 'Ingrese su opcion: ' READ(*,*) opcion IF (opcion >=1 .AND. opcion <= 4 ) THEN
IF (opcion = = 1) THEN res=a+b End IF IF (opcion = = 2) THEN res = a-b End IF IF (opcion = = 3) THEN res=a*b End IF IF (opcion = = 4) THEN res = a/b End IF write (*,*)'El resultado es: :',res
ELSE write(*,*) 'NO HA ELEGIDO UNA OPCION VALIDA'
ENDIF END PROGRAM
Manual de FORTRAN Parte 1 – pag. 19 de 21
5.1.2 Sentencia CASE Es una estructura que permite varios casos de selección. Sólo se ejecuta el bloque de sentencias para el cual el valor de selector coincide con el valor en la lista de valores. Posteriormente se salta a la línea END SELECT. En caso de que selector no coincida con ningún caso, se ejecuta el bloque de sentencias por defecto del CASE DEFAULT (es optativo). SELECT CASE (selector)
CASE (lista_de_valores1)
Sentencias1
CASE (lista_de_valores2)
Sentencias2
CASE DEFAULT
Sentencias3
END SELECT
selector es una expresión de tipo INTEGER, CHARACTER o LOGICAL (no REAL). Los diferentes casos o situaciones para selector pueden tener la forma: : x todos los valores ≤ x x : todos los valores ≥x x : y todos los valores en el rango entre x e y, con x ≤y x tan sólo el valor x. Se puede utilizar una lista de casos comunes (que ejecutarán el mismo código) en un único CASE separándolos por comas. Ejemplo:
1)PROGRAM operaciones
IMPLICIT NONE
INTEGER opcion
REAL a,b,res
WRITE(*,*)'Ingrese dos numeros'
READ(*,*) a,b
WRITE(*,*) '[1] SUMA'
WRITE(*,*) ‘[2] RESTA'
WRITE(*,*) '[3] MULTIPLICACION'
WRITE(*,*) '[4] DIVISION'
WRITE(*,*) 'Ingrese su opcion: '
READ(*,*) opcion
SELECT CASE (opcion)
CASE ( 1 )
res=a+b
CASE ( 2 )
res=a-b
CASE ( 3 )
res=a*b
CASE ( 4 )
res=a/b
CASE DEFAULT WRITE(*,*) 'NO HA ELEGIDO UNA OPCION VALIDA'
END SELECT
WRITE(*,*)'El resultado es: :',res
END PROGRAM
2) PROGRAM signo IMPLICIT NONE
INTEGER :: N, Signo
READ (*,*) N
SELECT CASE (N)
CASE ( : -1)
Signo = -1
CASE (0)
Signo = 0
Manual de FORTRAN Parte 1 – pag. 20 de 21
CASE (1 : )
Signo = 1
END SELECT
WRITE(*,*) "el signo es = ", Signo
END PROGRAM signo
3) PROGRAM PR1
IMPLICIT NONE
integer a ! Variable
parameter b=0 ! constante
read(*,*) a
select case (a)
case (-9:9)
write(*,*) "Uno"
case (10+b:20+b)
write(*,*) "Dos"
case (25:30)
write(*,*) "Tres"
end select
end program PR1
4) PROGRAM estructura_casos
Integer mes, nb_dias
Logical aniob
...
SELECT CASE (mes)
CASE(4, 6, 9, 11)
nb_dias = 30
CASE(1, 3, 5, 7:8, 10, 12)
nb_dias = 31
CASE(2)
SELECT CASE (aniob)
CASE(.true.)
nb_dias = 29
CASE(.false.)
nb_dias = 28
END SELECT
CASE DEFAULT
print *, ’ Numero de mes invalido’
END SELECT
END PROGRAM estructura_casos
5.3 BUCLES Los bucles se utilizan para repetir la ejecución de un conjunto de sentencias un determinado número de veces o hasta que se cumpla una determinada condición. Es posible referirse a estos casos como bucles controlados por
contador o bucles controlados por expresión lógica, respectivamente. La forma general es :
DO [control_de_bucle]
bloc
END DO
• control de bucle: define las condiciones de ejecución del bucle • bloc: es un conjunto de sentencias válidas
Manual de FORTRAN Parte 1 – pag. 21 de 21
5.3.1 Bucles DO controlados por contador La primera forma de este bucle es la siguiente:
DO variable_de_control = valor_inicial, valor_final, incremento
Sentencias
END DO
El modo de ejecutarse este bucle es el siguiente: la variable_de_control toma el valor_inicial y se compara con valor_final. Las Sentencias se ejecutan si dicha variable_de_control es menor o igual que valor_final si incremento es positivo, o si variable_de_control es mayor o igual que valor_ final si incremento es negativo. Los valores inicial, final y el incremento de la variable de control se determinan antes de que el bucle comience a ejecutarse, y no deben ser modificados durante la ejecución del bucle. Si el valor de incremento no se explicita, el programa asume el valor 1. Ejemplos: DO j=2,4 se repite 3 veces con j valiendo 2, 3 y 4. DO i=10,1,-1 se repite 10 veces con i valiendo 10, 9, 8, ...., 1. DO i=2,1 no se repite nunca pues i no puede ir de 2 a 1 aumentando 1 en cada paso. Salta directamente al END DO.
PROGRAM index_do
INTEGER i, suma, n
...
suma=0
DO i=1, n, 2
suma = suma+i
END DO
...
END PROGRAM index_do
5.3.2 Bucle DO controlados por expresión lógica Se trata de un bucle que se repite MIENTRAS se verifique una condición. Se escribe de la forma: DO WHILE condición acciones
END DO
Cuando la condición deje de cumplirse, el bucle termina. Ejemplo: un bucle que muestra los números del 1 al 9 (Ojo, podría parecer que se ejecuta 10 veces, pero sólo son 9, pues cuando n=10 la condición ya no se verifica, y por lo tanto el bucle no se ejecuta. Sería distinto si en lugar de n<10 fuese n<=10). Ejemplos 1) PROGRAM muestra INTEGER n n=1 DO WHILE (n < 10) write(*,*) n n=n+1 END DO END PROGRAM muestra
2) PROGRAM iteration_while INTEGER n, suma … n = 0 suma = 0 DO WHILE (suma < 500) n = n+1 suma = suma + n END DO … END PROGRAM iteration_while