Capitulo 2

La principal razón para escribir un programa, cualquier tipo de programa, es para

resolver un problema específico, sin embargo, escribir un programa no es fácil,
requiere mucha experiencia práctica y tener la oportunidad de observar programas
realizados por otras personas ayuda también a la experiencia.
La tarea de escribir un programa se puede dividir en cuatro pasos básicos:
Especificación: Especificar claramente el problema
Análisis y diseño: Analizar el problema y fragmentarlo en elementos
fundamentales
Codificación: codifica el programa de acuerdo al plan desarrollado en el anterior
paso
Comprobación: Comprueba el programa exhaustivamente, si es necesario repetir
los anteriores dos pasos, por lo menos hasta que el programa funcione
correctamente como se había previsto.
Un plan estructurado es un buen método para la asistencia del diseño de un
programa. Esto involucra la creación de un plan estructurado a niveles sucesivos de
refinamiento hasta alcanzar el punto donde se está listo para codificar los pasos
individuales sin necesidad de más análisis.
Un programa está compuesto por una unidad de programa principal y unidades de
programa de otros tipos, en particular subrutinas. Cada programa principal debe
comenzar con la declaración “Program” y finaliza con la declaración “End
Program” entre estas dos declaraciones debe haber declaraciones de
especificación y declaraciones ejecutables. Las declaraciones de especificación
proveen información del programa al compilador, por otro lado, las declaraciones
ejecutables son obedecidas por el computador mientras se ejecuta el programa.
Como no siempre todo sale bien, en ocasiones se comenten errores a la hora de
escribir un programa, estos errores se clasifican en diferentes tipos; Los errores de
sintaxis son aquellos que ocurren al no escribir correctamente las declaraciones.
Los errores de semántica son errores lógicos del programa, es decir, que no realiza
la tarea para el que fue escrito el programa. Los errores de compilación son errores
que ocurren durante la compilación del programa y por ultimo los errores de
ejecución, que ocurren durante la ejecución del programa, normalmente los errores
de compilación son asociados a los errores de sintaxis mientras que los errores de
ejecución se asocian a la semántica.
Para finalizar el capítulo, nunca se debe olvidar que una computadora no tiene
inteligencia propia, solo realiza la tarea que el usuario pide, no importa que tan tonto
suene, es más lo que el usuario desea que la computadora haga.

Capítulo 3

En este capítulo se discutirá sobre tres tipos básicos de datos que pueden ser
usados en cálculos o en otro tipo de expresiones y las instalaciones que contiene
Fortran para la entrada y salida de información numérica y textual. Hay dos tipos
fundamentales de valores numéricos, los que son enteros y los que no, estos se
conocen en Fortran como “enteros” y “números reales” respectivamente, y la
diferencia entre ellos es de vital importancia en los lenguajes de programación.
También existe un tipo de dato fundamental que permite el guardado y la
manipulación de caracteres no numéricos.

En resumen:
Un entero: se mantiene exacto en la memoria del computador, y tiene un rango
limitado que depende de la escritura de la computadora, son declaradas con la
sentencia Integer.
Un número real: es almacenado por el computador como un numero de punto
flotante, es decir, como una aproximación a un número fijo de dígitos significativos,
además tiene un rango bastante extendido que también depende de la escritura de
la computadora, son declaradas con la sentencia Real.
Variables: Las variables son un lugar en donde los datos pueden ser almacenados
dentro de la memoria del computador, todas las variables deben ser declaradas con
una declaración de tipo (valga la redundancia) antes de su primer uso. Solo hay dos
formas en las que se le puede dar algún valor a las variables, ya sea por asignación
o por la sentencia READ.
Existen también variables de valor fijo, llamadas constantes, las constantes
almacenan valores que no pueden ser modificadas durante la ejecución del
programa.
Por otra parte, las variables no numéricas son declaradas de manera similar a las
numéricas, con la sentencia Character sin embargo es necesario también
especificar la longitud de los caracteres que la variable podrá almacenar, esto se
hace con la sentencia LEN y el número de caracteres que se desea almacenar.
En total hay seis tipos de datos intrínsecos que son procesados por Fortran, de los
cuales ya se han mencionado los tres más importantes: Integer, Real y Character.
Sin embargo, también existe un dato que puede ser creado por el programador, los
datos derivados, cuyos componentes son datos de tipo intrínseco, para crear un
dato de tipo derivado se usa la sentencia TYPE.
Estos datos derivados tienen como componentes datos intrínsecos y otros datos
derivados, su función varía según la necesidad del programador. Un dato derivado
puede ser tanto una variable como un tipo, esto le da al programador mayor
sensación de personalización a la hora de escribir un programa.

Capítulo 4

En este capitulo se introduce el concepto de los procedimientos, cuya función es

asistir en el segundo paso para escribir un programa mencionado en el capítulo dos,
es decir, ayuda en la solución de los sub problemas que se forman al fragmentar un
problema principal, además muestra también como los dos tipos de procedimiento
que maneja Fortran, funciones y subrutinas, son usados como bloques de
construcción primarios en programas bien diseñados.
En resumen:
Un procedimiento es una sección especial del programa que, de alguna manera,
es referenciada siempre que sea requerido, estos procedimientos se dividen en dos
categorías: procedimientos intrínsecos, que son parte del lenguaje de fortran;
procedimientos externos, que son escritos por el programador.
Los procedimientos que maneja fortran son las funciones y las subrutinas, en
antiguas versiones de Fortran (Fortran 90) existían 108 funciones intrínsecas y 5
subrutinas intrínsecas, hoy en dia la lista de funciones y subrutinas intrínsecas se
extiende más allá de los 200 procedimientos intrínsecos.
El propósito de una función es el de tomar uno o más valores (o argumentos) y
regresar un solo resultado (el valor de la función), muchas funciones existen en
varias versiones, cada una de cada uno de los cuales opera con argumentos de
diferentes tipos, estas funciones son llamadas funciones genéricas. Las funciones
intrínsecas comúnmente más usadas son las funciones matemáticas como la raíz
cuadrada (SQRT), la función exponencial (EXP), la función logarítmica (LOG), entre
otras.
Una unidad de programa de Fortran consiste en una unidad de programa principal
y algún numero de cualquiera de los otros cuatro tipos de unidad de programa:
- unidades de subprograma de función externa.
- unidades de subprogramas de subrutinas externas.
- unidades del programa de módulos.
- bloquean las unidades de programa de datos.

Todas las unidades de programa tienen la misma estructura, iniciando con una
declaración inicial, alguna declaración de especificación, alguna declaración de
ejecución y una declaración de fin. Para el caso de una funcion externa tenemos la
siguiente estructura:
--------------------------------------------------------------------------------------------------------------
tipo FUNCTION nombre(argumento1, argumento2, …)

IMPLICIT NONE
...
Declaracion de specificacion
...
Declaracion de ejecucion
...
END FUNCTION nombre
--------------------------------------------------------------------------------------------------------------

Donde estos argumentos son argumentos falsos cuya función es representar otros
argumentos que serán usados cuando la función sea usada o referenciada, y el tipo
es el tipo de resultado de la función. Cada función debe contener una variable que
tenga el mismo nombre de la función y esta variable debe ser asignada o de otra
manera, un valor a devolver como el valor de la antes de salir de la función. Aunque
no es necesario, es posible añadir una especificación de atributos EXTERNAL a
dicha declaración; esta adición informa al compilador que el nombre es que de una
función y no de una variable. Por ejemplo:

--------------------------------------------------------------------------------------------------------------
REAL, EXTERNAL:: Nombre_de_la_funcion
--------------------------------------------------------------------------------------------------------------
La diferencia entre una función y una subrutina radica en la forma de referirse a ellas
y cómo se devuelven los resultados, si los hay. Los argumentos de una subrutina
se utilizan tanto para recibir información para operar como para devolver los
resultados. La estructura de una subrutina es similar a la de la funcion como
cualquier otra unidad de programa:

--------------------------------------------------------------------------------------------------------------
SUBROUTINE nombre(argumento1, argumento2, . . . )
IMPLICIT NONE ...
Declaracion de specificacion
...
Declaracion de ejecucion
...
END SUBROUTINE nombre
--------------------------------------------------------------------------------------------------------------

Una subrutina puede no tener argumentos, para este caso usamos la sentencia
CALL que da el nombre de la subrutina y una lista de argumentos que se utilizarán
para transmitir la información entre la llamada de la unidad del programa y la
subrutina. Por ejemplo:
--------------------------------------------------------------------------------------------------------------
CALL nombre ( arg 1, arg 2, . . . )
--------------------------------------------------------------------------------------------------------------

Los procedimientos pueden ser referidos en el programa principal o en otro

procedimiento. Sin embargo un procedimiento no puede referirse a sí mismo, ni
directa ni indirectamente (por ejemplo, a través de la referencia a otro procedimiento
que, a su vez, hace referencia al procedimiento original). Esto se conoce como
recursividad y no está permitido a menos que tomemos medidas especiales para
permitirlo.
El atributo INTENT es uno de los varios atributos que pueden seguir al tipo en una
declaración. Sólo se puede utilizar en la declaración de un maniquí argumento. Se
utiliza para controlar la dirección en la que los argumentos se utilizan para pasar
información. Puede tomar una de las siguientes tres formas:
 - INTENT(IN): que informa al procesador que este argumento falso se utiliza
sólo para proporcionar información al procedimiento, y el procedimiento no
será permitido para alterar su valor de cualquier manera.

- INTENT(OUT): que informa al procesador que este argumento falso sólo para
devolver la información del procedimiento al programa de llamadas. Su valor
será indefinido al entrar en el procedimiento y se le debe dar un valor por
algún medio antes de ser usado en una expresión, o ser referido de otra
manera en un contexto que requerirá que se evalúe su valor.

- INTENT(INOUT): que informa al procesador que este argumento falso puede

ser utilizado para la transmisión de información en ambas direcciones.

Un Modulo es otra unidad de programa cuyo propósito es distinto al de los

procedimientos, uno de sus usos más importantes está relacionado a la
accesibilidad global de variables, constantes y datos de tipo derivado. Su estructura
como cualquier otra unidad de programa es:
--------------------------------------------------------------------------------------------------------------
MODULE nombre
IMPLICIT NONE
SAVE
...
Declaraciones de especificacion
...
Declaraciones ejecutables
...
END MODULE nombre
--------------------------------------------------------------------------------------------------------------

La declaración que consiste en la única palabra SAVE siempre debe ser incluida en
cualquier módulo que declara cualquier variable. Los objetos de tipos derivados sólo
pueden utilizarse como argumentos para procedimientos si su tipo se define en un
MÓDULO que es utilizado por las unidades de programa pertinentes.
En general los módulos son de gran ayuda en el diseño y control de los datos ya
que permiten una programador para agrupar los datos de tal manera que todos los
procedimientos que requieren el acceso a un grupo particular puede hacerlo
simplemente usando el módulo apropiado.