manual fortran parte1

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


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


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.


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.


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


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


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


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.


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



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


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.


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


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


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


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.


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.


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


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


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


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


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

manual fortran parte1

Documents