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