Fortran. Fórmula Translación (página 2)

A mediados de 1954 fue terminada una especificación del borrador para The IBM Mathematical Formula Translating System. El primer manual para el FORTRAN apareció en octubre de 1956, porque los clientes eran reacios a usar un lenguaje de programación de alto nivel a menos que su compilador pudiera generar código cuyo desempeño fuera comparable al de un código hecho a mano en lenguaje ensamblador.

Mientras que la comunidad era escéptica en que este nuevo método pudiera posiblemente superar la codificación a mano, éste redujo por un factor de 20 al número de sentencias de programación necesarias para operar una máquina, y rápidamente ganó aceptación. 

El lenguaje fue ampliamente adoptado por los científicos para escribir programas numéricamente intensivos, que incentivó a los escritores de compiladores a producir compiladores que pudieran generar un código más rápido y más eficiente. La inclusión en el lenguaje de un tipo de datos y de la aritmética de números complejos amplió la gama de aplicaciones para las cuales el lenguaje se adaptaba especialmente e hizo al FORTRAN especialmente adecuado para aplicaciones técnicas tales como la ingeniería eléctrica.

Por 1960, las versiones de FORTRAN estaban disponibles para los computadores IBM 709, 650, 1620, y 7090.

Significativamente, era cada vez mayor la popularidad del FORTRAN estimuló a fabricantes de computadores de la competencia a proporcionar compiladores FORTRAN para sus máquinas, así que por 1963 existían más de 40 compiladores FORTRAN. Por estas razones, el FORTRAN es considerado ser el primer lenguaje de programación ampliamente usado soportado a través de una variedad de arquitecturas de computador.

El desarrollo del FORTRAN fue paralelo a la temprana evolución de la tecnología del compilador. De hecho, muchos avances en la teoría y el diseño de compiladores fueron motivados específicamente por la necesidad de generar código eficiente para los programas en FORTRAN.

0

Código FORTRAN en una tarjeta perforada, mostrando el uso especializado de las columnas 1-5, 6 y 73-80.

El primer estándar de FORTRAN se introdujo en 1962 y se llamó FORTRAN IV.

En 1966 se presentó el primer estándar ANSI (American National Standards Institute), que se conoció como FORTRAN 66. El segundo estándar ANSI, con muchas mejoras, se introdujo en 1977 (FORTRAN 77), y se convirtió en el estándar utilizado por la comunidad científica por muchos años. Incluso a la fecha es común encontrar muchos programas escritos en FORTRAN 77.

FORTRAN 77 tenía una serie de desventajas. Entre ellas una estructura muy rígida adaptada al uso de tarjetas perforadas ("forma fija"), que requería que ciertas columnas tuvieran usos específicos. Además, no permitía un uso dinámico de la memoria y no permitía realizar operaciones entre arreglos de números. Para mejorar esta situación, en 1990 se presentó un tercer estándar ANSI conocido como FORTRAN 90, que contenía muchas nuevas características y permitía una programación más estructurada. Una serie de cambios menores se presentaron en 1995 (FORTRAN 95), y actualmente se trabaja en un nuevo estándar ANSI (FORTRAN 2003).

VERSIONES DE FORTRAN

• FORTRAN II

• FORTRAN III

• FORTRAN IV

• FORTRAN 77

• FORTRAN 90

• FORTRAN 95

• FORTRAN 2003

• FORTRAN 2005

• FORTRAN 2008

• FORTRAN 2010

FORTRAN II

IBM FORTRAN II apareció en 1958. La mejora principal era apoyar , al permitir por escrito subrutinas de usuario y las funciones que volvió valores, con parámetros pasados por referencia.

 La declaración común, siempre una forma de subrutinas para el acceso común (o mundial) variables. 

• Subrutina, FUNCIÓN y END

• CALL y RETORNO

• COMÚN

En los próximos años, FORTRAN II también añadió soporte estos tipos de datos  DOBLE PRECISIÓN y COMPLEJO.

Sencillo programa Fortran II

Este programa, por la fórmula de Herón, lee una tarjeta de datos que contiene tres dígitos enteros 5 A, B y C como entrada. Si A, B y C no pueden representar a los lados de un triángulo en la geometría plana, entonces el programa de ejecución de la voluntad termina con un código de error de "STOP 1".  De lo contrario, una línea de salida será impreso que indica los valores de entrada para A, B y C, seguidos de la superficie calculada del triángulo como un número de punto flotante con 2 dígitos después del punto decimal.

ZONA C de un triángulo con un cuadrado estándar ROOT FUNCIÓN

DE ENTRADA C – LECTOR TARJETA UNIDAD 5, entero de entrada de salida C- IMPRESORA unidad de línea 6, la producción real

C ENTRADA PANTALLA DE ERROR ERROR DE SALIDA CÓDIGO 1 EN CONTROL DE LISTADO DE EMPLEO

LEER TAPE INPUT 5, 501, IA, IB, IC

501 FORMATO (3I5)

IA C, IB y IC no podrá ser negativo

C Además, la suma de dos lados de un triángulo

C es mayor que el tercer lado, por lo que VERIFIQUE QUE TAMBIÉN

SI (IA) 777, 777, 701 701 IF (IB) 777, 777, 702 702 IF (IC) 777, 777, 703 703 IF (IA+IB-IC) 777 777 704 704 IF (IA+IC-IB) 777 777 705 705 IF (IB+IC-IA) 777 777 799 777 PARADA 1

C USO DE LA FORMULA HERON calculamos la

ZONA C del triángulo

799 S = FLOATF (IA + IB + IC) / 2.0 AREA = SQRT(S * (S – FLOATF (IA)) * (S – FLOATF (IB)) *

+ (S – FLOATF (IC)))

Escribir la salida Tape 6, 601, IA, IB, IC, AREA 601 FORMATO

(4H A=, I5, 5H B=, I5, 5H C=, I5, 8H AREA=, F10.2,

+ 13H PLAZA DE UNIDADES)

PARADA

FORTRAN III

IBM también desarrolló una FORTRAN III en 1958 que permitió el código ensamblador en línea entre otras características, sin embargo, esta versión nunca fue lanzada como un producto. Al igual que el FORTRAN 704 y FORTRAN II, FORTRAN III incluye características dependientes-máquina que hizo el código escrito en ella portable de la máquina a máquina. Las primeras versiones de FORTRAN proporcionadas por otros proveedores sufrieron los mismos inconvenientes.

FORTRAN IV

A partir de 1961, como resultado de demandas de los clientes, IBM comenzó a desarrollar un FORTRAN IV que eliminaban los dependientes de las características-máquina de FORTRAN II (como leer la entrada CINTA), al tiempo que añade nuevas características como una LÓGICA tipo de datos, lógica expresiones booleanas y la lógica IF como una alternativa a la aritmética instrucción IF. FORTRAN IV fue finalmente liberado en 1962, primero para el IBM 7030 ("Stretch") equipo, seguido por las versiones para el IBM 7090 y IBM 7094.

En 1965, Fortran IV se suponía que era el "estándar" y de conformidad con las normas de la Asociación Americana X3.4.3 Grupo de Trabajo de FORTRAN.

FORTRAN 66

Tal vez el acontecimiento más significativo en la historia temprana de FORTRAN fue la decisión de la Asociación de Estándares Americanos (ahora ANSI) para formar un comité para desarrollar un "American Standard Fortran." El resultado de dos normas, aprobada en marzo de 1966, define dos idiomas, FORTRAN (basado en FORTRAN IV, que había servido de factor estándar), y de base FORTRAN (basado en FORTRAN II, pero despojado de su cargo funciones-máquina). El FORTRAN definido por la norma empezó a ser conocido como FORTRAN 66 (aunque muchos siguieron refiriéndose a ella como FORTRAN IV, el idioma en que se basa en gran medida el estándar). FORTRAN 66 efectivamente se convirtió en el primer estándar de la industria "versión de FORTRAN. 

FORTRAN 66 incluye:

• Programa principal, subrutinas, FUNCIÓN y bloque de datos dependencias de programas

• ENTERO, REAL, DOUBLE PRECISION, COMPLEJO y LÓ

• GICA  (tipos de datos)

• COMÚN, DIMENSIÓN y EQUIVALENCIA (declaraciones)

• DATOS (declaración para especificar los valores iniciales)

• Intrínseca y EXTERIORES (por ejemplo, la biblioteca) funciones

• Asignación de declaración

• GOTO, asignado GOTO, y se calcula GOTO (declaraciones)

• Lógico IF y la aritmética (de tres vías) SI (declaraciones)

• NO (bucles)

• LEER, ESCRIBIR, RETROCESO, REWIND, y ENDFILE declaraciones para secuenciales I / O

• FORMATO (declaración)

• CALL, RETORNO, PAUSA, y PARADA (declaraciones)

• Hollerith constantes en DATOS y FORMATO declaraciones, y como argumentos reales a los procedimientos

• Identificadores de hasta seis caracteres de longitud

• Las líneas de comentario

FORTRAN 77

Después del lanzamiento de FORTRAN 66 estándar, los proveedores de compiladores introdujeron una serie de extensiones a "Standard Fortran", que provocó ANSI en 1969 para comenzar a trabajar en la revisión de la norma de 1966. Proyectos finales de esta norma revisada y distribuida en 1977, lo que llevó a la aprobación formal de la norma FORTRAN nuevo en abril de 1978. La nueva norma, conocida como FORTRAN 77, añadió una serie de características significativas para hacer frente a muchas de las deficiencias de FORTRAN 66:

• Bloque IF y END IF declaraciones, con la opción de ELSE y ELSE IF cláusulas, para proporcionar apoyo lingüístico para mejorar la programación estructurada

• Incrementos negativos y cero cargos viaje

• ABRIR, CERRAR, y CONSULTAR declaraciones para mejora / capacidad de O

• De acceso directo / S de archivos

• IMPLICIT declaración

• CARÁCTER tipo de datos, con ampliación de las instalaciones muy a la entrada de caracteres y la producción y procesamiento de datos basado en caracteres

• PARÁMETRO declaración para especificar constantes

• GUARDE declaración de variables locales persistentes

• Nombres genéricos para las funciones intrínsecas

• Un conjunto de los intrínsecos (LGE, LGT, LLE, LLT) para léxica comparación de cadenas, basada en el ASCII secuencia de ordenación.

En esta revisión de la norma, una serie de características fuera suprimida o modificada de una manera que podría invalidar previamente los estándares y programas. (Retiro fue la única alternativa a la permitida X3J3 en ese momento, ya que el concepto de "desprecio" todavía no estaba disponible para los estándares de ANSI.) Si bien la mayoría de los 24 elementos de la lista de conflictos dirigida casos patológicos permitidos por la norma anterior, pero rara vez se usa, un pequeño número de capacidades específicas fueron removidos deliberadamente, tales como:

• Hollerith constantes y Hollerith de datos, tales como:

GREET = 12HHELLO ALLÍ!

• La lectura en una edición H (campo Hollerith) Descriptor en una especificación de formato.

• Overindexing de límites de la matriz por subíndices.

DIMENSIÓN A (10,5)

Y = A (11,1)

• Transferencia de control en el rango de un bucle DO (también conocido como "Extended Range").

Una práctica importante de extensión de FORTRAN 77 fue el lanzamiento de MIL-STD-1753 en 1978. Esta especificación, desarrollada por el Departamento de Defensa de EE.UU., estandarizado una serie de características implementadas por la mayoría de los compiladores de Fortran 77, pero no incluidas en la norma ANSI FORTRAN 77 estándar. Estas características eventualmente, deben incorporarse al Fortran 90 estándar.

• DO WHILE y END DO (declaraciones)

• INCLUYE (declaración)

• IMPLICIT NINGUNA (variante de la IMPLICIT declaración)

• Manipulación de bits funciones intrínsecas, basado en funciones similares incluidos en Industrial en tiempo real Fortran (ANSI / ISA S61.1 (1976))

El IEEE 1003.9 POSIX estándar, lanzado en 1991, proporcionó un medio simple para Fortran-77 programadores para emitir las llamadas al sistema POSIX. Más de 100 llamadas fueron definidos en el documento – que permite el acceso a la compatibilidad de control de procesos POSIX, el manejo de señales, archivo sistema de control, control de dispositivos, señalando procedimiento, y el arroyo de E / S en una forma portable.

El desarrollo de una norma revisada para tener éxito FORTRAN 77 sería retrasado en varias ocasiones como el proceso de normalización luchado para mantenerse al día con los rápidos cambios en la informática y la práctica de programación. Mientras tanto, como el "estándar FORTRAN" durante casi quince años, FORTRAN 77 se convertiría en el dialecto históricamente más importante.

Control Data Corporation Computadoras, había otra versión de FORTRAN 77, llamada Minnesota FORTRAN (FMN), diseñado especialmente para los estudiantes, con variaciones en la producción de construcciones, usos especiales de los Comunes y las declaraciones de datos, códigos y niveles de optimizaciones para la compilación y el errores de listas detalladas, extensos mensajes de advertencia, y depuración.

FORTRAN 90

El retraso es el sucesor de mucho para FORTRAN 77, informalmente conocido como Fortran 90 (y antes de eso, Fortran 8X), finalmente fue lanzado como un estándar ISO en 1991 y un estándar ANSI en 1992. Esta revisión importante añadió muchas características nuevas para reflejar los cambios significativos en la práctica de programación que había evolucionado desde la norma 1978:

• De forma libre la fuente de entrada, también con minúsculas palabras clave Fortran

• Los identificadores de hasta 31 caracteres de longitud

• En línea comentarios

• Capacidad para funcionar en las matrices (o la matriz de las secciones) en su conjunto, lo que simplifica enormemente las matemáticas y los cálculos de ingeniería.

• Parciales enmascarados matriz de asignación y las declaraciones completas y expresiones de matriz, como   X (1: N) = R (1: N) * COS (A (1: N))

• DONDE declaración para la asignación de matrices selectiva

• Matriz con valores constantes y expresiones,

• Definido por el usuario con valores de matriz de funciones y constructores matriz.

• RECURSIVO procedimientos

• Módulos, a grupo relacionado de procedimientos y los datos juntos, y ponerlos a disposición de las unidades de otro programa, incluyendo la capacidad de limitar el acceso sólo a determinadas partes del módulo.

• Un mejor argumento-que pasa mecanismo enormemente, lo que permite interfaces que se comprueban en tiempo de compilación

• Las interfaces de usuario-escrito para procedimientos genéricos

• La sobrecarga de operadores

• Derivado /resumen los tipos de datos

• Nuevo tipo de datos sintaxis de declaración, para especificar el tipo de datos y otros atributos de las variables

• La asignación dinámica de memoria  mediante la asignables  atributo y el ALLOCATE y DEALLOCATE declaraciones

• POINTER atributo, asignación de punteros, y anular la declaración para facilitar la creación y manipulación de la dinámica de las estructuras de datos

• Bucle estructurado construcciones, con un END DO declaración de terminación del bucle, y SALIR y CICLO declaraciones para "romper" fuera de lo normal NO iteraciones del bucle de manera ordenada

• SELECCIONAR . . . CASO construcción de múltiples sentidos de selección

• Especificación de portátiles de precisión numérica bajo control del usuario

• Nuevo y mejorado los procedimientos intrínsecos.

FORTRAN 95

Fortran 95 fue una revisión menor, sobre todo para resolver algunas cuestiones pendientes de la Fortran 90 estándar. Sin embargo, Fortran 95 también añadió una serie de extensiones, especialmente de los de alto rendimiento Fortran pliego de condiciones:

• FORALL y anidados DONDE construye a las ayudas vectorización

• Definidos por el usuario PURE y ELEMENTAL procedimientos

• Predeterminado de inicialización de los componentes de tipo derivado, incluyendo la inicialización de puntero

• Amplió la capacidad de utilizar las expresiones de inicialización de objetos de datos

• Claramente definidos que asignables matrices son automáticamente, cancela la asignación cuando salen del ámbito de aplicación.

Un número de funciones intrínsecas se ampliaron (por ejemplo, un débil argumento ha sido añadido a la maxloc intrínseca).

Varias características que se señalan en Fortran 90 para ser obsoleto fueron retiradas de Fortran 95:

• NO declaraciones utilizando REAL y DOUBLE PRECISION variables

• La ramificación de un END IF declaración de fuera de su bloque

• PAUSA declaración

• ASIGNAR y se les asignará GOTO declaración, y se les asignará especificadores de formato

• H descriptor de edición.

Un complemento importante de Fortran 95 es el informe técnico ISO TR-15581: Mejora de Instalaciones Tipo de datos, conocidos por el nombre TR asignables. Esta especificación define una mayor utilización de asignables matrices, antes de la plena disponibilidad de los compiladores de Fortran. Estos usos incluyen asignables matrices como componentes de tipo derivado, en maniquí de listas de argumentos de procedimiento, y como valores de retorno de la función. (Asignables matrices son preferibles a POINTER arrays, porque asignables matrices están garantizados por Fortran 95 que se cancela la asignación de forma automática cuando salen del ámbito de aplicación, eliminando la posibilidad de pérdida de memoria.

Además, el alias no es un problema para la optimización de las referencias de matriz, permitiendo que los compiladores generen código más rápido que en el caso de los punteros.)

Otro complemento importante de Fortran 95 es el ISO informe técnico TR-15580, punto flotante de manejo de excepciones-, se conoce informalmente como el TR IEEE. 

Esta especificación define el apoyo a la aritmética de punto flotante IEEE y de punto flotante de manejo de excepciones.

La compilación condicional y cadenas de longitud variable.

Además de la obligatoria "lengua base" (definido en la norma ISO / IEC 1539-1: 1997), el lenguaje Fortran 95 también incluye dos módulos opcionales:

• Diferentes cadenas de caracteres (ISO / IEC 1539-2: 2000)

• La compilación condicional (ISO / IEC 1539-3: 1998)

Que, juntas, conforman varias partes del Estándar Internacional (ISO / IEC 1539).

De acuerdo con los desarrolladores de los estándares ", las piezas opcionales describen autónomas características que han sido solicitadas por un cuerpo sustancial de los usuarios y / o desarrolladores, pero que no se consideran de generalidad suficiente para que puedan exigir en todos los estándares y compiladores FORTRAN. " Sin embargo, si uno los estándares de Fortran proporciona estas opciones, entonces "debe ser proporcionada de conformidad con la descripción de las instalaciones en la parte apropiada de la norma."

FORTRAN 2003

La norma más reciente, Fortran 2003, constituye una revisión a la introducción de muchas nuevas características. Un resumen completo de las nuevas características de Fortran 2003 está disponible en el Grupo de Trabajo de Fortran (GT5) sitio web oficial.

A partir de ese artículo, las principales mejoras de esta revisión son:

• Derivado mejoras tipo: con parámetros tipos derivados, un mejor control de la cesibilidad, la mejora de la estructura de constructores y finalizadores.

• La programación orientada a objetos de apoyo: extensión de tipo y la herencia, polimorfismo dinámico, la asignación de tipo A y tipo-los procedimientos de la envolvente.

• manipulación de las mejoras de los datos: componentes asignables (incorporando TR 15581), escriba los parámetros en diferido, VOLATILIDAD atributo, la especificación explícita de tipos

• En los constructores de matriz y asignar los estados, las mejoras de puntero, las expresiones de inicialización extendido y mejorado los procedimientos intrínsecos.

• Entrada / salida de mejoras: asíncrono de transferencia, el acceso corriente, se especifica la transferencia de las operaciones del usuario para los tipos de derivados, el usuario especifica el control de redondeo durante las conversiones de formato, constantes con nombre para las unidades pre conectados, la RAS declaración, la regularización de palabras clave, y el acceso a mensajes de error.

• Procedimiento puntero.

• Apoyo a la aritmética de punto flotante IEEE y de punto flotante de control de excepciones (que incorpora TR 15580).

• Inter operabilidad con el lenguaje de programación C.

• Soporte para el uso internacional: el acceso a la ISO 10646 bytes 4 caracteres y la elección de decimal o coma en formato numérico de entrada / salida.

• Integración mejorada con el sistema operativo anfitrión: el acceso a la línea de comando argumentos, las variables de entorno, y mensajes de error del procesador.

Un complemento importante de Fortran 2003 fue el informe técnico ISO TR-19767: Mejora de las instalaciones del módulo en Fortran. En este informe se sub-módulos, módulos de Fortran que hacen más similar al de Modula-2 módulos. Son similares a Ada sub-unidades niño privado. Esto permite la especificación y la implementación de un módulo que se expresa en unidades de programa separado, lo que mejora los envases de las grandes bibliotecas, permite la preservación de los secretos comerciales, mientras que la publicación definitiva de las interfaces, y evita las cascadas de compilación.

FORTRAN 2008

Se están realizando esfuerzos para desarrollar una revisión de Fortran 2003, denominado provisionalmente Fortran 2008. Al igual que con Fortran 95, este pretende ser una actualización menor, la incorporación de las aclaraciones y correcciones que se Fortran 2003 y sub-módulos de la incorporación de TR-19767 en el idioma base, así como la introducción de un selecto capacidades nuevas. A partir de febrero de 2007, las nuevas capacidades incluidas propuestas.

COMPILAR Y CORRER PROGRAMAS EN FORTRAN

Los programas en FORTRAN se escriben en un editor de texto cualquiera (vi, emacs, etcétera). Normalmente, el nombre del archivo debe llevar como sufijo .f, o .f90. A este archivo se le llama el "código fuente".

Una vez escrito el programa, este debe compilarse, es decir, debe ser leído por un programa llamado "compilador" que lo traduce a lenguaje de máquina y produce un nuevo archivo con el programa ejecutable. Algunos lenguajes de programación no usan un compilador, sino un "intérprete" (por ejemplo BASIC y PERL). La diferencia es que un interprete traduce y ejecuta línea por línea, sin nunca crear un archivo ejecutable.

Un intérprete es más transparente de usar, pero mucho más lento. FORTRAN funciona siempre con un compilador.

ELEMENTOS BÁSICOS DE UN PROGRAMA EN FORTRAN

Un programa en FORTRAN tiene los siguientes elementos básicos:

• Nombre del programa. El nombre del programa es en realidad opcional, pero es muy buena idea tenerlo.

• Declaraciones de variables utilizadas en el programa.

• Cuerpo del programa. Comandos a ejecutar en el código. Los comandos se ejecutan en orden de aparición. El programa siempre debe terminar con el comando END.

• Subprogramas. El cuerpo del programa puede llamar a subprogramas que realicen tareas específicas. Es buena práctica de programación separar un programa en bloques y poner cada bloque en diferentes subprogramas. De hecho, para programas largos es buena idea tener cada subprograma en archivos separados.

La estructura de un comando en FORTRAN 90 tiene las siguientes propiedades:

• Los comandos se escriben en líneas de a lo más 132 caracteres (aunque algunos compiladores aceptan líneas más largas).

• Espacios en blanco al principio de una línea se ignoran. Esto ayuda a mejorar visualmente la estructura del programa. Hay que recordar que no solo la máquina va a leer el programa, sino también seres humanos (por lo menos el autor), por lo que una estructura visualmente clara en importante.

• Un signo & al final de una linea indica que el comando continua en la linea siguiente.

• Todo lo que siga de un signo! se considera un comentario y es ignorado por el compilador. Los comentarios son para las personas, no para la máquina. Hacen más fácil de entender el programa para personas que no lo escribieron, y sirven incluso para que el autor sepa lo que hace el programa si lo vuelve a ver tiempo después.

• Es posible poner varios comandos en una línea separándolos con punto y coma.

• Importante: FORTRAN no distingue entre mayúsculas y minúsculas en un programa, también ignora más de un espacio en blanco y líneas en blanco. Que se use es cuestión de estilo personal.

Ejemplo: Programa "nada".

program nada

! Este programa no hace nada.

end program nada

La primera línea dice como se llama el programa. La segunda línea es un comentario y el compilador la ignora. La ´ultima línea dice que el programa ha terminado.

Ejemplo: Programa "hola".

program hola

! Ahora vamos a saludar al mundo

print *, "hola mundo!" ! Aqui es donde saludamos

end program hola

Lo nuevo aquí es la línea: print *, "hola mundo!". La instrucción print * indica imprimir en la salida estandard (es decir, la pantalla). Lo que se va a imprimir debe colocarse entre comillas después de una coma. Nótese como hay un comentario al final de la línea que el compilador simplemente ignora.

CONSTANTES Y VARIABLES

Los programas en FORTRAN manejan datos de dos tipos: constantes y variables.

Las constantes tienen un valor fijo, mientras que las variables se identifican con nombres y pueden cambiar de valor durante al ejecución del programa. Constantes y variables deben tener tipos específicos que indican al programa como almacenarlas y manejarlas.

TIPOS DE DATOS

Los tipos de datos permitidos son los siguientes:

logical Las variables lógicas solo pueden tener dos valores: .true. (Verdadero) y .false. (Falso).

integer Valores enteros guardados en 4 bytes. Se indican como números sin punto decimal: 1, 2, -3, 25, etc.

real Valores reales guardados en 4 bytes y con 8 cifras significativas. Se indican con punto decimal, y de ser necesario el exponente de la potencia de 10 después de una E: 1., -3.1416, 6.25E-10, etc.

double Valores reales de doble precisión guardados en 8 bytes y con 16 cifras significativas, también se denotan por real(8). Se indican con punto decimal y el exponente de la potencia de 10 después de una D: 1.D0, -3.1416D0, 6.25D-10, etc. Son muy ´útiles en cálculos numéricos largos, donde los errores de redondeo pueden hacer que las ´ultimas 4 o 5 cifras significativas de un número real sean basura.

quadruple Valores reales de cuádruple precisión guardados en 16 bytes y con 32 cifras significativas, también se denotan por real(16). Se indican con punto decimal y el exponente de la potencia de 10 después de una Q: 1.Q0, -3.1416Q0, 6.25Q-10, etc.

complex Dos valores reales formando un par y que en operaciones matemáticas se tratan como la parte real e imaginaria de un número complejo:

(1.,-2.), (1.0E0,-2.0E0). También existen versiones de doble y cuádruple precisión.

character Variables que corresponden a cadenas de caracteres. Al declarar una variable de este tipo se debe especificar cuantos caracteres puede tener. Estas variables deben estar contenidas en comillas: "hola", "abcdfe", "Me llamo Luis", "128.3", etc.

DECLARACIÓN DE VARIABLES

Las variables utilizadas en un programa FORTRAN deben declararse como uno de los tipos mencionados en la sección anterior. Por compatibilidad con versiones viejas de FORTRAN, se asume que aquellas variables que no han sido declaradas tienen un tipo implícito de acuerdo a la siguiente regla: variables cuyos nombres empiezan con

{i, j,k,l,m,n} se asumen enteras, y todas las demás se asumen reales. El uso de declaraciones implícitas es indeseable, pues hace más difícil detectar posibles errores de tecleo. Para evitar usar declaraciones implícitas se debe poner al principio de las declaraciones la línea:

implicit none

Ejemplo: Programa "valores".

program valores

implicit none

logical flag

integer i

real a

character(30) texto

i = 1

a = 2.5

texto = "Estas son las variables:"

print *, texto

print *, flag,i,a

end program valores

El programa anterior primero declara que no hay variables implícitas, luego declara una variable lógica, una entera, una real y una cadena de caracteres. Luego les asigna valores y las imprime a la pantalla. Nótese el uso de comillas para la variable de tipo character, y como se ha declarado como de 30 caracteres (suficientes para contener la frase "Estas son las variables").

También es importante señalar el uso del operador =. Este operador no significa "igual", sino que significa "asignar", y sirve para asignar valores a variables.

CONVERSIÓN ENTRE TIPOS

En FORTRAN es muy importante declarar las variables correctamente. Muchos errores comunes están relacionados con utilizar tipos equivocados de variables. Por ejemplo, en operaciones entre números reales debe evitarse el utilizar variables enteras ya que fácilmente se obtendrán valores equivocados. Supongamos que se han declarado las variables i y j como enteras, y la variable x como real, y queremos calcular:

x = i / j

Si tenemos i=10 y j=4 el resultado será 2 y no 2.5 como uno podría esperar. Esto se debe a que la división entre números enteros siempre se considera un entero. Para evitar este tipo de errores es importante convertir un tipo de variables a otras. Esto puede lograrse con los comandos: int(),nint(,real(),dble(). Los comandos real() y dble() convierten la cantidad entre paréntesis a una variable real o de doble precisión, respectivamente. Los comandos int() y nint() convierten la cantidad entre paréntesis a un número entero, la diferencia está en que int() simplemente trunca el número, mientras que nint() lo reduce al entero más cercano.

Ejemplo: Programa "convertir".

program convertir

print *, 10/4

print *, 10.0/4.0

print *, real(10)/real(4)

print *, real(10/4)

print *, dble(10)/dble(4)

print *, int(10.7)

print *, nint(10.7)

print *, int(-3.7)

print *, nint(-3.7)

end program convertir

OPERACIONES EN FORTRAN

Las operaciones aritméticas en FORTRAN involucran los siguientes operadores:

= Asignación. Es muy importante recalcar que este operador NO significa igualdad. En FORTRAN, tiene sentido escribir líneas que algebraica-mente son absurdas como por ejemplo:

a = a + 1

Esto significa tomar la variable a, sumarle 1, y asignar el resultado de nuevo a la variable a.

+ Suma (2.0+3.0! 5.0).

– Resta (2.0-3.0! -1.0).

* Multiplicación (2.0*3.0! 6.0).

/ División (2.0/3.0! 0.66666667).

** Exponenciación (2.0**3.0! 8.0).

Las operaciones se realizan en el siguiente orden:

1. Términos entre paréntesis, comenzando por los de más adentro.

2. Exponenciación.

3. Multiplicación y división de izquierda a derecha.

4. Sumas y restas de izquierda a derecha.

ARREGLOS

FORTRAN puede almacenar en memoria vectores y matrices utilizando variables llamadas

"arreglos" que contienen muchos elementos. Los arreglos pueden ser de cualquiera de los tipos aceptados por FORTRAN.

ARREGLOS DE TAMAÑO FIJO

La manera más directa de declarar un arreglo es dando su tamaño desde el principio.

Por ejemplo, para declarar un vector de 3 componentes y una matriz de 4 por 5 se escribe:

real, dimension(3) :: v

real, dimension(4,5) :: m

Es posible declarar arreglos con un número arbitrario de dimensiones. Por ejemplo, un arreglo de 4 ´índices cuyos valores van de 1 a 2 se declara como:

real, dimension(2,2,2,2) :: R

También se puede dar explícitamente el rango permitido para los ´índices:

real, dimension(0:8), v1

real, dimension(2:5), v2

Esto declara al vector v1 con ´índices que van de 0 a 8, y al vector v2 con ´índices que van de 2 a 5.

Existe una abreviación de la declaración de arreglos. Por ejemplo, los arreglos v,m,R de los ejemplos anteriores se pueden también declarar como:

real :: v(3), m(4,5), R(2,2,2,2)

Para referirse a un miembro específico del arreglo, se utilizan expresiones del tipo:

a = v (1) + m (1,1) + R (1, 2, 1,2)

Es posible también realizar operaciones con arreglos completos a la vez (esto no era posible en FORTRAN 77). Por ejemplo, si a, b, c son arreglos con las mismas dimensiones, podemos escribir:

a = b+c

a = b*c

a = b**2

La primera operación suma uno a uno los elementos de los arreglos b y c y los coloca en los elementos correspondientes de a. La segunda operación hace lo mismo, pero multiplicando los elementos de b y c (Ojo: esto NO es una multiplicación de matrices, sino una multiplicación elemento a elemento). La ´ultima operación eleva cada elemento de b al cuadrado y los asigna al elemento correspondiente de a.

Para este tipo de operaciones es muy importante que los arreglos involucrados tengan las mismas dimensiones, o habrá un error.

Ejemplo: Programa "arreglos".

program arreglos

implicit none

! Declarar vectores.

real, dimension(3) :: v1,v2

!Declarar matrices.

real, dimension (0:1,0:1) :: a,b,c

! Dar componentes de v1.

v1(1) = 1.0

v1(2) = 2.0

v1(3) = 3.0

! Dar v2 de golpe.

v2 = 4.0

! Dar componentes de b.

b(0,0) = 1.0

b(0,1) = 2.0

b(1,0) = 3.0

b(1,1) = 4.0

! Dar la matriz c de golpe.

c = 2.0

! Definir a como la división de b entre c.

a = b/c

! Imprimir v1 completo.

print *, "Vector v1:"

print *, v1

print *

! Imprimir v2 componente a componente.

print *, "Vector v2:"

print *, v2(1),v2(2),v2(3)

print *

! Imprimir componente c (0, 0).

print *, "Componente c(0,0):"

print *, c(0,0)

print *

! Imprimir componente b (1,1).

print *, "Componente b(1,1):"

print *, b(1,1)

print *

! Imprimir a completo.

print *, "Matriz a completa:"

print *, a

print *

end program arreglos

En el ejemplo anterior se muestran declaraciones y operaciones con arreglos. Nótese que al imprimir es posible imprimir componentes individuales, o arreglos completos. En este último caso el arreglo se escribe recorriendo primero los ´índices de la izquierda y luego los de la derecha (al revés de lo que uno esperaría normalmente). Otro punto a notar es el comando print * sin nada que le siga, esto hace que FORTRAN imprima una línea en blanco.

ASIGNACIÓN DINÁMICA DE MEMORIA

En algunas ocasiones resulta ´útil declarar un arreglo sin asignarlo un número fijo de componentes desde el principio, y solo asignarlas después (debido por ejemplo a que se leen datos del exterior). Para hacer esto, los arreglos se pueden declarar como:

real, allocatable, dimension (:) :: v

real, allocatable, dimension (:,:) :: m

Antes de realizar cualquier operación con un arreglo de este tipo se le debe asignar memoria de la siguiente forma:

allocate(v(3),m(4,5))

Al terminar los cálculos es posible eliminar esta memoria con el comando:

deallocate(v,m)

Esto es particularmente ´útil en códigos largos que utilizan mucha memoria, o en casos donde el tamaño de los arreglos depende ya sea de valores externos o de que se cumplan ciertas condiciones en el código.

FUNCIONES INTRÍNSECAS

FORTRAN cuenta con una serie de funciones matemáticas pre-definidas llamadas

"funciones intrínsecas". Una lista de algunas de ellas (no todas) es:

sqrt(x) Ra´iz 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 (ex).

alog(x) Logaritmo natural de x.

alog10(x) Logaritmo en base 10 de x.

max(x,y) M´aximo entre x y y.

min(x,y) M´inimo entre x y y.

Las funciones trigonométricas se usan siempre en radianes, y no en grados.

Ejemplo: Programa "intrínsecas".

program intrinsecas

implicit none

real pi

! Imprimir seno y coseno de cero.

print *

print *, "Seno y coseno de 0"

print *, sin(0.0),cos(0.0)

print *

15

! Ahora a calcular pi. Recuerden que cos(pi) = -1.

pi = acos(-1.0)

print *, "El valor de pi es"

print *, pi

print *

! Ya tenemos pi, ahora calcular su seno, coseno y tangente

print *, "Seno, coseno y tangente de pi"

print *, sin(pi),cos(pi),tan(pi)

print *

! Cual es la raiz cuadrada de 2?

print *, "Raiz de 2"

print *, sqrt(2.0)

print *

end program intrínsecas

Cosas por notar en este ejemplo son las siguientes: FORTRAN no conoce el valor de p. En general no es buena idea definir este valor directamente, es mejor calcularlo usando funciones trigonométricas inversas para obtener mayor precisión. Nótese también que al correr este programa, el seno y la tangente de p no dan cero sino números de orden 10-7.

Esto es debido al error de redondeo en la última cifra significativa de los números reales.

Si utilizamos doble precisión, el error seía del orden 10-15. Cuando uno realiza muchas operaciones numéricas, el error de redondeo se propaga y puede contaminar varias cifras decimales. Por ello es buena idea usar doble precisión para cálculos numéricos complejos.

CONTROL DE FLUJO DEL PROGRAMA

En general, un programa FORTRAN ejecuta los comandos en el orden en el que se escribieron, uno a la vez. Sin embargo, frecuentemente hay situaciones en las que esto es

demasiado simple para lo que uno quiere hacer. A veces es necesario repetir una misma operación muchas veces con ligeras variaciones, y otras veces hay operaciones que solo deben realizarse si se cumple alguna condición. Para este tipo de situaciones existen los llamados "comandos de control del programa" y que caen en dos tipos básicos: "loops" y condicionales.

Loops

Un "loop" es un conjunto de instrucciones que deben realizarse muchas veces y tiene la forma estandard:

do i=start,end,increment

comando 1

comando 2

comando 3

end do

Todos los comandos que están contenidos entre la línea do i=… y la línea end do se repiten varias veces, dependiendo de los valores de start,end,increment que deben ser enteros. La primera vez, la variable i toma el valor start. Al terminar, el valor de i se incrementa en increment, si el valor final es mayor que end el loop ya no se ejecuta de nuevo y el programa continua en el comando que siga después de end do, de lo contrario se vuelven a ejecutar los comandos dentro del loop hasta que se obtenga i>end.

Programa "fibonacci".

program fibonacci

! Este programa calcula los numeros de la serie

! de fibonacci hasta nmax.

implicit none

integer i,nmax

integer jnew,jold,aux

! Poner un limite.

nmax = 10

! Inicializar (jnew,jold).

jnew = 1; jold = 1

! Iniciar loop.

print *

do i=1,nmax

! Imprimir elemento i de la serie.

print *, "Elemento ",i," de la serie de Fibonacci: ", jnew

print *

! Calcular nuevo elemento de la serie.

aux = jnew

jnew = jnew + jold

jold = aux

end do

end program fibonacci

IF

En ocasiones uno desea que una parte del programa solo sea ejecutada si cierta condición específica se satisface. Esto se logra utilizando los "condicionales", que en FORTRAN se controlan con el comando IF. La estructura de este comando es la siguiente:

if (expresi´on l´ogica) then

18

comando 1

comando 2

else

comando 3

comando 4

end if

Al ejecutar esto, el programa verifica si la expresión lógica entre paréntesis después del if es verdadera. De serlo, se ejecutan los comandos siguientes. De ser falsa, se ejecutan los comandos después del else (nótese que el [else] es opcional).

La expresión lógica puede utilizar cualquiera de los siguientes operadores lógicos:

• == Igualdad: if (i==3) then. Una versión equivalente de este operador

(que de hecho es la única válida en FORTRAN 77) es .eq.:

if (i.eq.3) then.

• >Mayor que: if (i>3) then. Una versión equivalente de este operador

(que de hecho es la única válida en FORTRAN 77) es .gt.:

if (i.gt.3) then.

• >= Mayor o igual: if (i>=3) then. Una versión equivalente de este

operador (que de hecho es la única válida en FORTRAN 77) es

ge.: if (i.ge.3) then.

• < Menor que: if (i>3) then. Una versión equivalente de este operador

(que de hecho es la única válida en FORTRAN 77) es .lt.:

if (i.lt.3) then.

• <= Menor o igual: if (i<=3) then. Una versión equivalente de este

operador (que de hecho es la única válida en FORTRAN 77) es

le.: if (i.le.3) then.

• /= No igual: if (i/=3) then. Una versión equivalente de este operador

(que de hecho es la única válida en FORTRAN 77) es .ne.:

if (i.ne.3) then.

• not. Negación lógica: if (.not.flag) then, donde flag ha sido declarada

como una variable lógica.

• or. "O" lógico: if ((i==3) .or.(i==5)) then.

• and. "Y" lógico: if ((i==3).and.(j==5)) then.

El comando if puede simplificarse si solo hay un comando en su interior:

if (i==3) comando

Este comando indica que si se cumple la condición el comando indicado debe ejecutarse.

También es posible tener muchas alternativas en un condicional:

if (expresión lógica 1) then

comando 1

else if (expresión lógica 2)

comando 2

else if (expresión lógica 3)

comando 3

else

comando 4

end if

CONTROL LÓGICO DE LOOPS

Es posible utilizar condiciones lógicas para controlar un loop. Esto se logra utilizando el comando do while():

do while(expresión lógica)

comando 1

comando 2

end do

En este caso no se cuenta con una variable entera como en el caso estándar, sino que el loop se ejecuta una y otra vez mientras la expresión lógica sea verdadera. El loop se detiene una vez que dicha expresión es falsa. Por ejemplo, el siguiente código actúa de la misma forma que un loop estándar de 1 a 10:

i = 1

do while (i <=10)

i = i + 1

end do

CUIDADO: Con este tipo de loops se corre el riesgo de caer en un ciclo eterno, donde la condición lógica nunca deja de satisfacerse y la máquina sigue ejecutando el loop para siempre. Cuando se trabaja en una terminal uno nota esto fácilmente si el código continua mucho tiempo más del que esperábamos sin hacer aparentemente nada. En ese caso siempre se puede detener al código tecleando [CTRL C]. Pero cuando uno está corriendo en una cola en una super-computadora se corre el riesgo de terminarse la cuota que debería haber durado un año de una sola vez, y peor aún, los encargados del sistema pueden decidir retirar los privilegios de trabajar en esa máquina ante semejante desperdicio de recursos de cómputo y falta de cuidado.

ENTRADA Y SALIDA DE DATOS (input/output)

En la mayoría de los códigos científicos es necesario dar datos desde fuera y sacar datos hacia afuera. Por default, la entrada de datos es desde el teclado y la salida es a la pantalla. La entrada y salida de datos se manejan con los comandos:

read(,)

write(,)

Ambos comandos tienen dos argumentos, el primero de los cuales indica la "unidad" de entrada o salida, y el segundo el formato en el que están los datos. La versión más simple es:

read(*,*)

write(*,*)

Aquí, el primer asterisco indica entrada o salida estándar (teclado y pantalla respectivamente), y el segundo formato libre. El comando write(*,*) puede substituirse por la forma equivalente print * seguido de una coma.

UNIDADES DE ENTRADAS Y SALIDAS

Además de utilizar el teclado y la pantalla, los datos también pueden leerse o enviarse a un archivo. Para ello debe primero abrirse el archivo con elopen que debe tener al menos dos argumentos (puede tener varios más). El primer argumento es la "unidad" a la que se asigna la salida o entrada de datos, que debe ser un numero entero (comúnmente se usa 10). El segundo argumento es el nombre del archivo entre comillas (con su PATH completo si no está en el mismo directorio que el ejecutable). Al terminar de leer o escribir se debe cerrar el archivo con el comando close cuyo único argumento es el número de la unidad.

Ejemplo: Programa "archivos". Para este ejemplo es necesario crear primero un archivo de datos llamado "entrada.dat" que contenga solo una línea con: "juan,25,masculino".

program archivos

! Declarar variables.

implicit none

integer edad

character(20) nombre,sexo

! Abrir archivo de entrada.

open(10,file="entrada.dat")

! Leer datos.

read (10,*) nombre,edad,sexo

! Cerrar achivo.

close(10)

! Abrir archivo de salida.

open(11,file="salida.dat")

! Escribir datos.

write(11,*) "Me llamo ",nombre

write(11,*) "Tengo ",edad," anios"

write(11,*) "Mi sexo es ",sexo

! Cerrar archivo.

close(11)

end program archivos

FORMATO DE ENTRADA Y SALIDA

En ocasiones se requiere que los datos de entrada o salida estén en un formato muy específico. El control del formato se lleva a cabo en el segundo argumento del los comandos open y close. Existen dos posibilidades: Para formatos sencillos, el formato se coloca simplemente el formato entre comillas y paréntesis dentro del segundo argumento, mientras que para formatos más complicados se coloca un número entero que identifica la línea donde está el formato. Por ejemplo, las dos opciones siguientes son equivalentes:

read(10,"(i4)") m

read(10,100) m

100 format(i4)

En ambos casos se indica al código que debe leer un número entero de a lo más 4

dígitos de longitud "i4". La ventaja del segundo método es que se puede usar el mismo formato en más de un comando:

read(10,100) i

read(10,100) j

read(10,100) k

100 format(i4)

Los diferentes opciones de formato son:

SUBPROGRAMAS

En muchas ocasiones existen tareas que se deben realizar muchas veces durante la ejecución de un código, por lo que resulta conveniente que sean subprogramas en sí mismos.

La existencia de subprogramas también hace que un código sea más modular, y permite que diferentes personas programes diferentes partes de un mismo código.

Los diversos subprogramas pueden ser parte de un mismo archivo, o estar en archivos separados que se unen durante el proceso de compilación. Si están en un mismo archivo, deben aparecer después de la línea que termina el programa principal. En FORTRAN 90 hay tres tipos básicos de subprogramas: funciones, subrutinas y módulos. Consideraremos cada uno de ellos por separado.

FUNCIONES

Asi como existen funciones intrínsecas en FORTRAN (sin, cos, etc.), también es posible definir funciones nuevas de una o más variables. El objetivo de una función es obtener un número a partir de los argumentos. Al igual que el programa principal, una función comienza por su nombre function nombre. Al final de la función deben aparecer los comandos return seguido de end function nombre, esto regresa el control al programa principal. La función es una unidad autónoma, por lo que debe declarar todas las variables que utiliza, incluyendo el nombre de la función y los argumentos.

Es muy importante que los argumentos de la función sean del mismo tipo cuando se llama la función y en la función misma, de otra forma habría errores al ejecutar el código.

El nombre de la función debe declarase en el programa principal y cualquier subprograma que la llame.

SUBRUTINAS

Una subrutina es similar a una función, pero más complicada, de la que no solo se espera un número, sino toda una secuencia de operaciones que pueden requerir regresar muchos números al programa principal (o ninguno).

Las subrutinas se llaman usando el comando call nombre. Igual que las funciones, las subrutinas comienzan por su nombre subroutine nombre y terminar con los comandos return y end subroutine nombre. También son unidades autónomas que deben declarar todas las variables que utilizan, incluyendo a sus argumentos.

A diferencia de las funciones, el nombre de una subrutina no tiene un tipo (el nombre de las funciones si tiene un tipo pues corresponde al valor de regreso).

Una característica importante de las subrutinas es que cuando se pasa un arreglo como uno de sus argumentos, no es necesario dar el tamaño. Se puede pasar el tamaño como un argumento, digamos N, y simplemente declarar el arreglo como real, dimension(N) :: nombre. Algo similar sucede con los variable de tipo character que se pueden declarar con dimensión indeterminada usando * cuando son parte de los argumentos de la subrutina, de manera que heredan el tamaño que tenían él en programa que llamo a la subrutina.

MÓDULOS

El ultimo tipo de subprogramas son los módulos que solo existen a partir de FORTRAN 90. Los módulos sirven para declarar variables que se usan en muchos subprogramas, o para agrupar muchos subprogramas en una sola unidad. Los módulos comienzan por su nombre module nombre y terminan con end module nombre (en los módulos no se utiliza el comando return). A diferencia de las funciones y subrutinas, si el módulo está en el mismo archivo que el programa principal, debe estar antes que este. Cualquier subprograma que haga uso del módulo debe hacerlo mediante el comando use nombre inmediatamente después del nombre del subprograma. El uso más común de los módulos es para declarar variables que van a ser utilizadas por muchos subprogramas.

CONCLUSIÓN

FORTRAN es unos de los primeros lenguajes de programación de alto nivel que desde que salió la primera versión, cuando salió FORTRAN como un lenguaje que no era ensamblador dudaron porque los clientes eran reacios a usar un lenguaje de programación de alto nivel a menos que su compilador pudiera generar código cuyo desempeño fuera comparable al de un código hecho a mano en lenguaje ensamblador.

El lenguaje fue ampliamente adoptado por los científicos para escribir programas numéricamente intensivos, que incentivó a los escritores de compiladores a producir compiladores que pudieran generar un código más rápido y más eficiente. La inclusión en el lenguaje de un tipo de datos y de la aritmética de números complejos amplió la gama de aplicaciones para las cuales el lenguaje se adaptaba especialmente e hizo al FORTRAN especialmente adecuado para aplicaciones técnicas tales como la ingeniería eléctrica.

Por 1960, las versiones de FORTRAN estaban disponibles para los computadores IBM 709, 650, 1620, y 7090.

Significativamente, era cada vez mayor la popularidad del FORTRAN estimuló a fabricantes de computadores de la competencia a proporcionar compiladores FORTRAN para sus máquinas, así que por 1963 existían más de 40 compiladores FORTRAN. Por estas razones, el FORTRAN es considerado ser el primer lenguaje de programación ampliamente usado soportado a través de una variedad de arquitecturas de computador.

El desarrollo del FORTRAN fue paralelo a la temprana evolución de la tecnología del compilador. De hecho, muchos avances en la teoría y el diseño de compiladores fueron motivados específicamente por la necesidad de generar código eficiente para los programas en FORTRAN.

FORTRAN ha incluido atreves de los años mejoras a sus versiones dependiendo las necesidades.

Autor:

Emerson Rodriguez