TEMA 1: ESTRUCTURAS Y ELEMENTOS DEL LENGUAJE FORTRAN.
CARACTERES DEL LENGUAJE FORTRAN.
-El lenguaje Fortran tiene unos números y signos
que utiliza y que funcionan como caracteres o letras, siendo los
caracteres permitidos por este lenguaje los siguientes:
-Letras de la A a la Z (Tanto mayúsculas como
minúsculas).
-Números del 0 al 9.
-Caracteres de puntuación ., ;.
-Caracteres matemáticos +, *, /, -.
-Caracteres especiales $, , =, <, >, (), :,
´, y el blanco.
-El lenguaje Fortran no distingue en la sintaxis las
letras mayúsculas y minúsculas salvo en el caso de los literales, y
los signos de la comparación no los suele utilizar.
-Las nuevas versiones de Fortran usan todos los
códigos relacionales pero con la excepción de que forman parte de los
literales.
-Semántica, es lo que define el contenido de
ciertas palabras y un conjunto de palabras reservadas cada una con un
cometido especial. En este lenguaje hay un conjunto pequeño de palabras
reservadas.
-No existen palabras reservadas como tal, sino
palabras clave, sabiendo que cualquier palabra puede ser un identificador
válido.
-Con objeto de dar nombre a las cosas que se
manipulan (Módulo, ficheros estructuras, constantes, etc.) se establecen unas
normas que son:
-El carácter de una palabra debe ser un carácter
alfabético, que aparte de las 52 letras considera como caracteres
alfabéticos los símbolos $ y .
-El número máximo de caracteres que se pueden
utilizar son 31, aunque el compilador sólo reconoce los seis
primeros.
-El nombre de los objetos debe tener un significado
sobre el objeto que se está tratando (Que tenga sentido), se
debe hacer una normalización de los nombres.
FORMATO DEL LENGUAJE FORTRAN.
-El lenguaje Fortran no está formateado. Las cinco
primeras columnas son columnas reservadas para las etiquetas (Un número
desde el uno hasta el 9) y referenciará una línea.
-La etiqueta comprenderá un número del 1 al 99999
entero y sin signo, que deberá ser única y ocupará memoria.
-No tiene por qué estar ordenada pero no se puede
poner una etiqueta más de una vez en un programa (Recomendable colocar
la etiqueta para los formatos).
-La sexta columna irá en blanco y sólo se utiliza
para indicar que la línea que se está tratando es una línea de
continuación (Cualquier carácter es válido).
-Como máximo se pueden continuar 19 líneas de
programa y hay que hacer una indicación.
-Las columnas 7 a 72 sirven para colocar el código
fuente. Todas las sentencias se clasificarán en dos grupos:
-Ejecutables (Especifican la acción y generan una
instrucción).
-No ejecutables (Información y naturaleza de los
datos).
-Las columnas 73 a 80 sirven para realizar todo tipo
de comentarios, entre los cuales pueden figurar:
-Nombre del programador.
-Versión del programa.
-Fecha del programa.
-Descripción del programa.
-E/S del programa.
-Variables y qué representan.
-La primera columna puede llevar un conjunto de
caracteres con un significado especial que serán la c, C, * y el
símbolo $.
-Los comentarios no pueden ir entre líneas de
continuación pero pueden estar en cualquier parte del programa excepto la
anteriormente citada.
TIPOS DE MODULOS.
-Para referenciar un programa principal en Fortran
se utilizará el siguiente formato, teniendo en cuenta que dentro del
programa principal irán las acciones a cumplir:
- PROGRAM Identificador
acción1
acción2
.......
acciónn
END
-El especificador o identificador del programa puede
ser omitido y no es necesario colocarlo dentro de un programa.
-FUNCTION Identificador (Parámetros)
acción1
acción2
.......
acciónn
END
-Se utilizará la estructura de Función cuando se
necesite devolver o no un valor, teniendo en cuenta que la lista de los
parámetros pasados deben ser separados por comas.
-SUBROUTINE Identificador (Parámetros)
acción1
acción2
.......
acciónn
END
-La Subrutina o Procedimiento se utilizará en
aquellos casos en los que se necesite establecer una relación de más de un
tipo de dato. La lista de parámetros pasados deben ser separados por
comas.
-BLOCK DATA Identificador
acción1
acción2
.......
acciónn
END
-Esta estructura representa un conjunto de
instrucciones meramente descriptivas que serán datos comunes o aparte de
los Subprogramas y se pueden inicializar.
-Estos cuatro elementos se pueden colocar a partir
del programa principal o se pueden ejecutar y compilar
separadamente.
-El lenguaje no necesita que una variable esté
declarada anteriormente sino que tienen una declaración implícita (Lo
distingue por la primera letra).
TIPOS DE DATOS.
-Como norma general el lenguaje no utiliza tipos de
datos.
DATOS DE TIPO ENTERO.
-Son todas las variables que comiencen por una letra
que esté en el intervalo I-N, serán variables tomadas como enteras
si no se declara explícitamente de otro tipo o también se pueden
declarar como uno de
los siguientes:
-INTEGER *1 (Asigna al entero un byte de longitud).
-INTEGER *2 (Asigna al entero dos bytes de
longitud).
-INTEGER *4 (Asigna al entero cuatro bytes de
longitud).
-Si después de la palabra reservada INTEGER no se
pone nada la longitud por defecto de la variable declarada serán 4 bytes.
-El separador usado suele ser la coma y para definir
varias variables de tipo entero se pueden usar los siguientes formatos:
-INTEGER *1 Cont, Cont1, Cont2 (Declara 3 variables
enteras).
-Signo 2..36 0..9 ó A..Z .
- Número (Indica base 16 y es perfectamente
válido).
-El segundo formato define un número en otra base
que no sea base decimal, siendo el símbolo el que indica la base en
la que se va ha representar el número.
DATOS DE TIPO REAL.
-Es el número manipulado por excelencia en Fortran.
Hay dos operaciones de tipo general que son la coma fija y la coma
flotante.
-Los formatos que utilizan los números reales
serán:
-Signo parte entera. parte fraccionaria (C. fija).
-Signo parte entera E signo parte fraccionaria (C.
flotante)
-Para declarar una variable de tipo real se usará
uno de los siguientes formatos:
-REAL *4 (Asigna al real cuatro bytes de longitud).
-REAL *8 (Asigna al real ocho bytes de longitud).
-El error que se comete al usar cuatro bytes de
longitud se producirá en las siete u ocho cifras después de la coma.
-Cuando se utiliza un formato de cuatro bytes
estamos ante un número de simple precisión.
-El real declarado como ocho bytes abarca después
de la coma 14 o 15
cifras significativas para la parte entera del
número que es aproximadamente el doble del formato de cuatro bytes.
-Cuando se utiliza un formato de ocho bytes estamos
ante un número de doble precisión.
DATOS DE TIPO COMPLEJO.
-Este tipo de datos consta de una parte real y de
una parte que es imaginaria y en su representación se asumirá la
parte real y se quedará con la parte imaginaria.
-Los formatos que se utilizan para los números
complejos serán:
-Complejo (Real, Imaginario).
-Para declarar una variable de tipo complejo se
usarán uno de los siguientes formatos:
-COMPLEX *4 (Asigna al complejo cuatro bytes de
longitud).
-COMPLEX *8 (Asigna al complejo ocho bytes de
longitud).
-Después de la palabra reservada COMPLEX puede
aparecer un signo, y la parte real e imaginaria irán entre comas).
-Al igual que en otros tipos de datos cuatro bytes
serán simple precisión y ocho bytes serán doble precisión.
DATOS DE TIPO CARACTER.
-Estas variables se representan por la palabra
reservada CHARACTER y el formato que utiliza Fortran para definir las
variables de este tipo son:
-CHARACTER *Número .
-En este formato, número nos indica la longitud en
caracteres de la variable, siendo el tamaño máximo que puede tomar
un campo carácter desde 256 hasta 32767 caracteres.
-Este formato define el tratamiento de cadenas.
DATOS DE TIPO LOGICO.
-Las variables de tipo lógico se representan
mediante la palabra reservada LOGICAL con las variables separadas por
comas y con un formato como el siguiente:
-LOGICAL *2 (Asigna al campo dos bytes de longitud).
-LOGICAL *4 (ASigna al campo cuatro bytes de
longitud).
-Los valores que puede tomar una variable de tipo
lógico son los típicos de True y False.
DATOS DE TIPO REGISTRO.
-Para este tipo de variables tenemos que definir
previamente una estructura y sus correspondientes campos que se van
ha tomar, siendo dicha estructura del tipo:
-STRUCTURE Identificador
CHARACTER *25 Campo1
INTEGER Campo2
REAL Campo3
LOGICAL Campo4
.....................
END STRUCTURE
-La implementación del registro que podría usarse
con la estructura representada podría ser la siguiente:
-RECORD Identificador1 Identificador2 (Número).
-Donde identificador1 representa el nombre de la
estructura creada, identificador2 será el nombre del registro y
Número será el número de elemento del registro.
-Si por ejemplo deseamos referenciar a un real del
registro número 25 tendremos que utilizar la siguiente forma:
-Identificador2 (25).Campo3.
CONSTANTES.
-Para definir una constante en Fortran deberemos
utilizar el siguiente formato:
-PARAMETER (Identificador=constante, ...).
-La lista de constantes irá separada por comas. Las constantes
podrán ser de tipo numérico o de tipo Hollerith (Cadena de
caracteres con cualquier carácter imprimible). También podrán
ser expresiones.
-Las constantes numéricas podrán tener los
siguientes formatos:
-Sin punto decimal ni coma.
-Precedida por un signo, en los enteros.
-Coma fija con punto decimal, en los reales.
-Coma flotante con exponente entero, en los reales.
-Simple precisión (n.m, n., .m, n.mEe, n.E+e, nE+e).
-Doble precisión (n.mD+e, n.De, mDe, nDe).
-Compleja como un par ordenado entre paréntesis.
-Lógicas .TRUE. y .FALSE..
-De caracteres.
-La constante Hollerith podrá tener el siguiente
formato:
-Número H carácter.
-Una constante simbólica definida en PARAMETER
puede aparecer como una expresión o como un valor de DATA.
VARIABLES.
-Para definir una variable el compilador conoce ya
de antemano si la variable va a ser de tipo real o de tipo entera,
siendo por defecto de tipo real.
-La estructura que deberán seguir las declaraciones
de las variables en un programa Fortran será la siguiente:
-PROGRAM Identificador
PARAMETER (Lista de constantes)
*VARIABLES
INTEGER Lista de variables
REAL Lista de variables
COMPLEX Lista de variables
CHARACTER Lista de variables
LOGICAL Lista de variables
RECORD Tipos
*INICIO
.......
-Un atributo es una palabra reservada que acompaña
a la variable y sirve para que el programa realice un mejor
aprovechamiento de memoria, mejor dimensionamiento de arrays dinámicos, etc.
-Si la variable comienza con una letra que se
encuentre en el intervalo I-N se tratará de una variable de tipo entera.
Análogamente si comienza con una letra del intervalo A-H, O-Z se tratará de
una variable real.
-Como norma general, una variable debe ser declarada
antes de que pueda utilizarse. Para inicializar una lista de variables
a determinados valores se usará el siguiente formato:
-DATA Lista de variables, lista de constantes.
-Esta sentencia debe preceder a cualquier sentencia
ejecutable. Una constante seguida de un asterisco indicará
repetición.
EXPRESIONES.
-En las expresiones aritméticas sabemos que si se
realiza una operación de un entero con un real, siempre se codificará el
entero como real y luego se realiza la operación.
-Se convierte el tipo que contiene al otro,
realizándose siempre con la máxima precisión. Los operandos que se van a usar
en las expresiones aritméticas serán los siguientes:
-** (Operador potencia).
-/ (Operador división real).
-* (Operador producto).
-- (Operador resta).
-+ (Operador suma).
-() (Paréntesis).
-Para el uso de operadores relacionales, Fortran no
admite como unos operadores relacionales los signos siguientes:
-<=, >=, <, >, <>.
-Los operadores relacionales que están permitidos
en este lenguaje serán los siguientes:
-.LT. (Operador menor que).
-.LE. (Operador menor o igual que).
-.NE. (Operador distinto de).
-.GT. (Operador mayor que).
-.GE. (Operador mayor o igual que).
-.EQ. (Operador igual que).
-Una expresión relacional compara los valores de
dos expresiones de tipo aritmético o de caracteres y el resultado es de
tipo lógico. Los formatos que puede tomar una sentencia relacional
serán:
-Variable operador variable.
-Variable operador constante.
-Las variables no han de ser necesariamente
variables, también pueden ser expresiones de todo tipo.
-En cuanto a los operadores lógicos que están
permitidos por Fortran se encuentran los siguientes:
-.NOT. (Operador negación).
-.AND. (Operador producto lógico).
-.OR. (Operador suma lógica).
-.XOR. (Operador suma exclusiva lógica).
-.EQV. (Operador de equivalencia lógica).
-.NEQV. (Operador de no equivalencia lógica).
-El resultado de la evaluación de una expresión de
tipo lógico será un valor de tipo lógico, pudiendo ser el formato de la
expresión:
-Operando1 operador operando2.
-El orden de prioridad establecido para la creación
de variables en lenguaje Fortran será por tanto el siguiente:
-Expresiones aritméticas.
-Expresiones de caracteres.
-Expresiones relacionales.
-Expresiones lógicas.
-Para la declaración de variables se utiliza la
palabra reservada IMPLICIT, que toma una variable cualquiera a no ser
que se indique lo contrario. El formato que utiliza la instrucción es
el siguiente:
-IMPLICIT REAL (A-Z).
-El formato anterior indica que todas las variables
que empiecen desde la a hasta la z sean tratadas como reales de forma
implícita. Una variable suele ser tratada siempre como un real.
FINAL DE UN PROGRAMA.
-Hay dos formas de terminar la ejecución de un
programa, lógicamente o físicamente.
-Para terminar la ejecución de un programa
lógicamente se utiliza el siguiente formato:
-STOP Número.
-Número es la constante de caracteres o constante
entera sin signo de cinco dígitos, o puede ser un mensaje de error
encerrado entre dos comillas.
-Para terminar la ejecución de un programa
físicamente se utiliza el siguiente formato:
-END.
ENTRADA Y SALIDA DE DATOS.
-Para la introducción de datos se utiliza la
palabra reservada READ con el formato siguiente:
-READ (Número, Etiqueta).
-Donde número es el número que indica la unidad de
entrada, colocando el valor * si no se quiere poner nada. Etiqueta indica
la etiqueta que va ha definir un formato, si no se quiere poner nada se
usa el valor *.
-Para la lectura de elementos con READ las variables
se separan por un blanco o por comas, si se ha de introducir una frase
o algo de tipo carácter, irá encerrado entre comillas.
-Si no hay suficientes datos para esta instrucción
se produce un error y el programa aborta.
-Para la salida de datos se utilizan dos métodos
igualmente válidos, que son dos palabras reservadas y que tienen el
siguiente formato:
-PRINT *, Lista de variables (Separadas por comas).
-WRITE (*,*), Lista de variables (Separadas por
comas).
-La lista de variables pueden ser tanto variables,
como constantes como expresiones de todo tipo. El cursor avanza a la
siguiente línea. Este tipo de sentencias se suelen incluir antes de una
sentencia READ.
TEMA 2: FUNCIONES INTRINSECAS.
CONCEPTO DE FUNCION.
-Son aquellas funciones incorporadas al compilador,
que son accesibles desde un programa. Pueden ser llamadas en un
programa dando el identificador de la Función seguido por sus
argumentos entre paréntesis.
-Estas funciones pueden tener uno o varios
argumentos y se caracterizan porque:
-El nombre y sus valores de entrada son uno mismo.
-Nunca puede ser usada en el lado izquierdo de la
asignación.
-El nombre determina el tipo de salida de la
Función.
-Los argumentos son del mismo tipo que la Función.
-Los argumentos pueden ser expresiones de todo tipo.
-El formato de la Función será el siguiente:
-Nombre (Identificador1, identificador2, ...,
identificadorn).
FUNCIONES ARITMETICAS.
-Son aquellas que realizan algún tipo de operación
matemática.
-Calcula el valor absoluto de un argumento real y
devuelve un resultado real y positivo:
-ABS (Expresión numérica).
-Convierte un real a un entero truncándolo o
eliminando la parte decimal devuelve un entero:
-Var=INT (Expresión numérica).
-INT (10**VarN*VarX)/10**VarN (N son los decimales a
truncar).
-INT (10**VarN*VarX+0.5)/10**VarN (N son los
decimales deseados).
-NINT (Expresión numérica) (Realiza un redondeo).
-Convierte un número entero a un real:
-FLOAT (Expresión numérica).
-Eleva un número real a la enésima potencia donde
e es la base del logaritmo natural, devuelve un real:
-EXP (Número).
-Var=EXP (Número).
-DEXP (Número) (Donde número es de doble
precisión).
-CEXP (Número) (Donde número es un número
complejo).
-Calcula el logaritmo natural de base e y es la
inversa de la Función anterior, devuelve un real:
-Var=LOG (Expresión numérica).
-Calcula el logaritmo decimal o de base diez del
argumento indicado, devuelve un real:
-Var=LOG10 (Expresión numérica).
-Calcula la raíz cuadrada del argumento indicado,
devuelve un real:
-Var=SQRT (Expresión numérica).
-Devuelve el mayor valor de una serie de argumentos
indicados:
-MAX0 (Lista de identificadores) (Devuelve un
entero).
-AMAX1 (Lista de identificadores) (Devuelve un
real).
-DMAX1 (Lista de identificadores) (Devuelve un doble
precisión).
-Devuelve el menor valor de una serie de argumentos
indicados:
-MIN0 (Lista de identificadores) (Devuelve un
entero).
-AMIN1 (Lista de identificadores) (Devuelve un
real).
-DMIN1 (Lista de identificadores) (Devuelve un doble
precisión).
-Calcula el módulo o resto de dos números,
devuelve un entero:
-MOD (Número1, número2).
-Transfiere el signo del segundo identificador al
primero:
-SIGN (Expresión1, expresión2).
-Convierte un número de doble precisión a un
número real:
-SNGL (Número).
FUNCIONES TRIGONOMETRICAS.
-Son aquellas que realizan alguna operación con las
razones de tipo trigonométrico.
-Calcula el seno de una expresión dada, devuelve un
real y debe estar entre 1 y -1:
-Var=SIN (Expresión numérica) (Devuelve un real).
-DSIN (Expresión numérica) (Devuelve un doble
precisión).
-CSIN (Expresión numérica) (Devuelve un complejo).
-Calcula el coseno de una expresión dada, devuelve
un real y debe estar entre 1 y -1:
-Var=COS (Expresión numérica) (Devuelve un real).
-DCOS (Expresión numérica) (Devuelve un doble
precisión).
-CCOS (Expresión numérica) (Devuelve un complejo).
-Calcula la tangente de una expresión dada,
devuelve un real:
-Var=TAN (Expresión numérica) (Devuelve un real).
-DTAN (Expresión numérica) (Devuelve un doble
precisión).
-Calcula el arcoseno de una expresión dada,
devuelve un real:
-Var=ASIN (Expresión numérica).
-Calcula el arcocoseno de una expresión dada,
devuelve un real:
-Var=ACOS (Expresión numérica).
-Calcula el arcotangente de una expresión dada,
devuelve un real:
-Var=ATAN (Expresión numérica).
-Calcula el seno hiperbólico de una expresión
dada, devuelve un real:
-Var=SINH (Expresión numérica).
-Calcula el coseno hiperbólico de una expresión
dada, devuelve un real:
-Var=COSH (Expresión numérica).
-Calcula la tangente hiperbólico de una expresión
dada, devuelve un real:
-Var=TANH (Expresión numérica).
FUNCIONES DE NUMEROS COMPLEJOS.
-Realiza diferentes funciones con los números
complejos.
-Toma la parte real de un argumento complejo:
-REAL (Expresión compleja).
-Toma la parte imaginaria de un argumento complejo:
-AIMAG (Expresión compleja).
-Calcula el conjugado de un argumento complejo:
-CONJ (Expresión compleja).
-Representa un argumento complejo tomado de números
reales:
-COMPLEX (Número1, número2).
TEMA 3: ESTRUCTURAS DE CONTROL SELECTIVAS Y
REPETITIVAS.
ESTRUCTURAS DE BIFURCACION INCONDICIONAL.
-Este tipo de estructuras son unas herramientas que
sirven para confeccionar las estructuras selectivas. No son
recomendables y sólo se mantienen por compatibilidad con otras versiones.
-La siguiente estructura es un IF aritmético, en el
que se realiza la elección de tres posibles etiquetas. Se evalúa la
condición y en Función de esa condición se tomarán los
siguientes valores:
-Condición <0 toma Etiqueta1.
-Condición =0 toma Etiqueta2.
-Condición >0 toma Etiqueta3.
-En este formato se pueden colocar dos etiquetas
iguales, siendo el formato de la instrucción:
-IF (Expresión aritmética) Etiqueta1, Etiqueta2,
Etiqueta3.
-La siguiente instrucción se usará en el caso de
que haya sentencias repetitivas que no estén implementadas en el
compilador, siendo su misión la de transferir el control a la sentencia
especicada en la etiqueta:
-GOTO Etiqueta.
-La siguiente instrucción transfiere el control a
la etiqueta enésima de la lista según un valor entero. Es el GOTO
calculado.
-En esta sentencia se evalúa la expresión entera
entre uno y el número de etiquetas, y se bifurcará a la etiqueta indicada
para ejecutar un conjunto de sentencias según la expresión entera.
Su formato es:
-GOTO (Etiqueta1, etiqueta2, ..., etiquetan)
Expresión entera.
-La instrucción GOTO asignado tiene como formato el
siguiente:
-ASSIGN Constante entera TO Variable entera.
-GOTO Variable entera (Etiqueta1, etiqueta2, ...,
etiquetan).
-Esta instrucción produce una estructura
multibifurcación. La variable debe tener una de las etiquetas de GOTO y su
funcionamiento es igual que la anterior.
-Para llevar la variable a la etiqueta se usa la
opción de ASSIGN. Si la variable no está asignada el GOTO no es válido.
ESTRUCTURAS ALTERNATIVAS.
-Dentro de las estructuras alternativas hay tres
tipos.
-La estructura alternativa simple, realiza un
conjunto de acciones si la condición es verdadera y sigue el flujo de control
secuencial si la condición es falsa.
-En las estructuras alternativas todas las
condiciones se colocan siempre entre paréntesis. El formato de la
alternativa simple es:
-IF (Expresión lógica) Sentencia.
-La expresión lógica está formada por una
expresión con relacionales y la sentencia a continuación no pueden ser las
palabras reservadas DO, ELSEIF, ELSE, ENDIF, END o IF.
-La estructura alternativa doble, selecciona una de
dos opciones. Si la condición es verdadera se ejecutan unas acciones y
si es falsa otras acciones. El formato de esta estructura sería:
-IF (Condición) THEN
acción1
acción2
.......
acciónn
ENDIF
-Esta última estructura se puede anidar con varias
sentencias IF, y su estructura quedaría:
-IF (Condición) THEN
acción1
acción2
.......
acciónn
ELSE
acciónn+1
acciónn+2
.........
acciónn+n
..............
ENDIF
-Si se quieren anidar varios niveles de sentencias
IF-ELSE usaremos la siguiente estructura:
-IF (Condición) THEN
acción1
acción2
.......
acciónn
ELSEIF (Condición2) THEN
acciónn+1
acciónn+2
.........
acciónn+n
....................
ELSE
acciónm+1
acciónm+2
.........
acciónm+n
ENDIF
-La estructura alternativa múltiple se utiliza
cuando la condición tiene más de dos valores con selección múltiple. El
valor de su expresión a de ser un entero, carácter o lógico.
-Si el carácter utilizado es numérico no irá
entre comillas, mientras que si es de tipo carácter irá entre comillas.
Esta última medida exige que el código ASCII del primer carácter sea menor
que el segundo.
-El formato de la estructura será el siguiente:
-SELECT CASE (Expresión)
CASE (Caso1)
acción1
acción2
.......
acciónn
CASE (Caso2)
acciónn+1
acciónn+2
.........
acciónn+n
...............
CASE DEFAULT
acciónm+1
acciónm+2
.........
acciónm+n
END SELECT
CONCEPTO DE BUCLE.
-Consiste en una estructura de control que gobierna
los procesos de tipo repetitivo dentro de un programa. Repite una
secuencia de acciones mientras o hasta una condición sea verdadera o
falsa.
-Iteración de un bucle es la repetición de
sentencias interiores que hay dentro de un bucle.
ESTRUCTURA REPETITIVA. SENTENCIA "DO".
-Esta estructura contiene dos formatos. El primer
formato se utiliza cuando se conoce el número de iteraciones y su
formato es:
-DO Etiqueta VarA=Inicio, Final, Incremento .
-Las variables se separan por comas y el incremento
puede ser positivo o negativo y es opcional. Normalmente inicio debe ser
menor que la variable final.
-El otro formato es lo mismo que una estructura de
tipo repetir. Se usa cuando se desea repetir una condición un número de
veces siendo una por defecto. Su formato es:
-DO Etiqueta VarA=Inicio, Final, Incremento
acción1
acción2
.......
acciónn
Etiqueta CONTINUE
ENDDO
-Las variables pueden ser enteras, constantes o
expresiones, y es más rápida y potente con variables y constantes con lo
que se evitan los errores de redondeo.
-Como mínimo se ejecuta una vez. Ejecuta un
conjunto de instrucciones hasta que se encuentra a la etiqueta, y si no se usa
la etiqueta se deberá cerrar el bucle con ENDDO.
-Por defecto el incremento del bucle es uno. Si se
usa la etiqueta habrá que tener en cuenta una serie de restricciones:
-No se puede usar un GOTO incondicional o asignado.
-No se puede usar ELSE, IF, SELECT CASE, ENDIF.
-No puede seguirle un ENDSELECT, EXIT, RETURN o STOP.
-Para evitar estas restricciones bastará con
colocar una sentencia en blanco. Si se quiere usar una variable índice
después de salir la variable índice la variable tendrá el valor final
más el incremento.
ESTRUCTURA REPETITIVA. SENTENCIA "WHILE".
-Utiliza una condición que puede ser una expresión
lógica o relacional. Esta condición se evalúa antes y después de cada
ejecución del bucle.
Si la condición es falsa no se ejecuta nunca.
-Los bucles deben terminar siempre y pueden ser
controlados por:
-Contador, necesita una variable dentro del bucle
que se debe inicializar, comprobar e incrementar.
-Centinela, es un valor especial para el final de
una lista y es un valor que jamás se procesa, pero debe ser del
mismo tipo que los datos.
-Interruptor, es una variable lógica.
-El formato de la instrucción será la siguiente:
-DO Etiqueta WHILE (Expresión lógica)
acción1
acción2
.......
acciónn
Etiqueta CONTINUE
ENDDO
-Todas las restricciones anteriormente indicadas
para la otra estructura repetitiva sirven para DO WHILE.
-Si por cualquier circunstancia el compilador no
reconoce este tipo de estructuras se podrá implementar de la siguiente:
-Etiqueta IF (Condición) THEN
acción1
acción2
.......
acciónn
GOTO Etiqueta
ENDIF
-Hay que tener en cuenta que GOTO sólo se usará en
el caso de este tipo de circunstancias y sólamente para ellas.
-Cuando se usen etiquetas, una sóla etiqueta
valdrá para cerrar varios bucles que estén anidados. Pero si se usan ENDDO
hay que colocar tantos como DO hayan.
TEMA 4: ENTRADAS Y SALIDAS CON FORMATOS.
INSTRUCCION CON FORMATO DE ENTRADA. SENTENCIA "READ".
-Este tipo de instrucciones no es muy potente porque
sólo están pensadas para introducir y sacar datos. La unidad estándar
en el teclado está denominado como un asterisco (*).
-La lectura mediante la instrucción READ se realiza
con la siguiente sintaxis:
-READ (Lista de descriptores), Lista de variables.
-La Lista de variables siempre irá separada por
comas.
-Con esta sintaxis la lectura se realiza del
dispositivo predefinido que puede ser uno de los siguientes:
-Constante entera (Que referencia otra sentencia).
-Variable carácter.
-Array de caracteres.
-Expresión carácter (Entre paréntesis y
apóstrofes).
-Variable entera (Con una etiqueta FORMAT).
-Dentro de la lista de descriptores podemos
encontrarnos las siguientes opciones:
-Unidad, que sirve para que a cada dispositivo se le
asigne una unidad o un entero (Sin signo) y la palabra UNIT es
opcional. Si no se coloca UNIT debe ir en primer lugar, si se
pone la palabra reservada UNIT podrá ir en otro lugar. Su sintaxis
es:
- UNIT= Entero.
-Formato, en el que podrán colocarse los siguientes
parámetros:
-Etiqueta, asignada a la sentencia especial que
será FORMAT.
-Variable, entera a la que previamente se le halla
asignado una Etiqueta válida.
-Expresión, de tipo cadena que contenga los
códigos de los formateos entre paréntesis que estarán cerrados
entre unas comillas.
-Variable o array, de caracteres a los cuales se le
hallan asignado los códigos de formato.
-Asterisco (*), que indicará una entrada sin
formato.
sabiendo que el formato estará definido por la
sintaxis:
- FMT= Formato.
-Número de registro, que sólo se usará en el
tratamiento de los archivos de acceso directo, donde se le indica que
lea el número relativo al registro siendo su estructura o
sintaxis:
-REC=Número registro.
-Código chequeador, de la operación al cual
deposita el resultado de analizar la operación siendo su sintaxis:
-IOSTAT=Variable entera.
-Control del fin de archivo, que se especifica con
la sintaxis:
-END=Etiqueta.
-Transferencia de control, que se produce cuando hay
un error y que contiene la siguiente sintaxis:
-ERR=Etiqueta.
-Si se admiten UNIT y FMT, sus correspondientes
valores deberán estar en el primer y segundo lugar de la instrucción READ
respectivamente.
-Los dos primeros formatos se han de usar
obligatoriamente, mientras que los otros parámetros sólo se usarán para ficheros
externos. Un ejemplo de uso de esta sentencia sería:
-READ (UNIT=3, FMT=20, REC=10, IOSTAT=Cod, END=100,
ERR=Error).
-Si la lectura es desde teclado el fin de fichero
debe ser tecleado por el usuario con la combinación CTRL+Z.
INSTRUCCION CON FORMATO DE SALIDA. SENTENCIA "WRITE".
-Para este tipo de instrucciones nos encontramos dos
formatos que están diferenciados:
-PRINT (Lista de descriptores), Lista de salida.
-WRITE (Lista de descriptores), Lista de salida.
-El primer formato siempre se utilizará cuando el
dispositivo de salida esté predefinido por el sistema, mientras que el
segundo formato se usará para una salida a una unidad específica.
-La lista de descriptores que se podrá usar serán
los mismos que en la instrucción READ. UNIT y FMT podrán no figurar si
se pone primero el número de la unidad y luego el formato.
INSTRUCCION DE FORMATOS. SENTENCIA "FORMAT".
-Esta instrucción facilita la información
necesaria para que se haga un reconocimiento de la representación que los datos
van a tomar en la memoria principal. La sintaxis de FORMAT será la
siguiente:
-Etiqueta FORMAT (Lista de código de formato).
-Etiqueta será el número de etiqueta
(Obligatorio), aunque se podrá referenciar también con una variable entera a la
cual se ha asignado una etiqueta con ASSIGN.
-La lista de códigos puede estar vacía si la lista
de sentencias de E/S está vacía con un salto de línea.
-Esta sentencia no es ejecutable, puede escribirse
en cualquier parte y conviene agruparlas todas al principio o al final
del programa.
-La Lista de código de formato podrá contener uno
o varios de los siguientes tipos:
-Códigos numéricos o de datos (Repetibles) entre
los cuales tenemos:
-Código I.
-Código F.
-Código E.
-Código D.
-Código G.
-Código P.
-Código L.
-Código A.
-Códigos de posicionamiento (No repetibles) entre
los cuales tenemos:
-Código X.
-Códigos T, Tl, Tr.
-Código /.
-Códigos especiales (No repetibles) entre los
cuales tenemos:
-Códigos S, Sp, Ss.
-Códigos Bn, Bz.
-Código H.
-Código :.
-Código .
-Códigos de control de carro.
CODIGO NUMERICO "I".
-En los códigos de datos o numéricos siempre hay
que diferenciar tres partes que son fundamentales:
-Tipo de dato a representar.
-Tamaño para la representación.
-Puntos y tamaños de la parte fraccionaria.
-Entre los códigos numéricos existen una serie de
características:
-Los blancos de relleno son ignorados.
-Si el signo es negativo se genera el signo -.
-Tiene prioridad el punto decimal de entrada ante la
posición decimal especificada.
-Los campos se ajustan a la derecha.
-Si se produce error de salida salen asteriscos.
-Para la entrada de este código los datos deben ser
de tipo entero, siendo I el identificador de código y w el ancho
del campo y la sintaxis:
-Iw.
-Transfiere datos enteros desde el soporte externo a
variables, tantos caracteres como valor tenga w contando dígitos,
blancos y signos y asocia variables de izquierda a derecha con las
normas siguientes:
-Blancos entre dígitos o al final se interpretan
como ceros.
-No usan código de formato cuando la lectura es por
teclado.
-Con Bn los blancos se ignoran y con Bz se toman
como ceros.
-Para la salida los datos van desde la memoria
interna al soporte externo con un valor w de ancho ajustándose a la
derecha y si es negativo se coloca un signo delante del dígito más
significativo.
-Si el número de caracteres es mayor que el ancho
de salida el campo de salida se llena de asteriscos.
-Si se utiliza un coeficiente de repetición n
deberá ser una constante entera sin signo mayor que cero con la sintaxis:
-nIw.
-Si se quiere indicar el número mínimo de dígitos
que aparecerán en la salida se usará m, una constante entera sin signo
con la sintaxis:
-nIw.m.
-Se debe contemplar la opción de que el número sea
negativo con lo que se deberá aumentar el formato en una unidad.
-Si en la salida se colocan menos dígitos que en el
formato indicado se suprimirán todos los ceros que no sean
significativos.
CODIGO NUMERICO "F".
-Este código transfiere datos de tipo real desde un
dispositivo externo hasta la memoria o a la inversa, siendo su sintaxis
la siguiente:
-Fw.d.
-En este código, F será el carácter del código,
w será la longitud total del campo incluyendo los blancos, signos, puntos y
dígitos, y d será el número de decimales de la parte real.
-Si no se introduce un punto decimal se sitúan los
decimales de forma automática. El código F permite ser un código
repetible con lo que su sintaxis será la siguiente:
-nFw.d.
-Se pueden introducir números reales en notación
exponencial, siendo el exponente que sigue al número real de dos formas:
-Constante entera con signo + o -.
-Carácter E o D seguido de un signo y una constante
entera.
-Los caracteres de las variables reales se ajustan a
la derecha del campo de anchura. El punto decimal se genera con d
posiciones a la derecha.
-En la salida no se producen ceros a la izquierda a
no ser que la mantisa sea menor que uno, con lo que habrá un cero
a la izquierda del punto decimal.
-Si la parte fraccionaria tiene más anchura que d
habrá un redondeo del valor antes de ajustarse y si el dato no cabe en w
se producirá una salida de w asteriscos.
-Entre los ejemplos que se pueden citar para este
formato estarán:
CODIGO NUMERICO "E".
-Este formato lee o escribe datos reales en simple o
doble precisión en notación exponencial. E es el código del
exponente, w el ancho del campo y d los dígitos decimales con una sintaxis
del tipo:
-Ew.d.
-La opción w contará la mantisa, el dígito que
precede al punto decimal el punto decimal de la mantisa y el exponente que
tendrá tres dígitos de forma que la representación será del tipo:
-(-)0.E(-)nn.
-Si el punto no figura en la entrada, la parte
decimal serán los d
dígitos más a la derecha de la mantisa. Si aparece
el punto decimal
en la entrada no se tendrá en cuenta la
especificación d en el formato.
-El signo del exponente se omite si es positivo y E
o D pueden omitirse si el exponente tiene signo. Es recomendable
especificar el punto decimal en la entrada.
-Para la salida han de reservarse una posición para
el punto decimal y el dígito cero que precede al punto decimal si hay
posición para él. Si la mantisa es negativa otra posición y el exponente
cuatro posiciones.
-Se ejecuta la anchura del campo a la derecha y si w
es menor que las posiciones para la salida se muestran asteriscos.
-En Función del desplazamiento del punto decimal se
calcula el exponente y la mantisa se puede redondear, pudiéndose omitir
el cero antecedente al punto decimal si no hay posición.
-El código E puede ser repetible con la siguiente
sintaxis:
-nEw.d.
-Otro formato en el que una constante entera e nos
indica el número de dígitos del exponente sería:
-Ew.dEe.
-Entre los ejemplos que se pueden citar para este
formato estarán:
CODIGO NUMERICO "D".
-Describe números reales en simple o doble
precisión en forma exponencial con el mismo efecto que el código E
siendo su sintaxis:
-Dw.d.
-Para la entrada de datos este código es tratado de
igual manera que el código E. Normalmente se utiliza este código para
enfatizar que el número que se trata es de doble precisión.
-El exponente para la salida cambia la letra E por
la letra D y tiene la siguiente sintaxis:
-D(+/-)nn.
-Este código numérico es repetible siendo su
sintaxis:
-nDw.d.
CODIGO NUMERICO "G".
-Se utiliza este código para entrada y salida de
datos de simple y doble precisión siendo sus sintaxis más generales las
siguientes:
-Gw.d.
-Gw.dEe.
-La entrada de datos reales tiene el mismo
significado que los códigos
F, E y D.
-En la salida actúa como formato F cuando el valor
de salida está en el rango entre 0.1 y 10**d, mientras que actúa como
formato E cuando el número es más pequeño de 0.1 o mayor que 10**d.
-Si actúa como formato F entonces los últimos
cuatro caracteres serán blancos y el valor se imprimirá en un ancho de
campo de w-4 caracteres.
-Si se usan formatos a la entrada y se coloca un
punto decimal cuando el formato es distinto, habrá disyunción entre el
formato del teclado y el establecido en el programa.
-Siempre se da prioridad al formato introducido por
teclado.
-Entre los ejemplos que se pueden citar para este
formato estarán:
CODIGO DE DATOS "P".
-Es un factor de escala y sirve para ver los valores
exponenciales con un entero delante del punto decimal, aplicable
sólamente a los códigos F, E, D y G, afectando a la entrada de datos y a su
salida.
-El valor n será un entero que puede llevar signo y
su sintaxis será:
-nP.
-Al aplicar el código P en la entrada sólo es
aplicable si el valor externo carece de exponente con lo que se expresará
mediante la relación:
-Valor interno=(Valor externo)/10n.
-El factor de escala afecta a los códigos de
formato que aparecen a continuación hasta encontrar otro factor de escala.
-Cuando se usa para el código F en la salida se
produce desplazamiento del punto en el valor verdadero siendo su relación:
-Valor externo=Valor interno*10n.
-Si se usa en concexión con D o E la salida no
cambia pero se desplaza el punto de la mantisa al hacer el producto por
10**n, y el exponente se decrementa en n, al igual que con la forma
mantisa-exponente.
-Con el formato G no se usa el factor de escala
porque da problemas.
-Si tenemos las siguientes instrucciones:
-100 FORMAT (2PE7.2, F6.3, -1P8.4)
READ (5, 100) VarA, VarB, VarC
WRITE (*, '(1X, 3F12.5)') VarA, VARB, VarC
y le introducimos la siguiente entrada:
-b17.E0157.132-453261.7.
tendremos la siguiente tabla de referencia:
CODIGO DE DATOS "L".
-Este código se usa para la edición de datos
lógicos siendo w el ancho del campo y siendo su sintaxis la siguiente:
-Lw.
-Para la entrada busca en el campo de forma que si
el primer carácter es T (True) o F (False) los demás caracteres del
campo son ignorados.
-Para la salida se produce una conversión de TRUE a
FALSE o T a F ajustándose a la derecha del campo.
-El código L es un código de tipo repetible siendo
su sintaxis:
-nLw.
CODIGO DE DATOS "A".
-Este código transfiere datos de tipo carácter de
la memoria al soporte externo y a la inversa, permitiendo el manejo,
entrada y salida de cualquier variable de tipo carácter, siendo su
sintaxis:
-Aw.
-También tiene formato repetible siendo su
sintaxis:
-nAw.
-En las entradas se debe colocar apóstrofes que
delimiten la cadena si es con lista directa, pero con el código A puede
evitarse y tomará la longitud de la variable asociada teniendo en cuenta:
-Si w=n todo el dato es asignado a la variable
carácter.
-Si w>n los últimos n caracteres se almacenan en
la variable.
-Si w<n los caracteres se ajustan a la izquierda
rellenándose los
n-w caracteres de la derecha a blancos.
-En las salidas existen otras consideraciones:
-Si w=n tendrá de longitud n.
-Si w>n los n caracteres se ajustan a la derecha
y los w-n primeros caracteres se rellenan a blancos.
-Si w<n los w primeros caracteres de la cadena
salen a la salida perdiéndose los restantes.
CODIGO DE POSICIONAMIENTO "X".
-Los códigos de posicionamiento determinan la
posición dentro de una línea. La posición puede ser relativa a la actual
del cursor o una posición absoluta.
-El código X salta n caracteres tanto para la
salida como para la entrada en el medio externo siendo su sintaxis:
-nX.
-La opción n indica los caracteres a saltar a
partir de la posición actual del cursor.
-Para la entrada salta n posiciones hacia adelante
desde la posición del cursor. Para la salida en la línea o registro
de salida genera n blancos y mueve el cursor n posiciones a la derecha.
-Este código no es repetible.
CODIGOS DE POSICIONAMIENTO "T", "Tl"
Y "Tr".
-Estos códigos producen una tabulación en el
registro y T especifica una posición absoluta dentro del registro de
entrada o salida siendo su sintaxis:
-Tc.
-La opción c indica la columna dentro del registro
desde donde se va a posicionar el cursor y donde comienzan las
transferencias de datos.
-El tabulador Tl mueve la posición del cursor hacia
la izquierda y Tr mueve la posición del cursor hacia la derecha con
las siguientes sintaxis:
-Tls.
-Trs.
-La opción s indica el número de posiciones que se
han de desplazar el cursor desde la posición actual.
-Si tenemos las siguientes instrucciones:
-50 FORMAT (2A, I2, T1, A, T18, A, I2)
CHARACTER *6 Nombre1, Nombre2, Apellido1*8,
Apellido2*8
INTEGER Edad1, Edad
READ (1, 50) Nombre1, Apellido1, Edad1, Nombre2,
Apellido2, Edad y le introducimos la siguiente entrada:
-José-Martinez8Torralva25.
obtendremos la siguiente lista de variables en la
salida:
-Nombre1 - José-.
-Apellido1 - Martínez.
-Edad1 - 0.
-De modo análogo, si tenemos las siguientes
instrucciones:
-100 FORMAT (T8, I5, Tl2, I4, Tl6, A6)
CHARACTER *8 Cadena
INTEGER VarA, VarB
READ (*, 100) VarA, VarB, Cadena y le introducimos la siguiente entrada:
-Visita12345678.
obtendremos la siguiente lista de variables en la
salida:
-M - 23456.
-N - 5678.
-Cadena - 345678.
-Estos códigos no son repetibles.
CODIGO DE POSICIONAMIENTO "/".
-Este es un código de posicionamiento vertical que
da por terminado un registro o deja registros o líneas vacías y su
sintaxis es:
-/.
-Puede separase por comas o no y sitúa el puntero
en el primer carácter de un nuevo registro.
-En la salida causa n-1 registros o líneas vacías
y no es un código de tipo repetible.
CODIGOS ESPECIALES "S", "Sp" Y
"Ss".
-Estos códigos sólo son válidos para formatos de
salida, para números y controlan la salida del signo + en los números
positivos de forma:
-S no imprime el signo +.
-Sp imprime el signo +.
-Ss no imprime el signo +.
-El formato Sp sólo valdrá hasta que sea el final
de los especificadores de formato o hasta un código S o Ss.
-Estos códigos no son repetibles.
CODIGOS ESPECIALES "Bn" Y "Bz".
-Estos códigos dirigen la interpretación de los
caracteres en blanco en los formatos numéricos de forma que:
-Bn ignora los blancos.
-Bz toma los blancos como ceros.
-Si un campo de entrada está en blanco se considera
como cero.
CODIGO ESPECIAL "HOLLERITH".
-Este código sólo puede formar parte de un formato de salida y
no es válido para entradas, siendo su sintaxis:
-wHc.
-Este código indica que habrá una salida de w
caracteres que son los que van a aparecer en c. Los apóstrofes se
consideran como cualquier otro carácter.
-El número de caracteres de la constante carácter
determina el ancho del campo de salida.
CODIGO ESPECIAL ":".
-Este código provoca la terminación de la
operación de salida si no hay más elementos en la lista de la sentencia de
salida.
-Si el código es encontrado durante una entrada de
datos o si quedan elementos en la lista de salida es ignorado.
CODIGO ESPECIAL " ".
-Este código facilita formatear la salida de datos
en la pantalla. Este código se aplica en formatos de sentencias de
salida.
-Causa que el procesador suprima en la salida de
acceso secuencial la separación de registros actual y el siguiente
registro.
CODIGOS ESPECIALES DE CONTROL DE CARRO.
-Exigen que se escriban los códigos como primer
carácter dentro de la
sentencia WRITE que emplea la impresora como salida
siendo sus códigos los siguientes:
-Blanco avanza una línea.
-0 avanza dos líneas.
-1 sitúa en la primera línea de la siguiente
página.
-+ imprime sobre la misma línea y no avanza.
-Si el primer carácter no es un signo de estos se
toma como blanco. En la mayoría de las sentencias FORMAT tiene
especificado en la columna 1 o 1X.
REGISTROS MULTIPLES.
-Si el número de elementos de la lista de entrada y
salida es menor que el número de códigos de datos, los códigos
sobrantes se ignoran.
-Si el número de elementos es mayor que el número
de códigos de formato se van asociando los códigos de datos con los datos
de izquierda a derecha.
-Cuando se alcanza el paréntesis de cierre de
FORMAT se empieza un nuevo registro repitiéndose los códigos a partir del
paréntesis de apertura precedente.
TEMA 5: SUBPROGRAMAS Y FUNCIONES EN FORTRAN.
UNIDADES DE PROGRAMA.
-Ante la necesidad de una organización jerárquica
Fortran permite dividir el programa en módulos llamados unidades de
programa. Hay dos clases de unidades de programa:
-Programa principal.
-Subprograma.
-Cada programa tiene un sólo programa principal que
puede contener cero o más Subprogramas que pueden ser:
-Funciones.
-Subrutinas.
-Las Funciones pueden ser de varios tipos:
-Externas, es un módulo independiente.
-Intrínsecas, es un módulo independiente.
-Unilíneas, son locales al módulo o unidad de
programa donde están definidas.
-Las Subrutinas son Subprogramas que pueden ser
usados para devolver un conjunto de cero a n datos y suelen ser de
propósito general.
-Los módulos pueden estar uno a continuación del
otro y no estarán separados a nivel lógico aunque sí lo estarán a
nivel físico.
-La Función se usa cuando se necesita devolver un
sólo valor, mientras que las Subrutinas se utilizan para devolver más
valores o en su defecto ninguno.
FUNCIONES SENTENCIA (UNILINEA).
-Es un procedimiento especificado en una sentencia
simple, con forma similar a una sentencia de asignación aritmética,
lógica o carácter.
Este tipo de Funciones representan una fórmula.
-Se escribe en la misma unidad de programa que va a
ser usada, son locales a la unidad de programa en la que está
definida.
-Es una sentencia de tipo no ejecutable y ha de ser
escrita antes de ser invocada, su sintaxis suele ser:
- Tipo Identificador (Lista de parámetros
actuales)=Expresión.
-Si no se colocan parámetros, habrá que poner
paréntesis igualmente.
-El tipo de dato del identificador de la Función
sentencia y los argumentos ficticios están determinados por el tipo
implícito del identificador.
-La invocación se realiza escribiendo su
identificador y entre paréntesis los argumentos verdaderos o actuales que
sustituyen a los argumentos que son ficticios.
-Los argumentos actuales pueden ser expresiones y
han de corresponderse en número, orden y tipo con los argumentos
ficticios. La llamada a la Función debe formar parte de una sentencia
ejecutable.
-Se puede invocar el paso de varios parámetros
separados por una coma o no ser invocados.
FUNCIONES INTRINSECAS.
-Son las Funciones propias del lenguaje Fortran, que
ya fueron descritas en el tema 2.
-Estas Funciones se usan con el identificador de la
Función seguido de los valores de los parámetros.
-Habrá que tener en cuenta que los argumentos sean
del mismo tipo y que correspondan dentro del rango.
FUNCIONES EXTERNAS.
-Este tipo de Funciones devuelve un valor a través
del identificador de la Función aunque puede devolver otros valores. Su
sintaxis es:
- Tipo FUNCTION Identificador (Lista de parámetros
formales)
acción1
acción2
.......
acciónn
Identificador=Expresión
.......
RETURN
END
-El tipo es opcional y especifica el tipo de datos
del valor que se devuelve. Si no se especifica se siguen las normas
del tipo implícito de los identificadores.
-Esta sentencia debe ser la sentencia inicial de una
Subrutina FUNCTION.
El tipo de la Función está determinado por la
especificación tipo en la cabecera.
-Puede tener cualquier sentencia excepto las
definiciones de otras Subrutinas. El valor asignado debe ser del mismo
tipo que el de la Función.
-El fín lógico de una Función es RETURN que puede
aparecer más veces.
La última sentencia de código fuente de
definición de una Función es END que será el fín físico.
-Desde una Función se puede invocar otra Subrutina
pero no a la misma Función y no se permite la recursividad.
LLAMADA A FUNCIONES EXTERNAS.
-La llamada a una Función ha de formar parte de una
sentencia siendo la sintaxis de la llamada la siguiente:
-Identificador (Lista de parámetros actuales).
-La referencia a la Función se puede realizar desde
cualquier otra unidad de programa. La lista de parámetros deberá
estar separada por comas.
-Los parámetros se pueden pasar por valor colocando
la palabra reservada VALUE delante de las variables. No se debe modificar
los valores de las variables de la lista. Es mejor duplicarlos o
protegerlos.
-Los parámetros actuales deben coincidir con los
argumentos ficticios con las siguientes especificaciones:
-Constantes, variables o expresiones, excepto la
concatenación de operandos.
-Nombre de array.
-Funciones intrínsecas o externas.
-Subrutinas.
PASO DE ARGUMENTOS A LAS SUBRUTINAS.
-Las llamadas por valor realizan unas copias del
argumento verdadero con lo que éste no cambia durante la ejecución de
la Subrutina.
-Las llamadas por referencia no realizan esa copia y
el argumento verdadero puede cambiar durante la ejecución de la
Subrutina.
-Para saber cuando se deben pasar valores por valor
o referencia nos fijaremos en la siguiente tabla:
-Por referencia si es una variable, array, elemento
de array o caracteres.
-Por valor si es una constante o una expresión.
SUBRUTINAS.
-Las Subrutinas empiezan con la sentencia SUBROUTINE
y puede tener cualquier sentencia excepto las usadas para definir
otros módulos o unidades de programa.
-Puede devolver cero, uno o más valores siendo la
transmisión por parámetros de cabecera. La ejecución termina con
un fín lógico o RETURN siendo la última sentencia el fín físico o END.
-Si sólo hay un RETURN se puede omitir porque END
funcionará como si fuera RETURN. La sintaxis de las Subrutinas es:
-SUBROUTINE Identificador (Lista de parámetros
formales)
acción1
acción2
.......
acciónn
RETURN
.......
END
-El identificador del procedimiento ha de ser
único, el primer carácter debe ser una letra.
-En la Subrutina no se asocia un valor al
identificador de la misma, devuelve los datos de salida modificando sus
argumentos si son:
-Nombres de variable.
-Nombres de array.
-Subrutinas ficticias.
-Asteriscos.
-El tipo de los argumentos se especifica explícita
o implícitamente. El argumento array se define con un tamaño fijo,
anidado o ajustable.
-El argumento asterisco se usa para la salida
múltiple de una Subrutina no permitiendo la autollamada o la recursión.
LLAMADA A SUBRUTINAS.
-Una Subrutina puede ser invocada desde otra
Subrutina o unidad de programa principal con la siguiente sintaxis:
-CALL Identificador (Lista de parámetros actuales).
-Los argumentos deben coincidir en orden y tipo con
los argumentos ficticios de la Subrutina referenciada. La
ejecución de CALL causa que el control de la ejecución pase a la Subrutina
referenciada.
-Los argumentos de CALL pueden ser:
-Expresiones.
-Arrays.
-Subrutinas.
-El argumento correspondiente al asterisco ha de ser
del tipo *N siendo N una etiqueta de una sentencia ejecutable. Los
valores se transmiten por referencia.
-Un ejemplo de la utilización de Subrutinas podría
ser:
-CHARACTER *20 Cab
REAL Gwr
PARAMETER (Cab='Especificación de la gravedad')
Gwr=9.82337
WRITE (*, *) Cab, Gwr
CALL Lista (Cab, Gwr)
WRITE (*, *) Cab, Gwr
SUBROUTINE Lista (Título, Datos)
CHARACTER *20 Título
REAL Datos
Título='Densidad Kg/cm'
Datos=0.57975
WRITE (*, *) Título, Datos
RETURN
END
-El resultado que proporcionará el anterior trozo
de código será un resultado imprevisible, puesto que no se puede
modificar una constante a una variable.
-La relación general para el paso de parámetros
será la siguiente:
Parámetros actuales Parámetros formales
Variables Nombre variable
Elementos de array Nombre variable
Estructuras Nombre variable
Expresiones Nombre variable
Arrays Array
*Etiqueta Etiqueta
Subrutinas Nombre único
Funciones Nombre único
SENTENCIAS "EXTERNAL" E
"INTRINSIC".
-Estas sentencias se usan para cuando el argumento
es el identificador simbólico de un Subprograma o Función.
-La sentencia EXTERNAL declara que un identificador
es un nombre de una Función externa o de una Subrutina. No es una
sentencia ejecutable y debe aparecer antes del código de sentencias
ejecutables.
-La sintaxis de EXTERNAL es:
-EXTERNAL Identificador1, Identificador2, ...,
Identificadorn.
-La sentencia INTRINSIC declara que un identificador
es nombre de una Función intrínseca, apareciendo el identificador
en la sintaxis:
-INTRINSIC Función1, Función2, ..., Funciónn.
-Las Funciones intrínsecas que no pueden ser
argumentos actuales de las Subrutinas son los siguientes:
-De conversión de tipos, INT, IFIX, IDINT, FLOAT y
CHAR.
-Lexicográficas, LGE, LGT, LLE y LLT.
-De máximos y mínimos.
ENTRADA MULTIPLE A UNA SUBRUTINA. SENTENCIA
"ENTRY".
-Sirve para que el comienzo de una Subrutina sea en
una sentencia específica contenida en la Subrutina. Puede estar
en cualquier punto del programa excepto dentro de un bloque IF o DO.
-Esta sentencia es de tipo no ejecutable siendo su
sintaxis:
-ENTRY Identificador (Lista de parámetros
actuales).
-Los identificadores simbólicos de varios puntos de
entrada tienen que ser diferentes entre sí y del nombre del
procedimiento.
-Un punto ENTRY se referencia desde otro módulo. El
proceso prosigue hasta encontrar un RETURN.
SALIDA MULTIPLE DE UNA SUBRUTINA. SENTENCIA
"RETURN N".
-Esta sentencia causa que el control de la
ejecución retorne a la unidad de programa desde donde se invocó. La sintaxis es
la siguiente:
-RETURN n.
-La especificación n se usará en una Subrutina,
para devolver el control a una sentencia específica, sin ser la siguiente a
la llamada.
-El valor de n ha de estar comprendido entre uno y
el número de asteriscos de la cabecera de la Subrutina.
TEMA 6: VECTORES Y MATRICES (ARRAYS).
ARRAYS UNIDIMENSIONALES.
-Consiste en una lista de un número finito de datos
del mismo tipo que se referencian por un identificador común y un
número de orden que son consecutivos.
-Las variables que representan los arrays se
denominan variables de subíndice. El tamaño de un vector es el número de
elementos que componen el vector. Una variable de subíndice tiene
el formato:
-Variable (Subíndice).
-La variable puede ser un array de los siguientes
tipos:
-Numérico.
-Cadena.
-Lógico.
-Complejo.
-El subíndice puede ser:
-Constante numérica.
-Variable.
-Expresión matemática.
-Para saber una determinada posición de un elemento
se deben cumplir las siguientes características:
-Todos los elementos del array son del mismo tipo.
-El vector tiene un nombre único y los elementos
están ordenados por el subíndice.
DECLARACION DE UN ARRAY. SENTENCIA
"DIMENSION".
-Hay dos formas de definir un vector o matriz,
utilizando la forma común a todas las versiones cuyo formato será:
-DIMENSION Identificador1 (Mínimo:Máximo), ...,
Identificadorn
(Mínimo:Máximo).
-El número de elementos que obtendremos vendrá
dado por la fórmula Máximo-Mínimo+1, sabiendo que máximo deberá ser
mayor o igual que el valor de mínimo.
-El identificador es una variable con las mismas
reglas. Opcionalmente se puede colocar después del Identificador un alias
o ALLOCATE que se usará cuando estemos en tiempo de ejecución. Como
ejemplos:
-ALLOCATE Array (Valor).
-DIMENSION Array (11:25).
-DIMENSION (14).
-Array (:).
-Lo que indica la opción ALLOCATE es que el valor
de sus subíndices se va a dimensionar durante la fase de ejecución.
-El subíndice izquierdo puede tomar los valores
cero, negativo o positivo al igual que el subíndice derecho, pero
éste último debe ser igual o mayor que el subíndice izquierdo.
-No se puede modificar la dimensión una vez
definida, y es necesario colocar corchetes para definir un array en tiempo de
ejecución.
-En el ejemplo siguiente se declara un array de una
dimensión que se dimensionará posteriormente:
-DIMENSION Array ALLOCATE (:).
-Para desasignar el array y liberar la memoria se
utilizará la opción DEALLOCATE como sigue:
-DEALLOCATE Array (Valor).
-Las dimensiones se separan por comas y se pueden
definir como máximo siete dimensiones, aunque pueden ser más
dependiendo de la memoria del ordenador.
-Si el límite es uno se puede omitir el valor de
mínimo, quedando la sintaxis siguiente:
-DIMENSION Identificador1 (Máximo), ...,
Identificadorn (Máximo).
-La segunda forma de definir vectores es con la
especificación de tipos de sintaxis:
-Tipo Identificador (Mínimo:Máximo).
-Tipo es cualquiera de los tipos definidos en
Fortran. Mediante esta forma se asocia el tipo de dato al identificador y
definirlo como un array con tantos elementos como haya.
-Los límites inferiores y superiores son
expresiones enteras siempre con constantes nunca variables.
-Otros atributos que podemos colocar después del
identificador son:
-REFERENCE.
-C.
-PASCAL.
-VALUE.
-Se usarán estas opciones cuando se va a pasar el
array por parámetro a otros lenguajes, por lo que habrá que normalizar el
lenguaje.
-Los arrays se almacenan en la memoria de una forma
distinta que en otros lenguajes, ya que se almacenan columnas a
columnas unas a continuación de otras.
-Se almacenan en orden creciente de sus subíndices
a partir de una posición determinada. Para sacar los elementos por
filas se usará el DO implícito.
OPERACIONES CON ARRAYS Y ELEMENTOS DE UN ARRAY.
-Hay dos tipos de operaciones básicas, con los
elementos que serán las mismas que permiten los tipos de datos o con
estructuras como el recorrido de un array.
-Para hacer el recorrido de un array se usará una
estructura del tipo FOR como:
-DO Etiqueta VarA=Izquierdo, Derecho
acción1
acción2
.......
acciónn
Etiqueta CONTINUE
ENDDO
-Se puede leer o escribir un array completo con
sólo poner el Identificador del array en la sentencia de E/S.
-Se puede inicializar un array completo con sólo
poner su identificador y los valores que se inicializan en la sentencia
DATA.
-Consiste en obtener datos de un dispositivo externo
y almacenarlos en un vector o escribir en un dispositivo los datos de
un array.
-La E/S puede realizarse con el identificador del
array y por tanto
se procesa en total o elemento a elemento con un DO
implícito o explícito.
ENTRADA Y SALIDA DE ARRAYS CON DO
"IMPLICITO".
-Se utiliza en vez de la estructura de tipo FOR.
Esta estructura está ya definida y hace sencilla la manipulación de los
arrays en la lectura y escritura.
-Con este tipo de DO se ejecuta una sóla vez la
sentencia READ de modo que se lee un sólo registro físico. Su sintaxis
es:
-READ (*, *) (Identificador (VarA), VarA=Inicio,
Final, Incremento).
-Cuando el incremento es uno se puede omitir.
También puede emplearse para acceder a los elementos de un array de más de
una dimensión para leer o escribir e inicializar.
-El DO implícito se puede anidar con tantos niveles
como sea necesario o tantos niveles como dimensiones tenga el array.
-Un ejemplo del uso del DO implícito sería:
-READ (*, *) (Array (VarA), VarA=1, 20).
-El ejemplo anterior lee veinte variables
estableciéndose un bucle. Otro ejemplo:
-READ (*, *) (Array (VarA), VarA=Izdo, Dcho, Paso).
-En el ejemplo anterior Paso indica que la variable
toma el valor de izdo y sus sucesivos valores repitiendo el proceso
hasta que dcho tiene mayor valor que izdo.
-Pero si paso es negativo entonces dcho ha de ser
menor forzosamente. El siguiente ejemplo tendría como representación con
DO la siguiente:
-READ (*, 100) (Array (VarA), VarB=1)
READ (*, *) ((Array (VarA, VarB), VarB=1, VarC),
VarA=1, VarD)
-DO VarA=1, VarD
DO VarB=1, VarC
READ (*, *) (Array (VarA, VarB))
ENDDO
ENDDO
PASO DE ARRAYS POR PARAMETRO.
-El paso de un array se realiza por referencia y
cuando un array es pasado, en realidad se pasa la dirección en memoria
del primer elemento ahorrándose memoria y espacio.
-Un ejemplo de ello es el siguiente:
-REAL Array (100, 200), VarA, VarB
CALL Lista (Array, VarA, VarB)
SUBROUTINE Lista (Arrayauxiliar, VarC, VarD)
-En la definición de los argumentos ficticios para
los arrays en las Subrutinas o Funciones, no es necesario que sean
iguales los límites superior e inferior de cada dimensión con los
límites del argumento actual del array transmitido.
-Siempre se exige que una variable sea dimensionada
por lo que dentro de la Subrutina se colocará la siguiente
declaración:
-REAL Arrayauxiliar (100, 200).
-En esta Subrutina no se crea la variable
arrayauxiliar sino que se define dicha variable. El array en esa declaración
se puede ajustar siempre que la dimensión sea menor que la declarada
anteriormente.
-En todo caso el tamaño del argumento ficticio para
el array no puede ser mayor que el del argumento actual.
-Se puede poner un asterisco que es la opción por
defecto y que indica que toma el valor de la dimensión iniciada en el
programa principal.
ARRAYS DE TAMAÑO AJUSTABLE Y TAMAÑO ASUMIDO.
-El argumento ficticio array en la Función Máximo
su tamaño se ajusta a N elementos que es un dato transmitido, y por
tanto la definición de arrays ajustables.
-La definición de un argumento ficticio array de
tamaño ajustable en una Función o en una Subrutina es la única
situación en la que una definición de array puede incluir una variable en
la especificación del rango de cada dimensión.
-Para definir un argumento ficticio array como
asumido se especifica el límite superior de la última dimensión del array
con un asterisco. El número de elementos del array ficticio es el mismo
que el array pasado por parámetro.
-Sólo se puede especificar el límite superior de
la última dimensión con un asterisco, aunque para los caracteres
también es válido.
-Para las Funciones carácter externas usaremos la
siguiente sintaxis:
-CHARACTER * (*) FUNCTION Identificador (Lista de
parámetros).
TEMA 7: SENTENCIAS ESPECIALES DE FORTRAN.
SENTENCIA "EQUIVALENCE".
-Esta sentencia declara que dos o más
identificadores son equivalentes y al menos dos. Hace que compartan la misma
posición de almacenamiento que puede ser referenciado de más de una forma.
-La sintaxis de esta orden es la siguiente:
-EQUIVALENCE (Lista de Identificadores).
-En una misma sentencia EQUIVALENCE pueden haber
más de una lista de identificadores, cada una de las cuales se refiere a
la misma posición de almacenamiento:
-EQUIVALENCE (Lista de Identificadores),
+ (Lista de Identificadores).
-Las variables de distinto tipo pueden hacerse
equivalentes, de forma que habrá almacenamiento compartido pero no una
posible conversión de tipos.
-La sentencia de almacenamiento de los
identificadores de la lista comienza con la primera unidad de almacenamiento de
las entidades de la lista.
-Se pueden hacer equivalentes los arrays y los
elementos de los arrays.
Los índices de las variables array escritos en una
lista de la sentencia deben ser constantes o expresiones
formadas por constantes.
-En una sentencia EQUIVALENCE no puede provocarse
que una misma variable ocupe dos posiciones de memoria distintas.
-Esta sentencia puede utilizarse entre variables o
arrays de tipo carácter aunque sus longitudes no sean las mismas.
-Las variables carácter equivalentes tendrán el
mismo primer carácter ubicado en la misma posición de memoria.
-En Fortran 77 no está permitido hacer equivalentes
variables de tipo carácter con variables numéricas, y los nombres de
Función no pueden hacerse equivalentes con otra entidad.
-Esta sentencia se suele utilizar cuando la memoria
de que se dispone es muy pequeña, pero produce que la lógica del
programa pueda acceder a la variable correcta.
SENTENCIA "COMMON".
-Una forma de comunicarse entre el programa o Unidad
de programa que llama a una Subrutina o Función, y la Subrutina o
Función llamada, es a través de la lista de argumentos.
-Con estos argumentos se referencian zonas de
memoria comunes desde distintas Unidades de programa, la Unidad de
programa que llama y la Unidad llamada.
-Con esta sentencia se pueden definir zonas comunes
de memoria entre diversas Unidades de que forman parte un programa,
entre la Unidad principal y una o varias Subrutinas o Funciones.
-Es una sentencia no ejecutable que debe aparecer en
la Unidad de programa que llama y en el Subprograma llamado antes
de todas las sentencias ejecutables.
-En esta sentencia se listan los nombres de las
variables y los nombres de los arrays con su dimensión y es una forma
alternativa de comunicar datos a la lista de argumentos de los Subprogramas.
-Si un array va ha estar en una zona común se puede
definir su lista de identificadores en la lista COMMON o definir el
array y ponerlo en la lista de la sentencia COMMON.
-Las variables y los arrays son asignados a un
almacenamiento común en el orden en que aparecen en la sentencia COMMON,
siendo la sintaxis de esta:
-COMMON Identificador1, Identificador2, ...,
Identificadorn.
-La sintaxis anterior pertenece a una sentencia
COMMON sin nombre o en blanco, pero existe una sentencia COMMON etiquetada
o con nombre.
-El orden de los identificadores especificados en
una sentencia COMMON determina la equivalencia de identificadores
simbólicos entre varias Unidades de un programa (El bloque común de memoria
es lo global).
-La lista de identificadores deben ser de igual tipo
en todas las sentencias COMMON estableciéndose las equivalencias
por el orden en que están en la lista.
-Un identificador de una lista COMMON no puede
figurar como argumento en una Subrutina o Función ni como parámetro en las
llamadas (Puede haber un solapamiento de memoria).
-El bloque común de memoria es único para todo el
programa. La memoria común se establece de forma contigua.
-En un bloque común de memoria no puede haber
variables carácter y no carácter mezcladas, siendo todo de variables
carácter o variables no carácter.
-Las variables o arrays que figuran en la lista de
COMMON sin nombre no pueden ser inicializadas con DATA, sólo pueden
inicializarse con sentencias de asignación.
SENTENCIA "COMMON" CON NOMBRE. USO
CONJUNTO DE "COMMON" Y "EQUIVALENCE".
-Esta sentencia etiquetada permite definir varias
zonas comunes de memoria, cada una con su nombre o etiqueta.
-Se forman de igual manera que las anteriores pero
se escribe su nombre o etiqueta con dos barras (Slash) antes de la lista
de variables.
-El nombre de COMMON debe ser un identificador
válido y pueden definirse dos o más zonas comunes. Es conveniente usar tantas
sentencias COMMON como zonas comunes haya.
-Se pueden mezclar en una zona común variables
numéricas con variables o arrays lógicos.
-En el siguiente ejemplo tendremos sólamente dos
bloques COMMON uno con nombre y otro sin nombre:
-COMMON /Nombre-1/ VarA, VarB, VarC
COMMON VarH, VarI, VarJ
COMMON /Nombre-1/ VarK, VarL
COMMON VarM, VarN
-Una comparación entre un trozo de programa con
COMMON y otro sin él podría ser el siguiente:
-REAL VarD, VarE, VarF, VarG, VarZ
READ *, VarD, VarE, VarF, VarG
VarZ=2
VarT=Función (VarD, VarE, VarF, VarG)
STOP
END
FUNCTION Función (VarA, VarB, VarC, VarX)
VarI=VarA*VarX**2+VarB*VarX+VarC
RETURN
END
-REAL VarD, VarE, VarF, VarG, VarZ
COMMON /Coeficientes/ VarD, VarE, VarF
VarZ=2
VarT=Función (VarZ)
STOP
END
FUNCTION Función (VarX)
COMMON /Coeficientes/ VarA, VarB, VarC
VarF=VarA*VarX**2+VarB*VarX+VarC
RETURN
END
-Si en una sentencia COMMON se precede a los
identificadores de dos barras o slash indicará que son zonas comunes sin
nombre. Es indiferente el orden de definición de las zonas
comunes.
-Los arrays o variables de COMMON con etiqueta
pueden ser inicializados con la sentencia DATA, pero no las variables de un
COMMON sin nombre.
-Un COMMON con etiqueta tiene que tener el mismo
tamaño en todas las Unidades de programa.
-Las variables o arrays pueden aparecer en ambas
sentencias COMMON y EQUIVALENCE siempre que no causen conflicto en el
orden en el que se almacenan.
-Dos variables que estén en una zona común no
pueden ser equivalentes entre sí.
SENTENCIA "SAVE".
-Esta sentencia se utiliza para almacenar
estáticamente los valores o datos de una invocación a otra.
-SAVE declara que las variables locales y los arrays
sean retenidos después de ejecutar RETURN o la siguiente llamada
al Subprograma.
-Las variables o arrays locales contendrán el
último valor adquirido en la ejecución anterior al Subprograma. Su
sintaxis es:
-SAVE (Lista de identificadores).
-La lista de identificadores, que podrán ser
variables, arrays o bloques COMMON, retendrá el último valor adquirido antes
de la ejecución de RETURN.
-Las excepciones en las que las variables no quedan
indefinidas al salir de un Subprograma son:
-Sentencias SAVE del Subprograma.
-Bloques COMMON en blanco o sin nombre.
-Bloques COMMON etiquetados y definidos en la Unidad
de programa principal y uno o más Subprogramas.
-Las variables en bloques COMMON etiquetados en
Subprogramas quedan indefinidos sólo cuando hay una salida desde un
Subprograma pero no se pueden retener con SAVE y el nombre del bloque
COMMON.
-En una lista de SAVE no pueden aparecer parámetros
de Subrutinas o Funciones, ni nombres de Función y Subrutinas ni
variables o arrays de bloques COMMON.
-Puede haber más de un SAVE o escribir la lista en
un sólo SAVE. Si hay más de un SAVE no podrán repetirse nombres de
variables o arrays.
INICIALIZACION DE VARIABLES. SENTENCIA
"DATA".
-Esta sentencia permite inicializar variables con la
siguiente sintaxis:
-DATA Lista1 /Constantes/, ..., Listan /Constantes/.
-La lista contendrá los nombres de las variables o
arrays a inicializar separados por comas e inicializa las constantes que
vendrán separadas por comas.
-Puede especificarse más de una lista y sus
constantes o agrupar todas las variables en una sóla lista. La inicialización
se realiza en el orden en el que aparecen, de izquierda a derecha.
-Si hay constantes consecutivas iguales se podrá
poner:
-Número*Constante.
-En el formato anterior Número es el número de
repeticiones que se especificará de dicha forma.
-Las reglas más importantes de las sentencias DATA
son las siguientes:
-El número de constantes ha de ser igual al número
de elementos de la lista, variables o arrays.
-No pueden aparecer argumentos ficticios de
Subprogramas, nombres de Función y elementos de bloque COMMON en blanco.
-Sólo pueden estar los bloques COMMON etiquetados
en los bloques DATA.
-El tipo de variable o array a inicializar debe
corresponderse con el tipo de la constante. Lo mismo para las variables de
tipo carácter (Si hay exceso se ignora y si hay defecto se
completa con blancos a la derecha).
-Esta sentencia no es ejecutable y puede aparecer
después de las especificaciones de datos pero es mejor colocarlas
antes de las sentencias ejecutables.
-Las sentencias DATA pueden utilizar el DO
implícito para inicializar el array a los datos que se quieran o sólo
definirlo. Un ejemplo de ello sería:
-INTEGER VarA, Orden, Alfa, Lista (100)
REAL Coeficiente (4), Epsilon (2), Pi (5), VarX (5,
5)
CHARACTER *15 Ayuda
DATA VarA /0/, Orden /3/
DATA Coeficiente /1.0, 2*3.0, 1.0/, Epsilon (1)
/0.0001/
DATA ((VarX (VarI, VarJ), VarI=1, VarJ), VarJ=1.5)
/15*1.0/
DATA Lista /100*0/
DATA Ayuda /'Ayuda'/
-El siguiente formato puede ir en cualquier parte
del programa y tiene como misión hacer una llamada al camino o ruta
especificado:
-$INCLUDE 'Path Nombre.For'.
SENTENCIA "PARAMETER".
-Esta sentencia identifica constantes mediante
nombres identificadores o simbólicos para que después se pueda hacer
referencia a la constante por el identificador. La sintaxis de la orden es:
-PARAMETER (Identificador=Expresión constante).
-Dentro de los paréntesis se pueden especificar
tantos parámetros como se quiera separándolos por comas.
-La expresión debe coincidir en su tipo con el
identificador y el valor que va ha representar el identificador al evaluarse
la expresión. Debe ajustarse a las reglas establecidas para las
sentencias de asignación.
-El tipo de dato del identificador puede definirse
de forma implícita o explícita, describiendo la sentencia de
definición antes.
-La expresión constante puede hacer referencia a
otro parámetro pero ha de estar definida antes en otro PARAMETER o en la
misma sentencia
PARAMETER.
-Un identificador de constante no puede cambiar
después el valor que se le ha impuesto.
-El ámbito de los parámetros es la Unidad de
programa en que están definidos y una vez que el parámetro es definido
puede ser referenciado en los sitios en que pueden referenciarse las
constantes excepto:
-No se pueden usar los parámetros en una
especificación de un formato.
-Un parámetro no puede usarse como parte de otra
constante.
-Esta sentencia no es ejecutable y puede aparecer
después de cualquier sentencia de especificación de tipo o antes de que
se haga uso del parámetro.
-Cuando un valor aparece varias veces en una Unidad
de programa se debe asociarle un nombre simbólico y usar dicho nombre
para después hacer la referencia a dicho nombre.
INICIALIZACION DE UN COMMON CON NOMBRE. SUBPROGRAMA
"BLOCK DATA".
-Este Subprograma asigna valores iniciales a
variables y a arrays de un COMMON etiquetado, puesto que los COMMON en blanco
se inicializan en las sentencias DATA.
-La sentencia BLOCK DATA que puede tener un
identificador termina con la sentencia END y las sentencias que se pueden
especificar son todas las no ejecutables para la inicialización de la lista
de COMMON etiquetados y que son:
-IMPLICIT.
-PARAMETER.
-DIMENSION.
-SAVE.
-COMMON.
-EQUIVALENCE.
-DATA.
-La sintaxis de este Subprograma será:
-BLOCK DATA Identificador
sentencia1
sentencia2
..........
sentencian
END
-Si el identificador se coloca es considerado como
un identificador global y no puede coincidir con el nombre de una
Función o el de una Subrutina.
-El COMMON etiquetado al inicializarlo hay que
especificarlo en el Subprograma BLOCK DATA de forma completa aunque haya
variables no inicializables.
-En un programa ejecutable pueden haber más de un
BLOCK DATA pero sólo uno puede ser sin nombre y todos los demás nombres
distintos. Un COMMON sólo puede estar en un sólo BLOCK DATA.
-Un ejemplo del uso de este Subprograma sería:
-BLOCK DATA Nombre
COMPLEX VarA, VarB
LOGICAL VarC, VarD
INTEGER VarI, VarJ, VarK, Lista
REAL VarX
COMMON /Bloque1/ VarX (10), VarI, VarJ, VarA
COMMON /Bloque2/ Lista (6), VarC, VarD, VarB
DATA VarX /10*0.0/, VarI, VarJ /1, 0/, VarC /False/
DATA VarA, VarB, /2*(0, 1)/
END
-Normalmente este tipo de Subprogramas se suelen
colocar cuando acaba el programa principal.
TIPO DE DATO COMPLEJO.
-Este tipo de datos se representa por un par
ordenado de números reales de doble precisión, enteros o una combinación de
ellos encerrados entre paréntesis y separados por comas.
-Para definir un identificador de tipo complejo
contamos con COMPLEX, y pueden haber variables, arrays complejos y Funciones
complejas.
-La memoria que ocupa una variable compleja es el
doble de una variable real. Se puede asignar una constante compleja, otra
variable compleja o una expresión compleja inicializándose con DATA.
-Cuando a la variable compleja se le quiere asignar
un número complejo que tiene la parte real, la parte imaginaria o ambas
debe usarse la Función intrínseca COMPLEX.
-Los números complejos pueden sumarse, restarse,
multiplicarse, elevarse a una potencia y dividirse. No puede usarse en la
expresión aritmética de la sentencia IF aritmético, y no puede usarse
como subíndice de un array.
-Otras Funciones que tienen los números complejos
son:
-AIMAG (Expresión numérica) (Parte imaginaria como
número real).
-CONJ (Expresión numérica) (Devuelve el complejo
conjugado).
-Otras Funciones internas que tienen un nombre
específico para el argumento complejo y el valor que devuelven es
también complejo son:
-CSQRT (Expresión numérica) (Raíz cuadrada de un
complejo).
-CABS (Expresión numérica) (Módulo del complejo).
-CEXP (Expresión numérica) (Función exponencial
de un complejo).
-CLOG (Expresión numérica) (Logaritmo natural de
un complejo).
-CSIN (Expresión numérica) (Seno de un complejo).
-CCOS (Expresión numérica) (Coseno de un
complejo).
SENTENCIA "PAUSE".
-Esta sentencia hace una parada temporal en la
ejecución de un programa para detener la salida hasta que el usuario haya
podido leer toda la información. Su sintaxis es:
-PAUSE.
-PAUSE 'Cadena de caracteres'.
-PAUSE Número (Constante de hasta cinco dígitos).
-Al producirse la parada se visualiza un mensaje
propio regido por el número indicado o la cadena si ha sido
especificada.
ASIGNACION DE ETIQUETAS A VARIABLES ENTERAS.
SENTENCIA "ASSIGN TO".
-Esta sentencia permite asignar un número de
etiquetas por una constante entera a una variable entera siendo su sintaxis:
-ASSIGN Etiqueta TO Variable.
-Etiqueta es la etiqueta de una sentencia ejecutable
o de una sentencia FORMAT, siendo variable el identificador de una
variable entera.
-Después de la ejecución de ASSIGN el valor de la
variable no puede ser considerada como un dato entero.
-Si la etiqueta asignada a la variable es la de una
sentencia FORMAT, la variable puede ser usada como un identificador de
formato.
-Si la etiqueta asignada es ejecutable la variable
puede ser usada en un GOTO asignado como:
-GOTO Variable.
-GOTO Variable (Etiqueta1, Etiqueta2, ...,
Etiquetan).
-Cuando se ejecuta una sentencia GOTO asignada el
control del programa es transferido a la sentencia con la etiqueta del
último valor asignado a la variable con ASSIGN.
TEMA 8: TRATAMIENTO DE CADENAS EN FORTRAN.
CADENAS DE CARACTERES.
-Una cadena es un conjunto de caracteres encerrados
entre apóstrofes.
Si se quiere representar un apóstrofe dentro de una
cadena se deberá representar por dos apóstrofes consecutivos.
-Una cadena se declara con la siguiente sintaxis:
-CHARACTER *Número Lista de variables.
-Aquí número representa el número de caracteres
de las variables de una cadena. Un array que contiene caracteres se define
con una sentencia CHARACTER y declarada de dos modos distintos.
LAS CADENAS COMO ARGUMENTO DE SUBPROGRAMAS.
-Un Subprograma puede especificar una cadena de
caracteres sin darle una longitud específica y equivale a la longitud de una
array con una variable entera.
-Se puede definir en un Subprograma un array de n
variables cada una con su cadena de caracteres sin especificar la longitud
de cadena en la sentencia CHARACTER.
-La longitud de la cadena es siempre positiva nunca
igual a cero, y dicha longitud no se puede alterar aunque sí
asignar cadenas cuya longitud es diferente.
-Una cadena con longitud más corta que la de la
variable, rellena a blancos por la derecha y si es más larga la trunca.
ASIGNACION DE VALORES A LAS CADENAS.
-Se realiza con la sentencia de asignación y una
constante de caracteres usándose una variable cadena para inicializar otra
variable de cadena.
-Si los caracteres asignados no coinciden con la
longitud se rellenan a blancos y si es mayor que la longitud se trunca
por la derecha.
COMPARACION DE CADENAS.
-Esta comparación se realiza carácter a carácter
de izquierda a derecha con las siguientes reglas:
-Si las cadenas tienen igual longitud y los
caracteres son los mismos, las cadenas son iguales.
-Si una cadena es más corta que la otra se añaden
blancos a la derecha de la otra cadena, de modo que pueda
proceder a la evaluación como si las cadenas fueran iguales.
-Las reglas de ordenación típicas son las
siguientes:
-Las letras mayúsculas están ordenadas de A a Z.
-Los dígitos ordenados de 0 a 9.
-El carácter blanco es menor que cualquier letra o
número.
SUBCADENAS.
-Es cualquier cadena que representa un subconjunto
de la cadena original y mantiene el orden original. Para especificar una
subcadena de una variable de carácter o un elemento de un array de
carácter se usa:
-Nombrecadena ( Expresión1 : Expresión2 ).
-Expresión1 es la posición en nombrecadena del
primer carácter de la subcadena y expresión2 es la posición en
nombrecadena del último carácter de la subcadena.
-Expresión1 y expresión2 deben ser del tipo entero
y cumplir:
-1<=Expresión1<=Expresión2<=Longitud de
la cadena.
-Si se omite la expresión1 se toma por defecto uno.
Si se omite la expresión2 se toma el valor de la longitud de la
cadena original, siendo la subcadena:
-Expresión2-Expresión1+1.
CONCATENACION DE CADENAS.
-Consiste en combinar dos o más cadenas de
caracteres en una única cadena, siendo el operador que realiza la
concatencación o unión de cadenas el siguiente:
-//.
FUNCION LONGITUD. SENTENCIAS "LEN" Y
"GETLEN".
-LEN determina la longitud de la cadena de
caracteres argumento siendo su sintaxis:
-LEN (Cadena de caracteres).
-Si la cadena de caracteres es una constante de
carácter su longitud es el número de caracteres. Si es una variable de
cadena o elemento de array la longitud es la definida en la declaración.
-Si cadena es una subcadena con el formato
(Expresión1:Expresión2) su longitud es la siguiente:
-Expresión2-Expresión1+1.
-GETLEN calcula la longitud de una cadena de
caracteres excluyendo a los caracteres en blanco siendo su formato:
-GETLEN (Cadena de caracteres).
FUNCIONES DE TRATAMIENTO DE CARACTERES. SENTENCIAS
"CHAR" E "ICHAR".
-CHAR determina el carácter de la cadena que ocupa
la posición relativa en la secuencia de caracteres ASCII siendo su
sintaxis:
-CHAR (Posición).
-El valor de posición debe estar entre 0 y 255
caracteres de la cadena.
-ICHAR es la Función inversa de CHAR. El argumento
es un carácter y la Función devuelve un entero que es la posición del
carácter en la secuencia ordenada de caracteres ASCII con el
formato:
-ICHAR (Carácter).
FUNCION DE BUSQUEDA. SENTENCIA "INDEX".
-Esta Función localiza una subcadena dentro de
otra. Devuelve un valor entero que indica la posición inicial de la cadena
de caracteres destino dentro de la cadena original siendo su
sintaxis:
-INDEX (Cadena fuente, Cadena destino).
-Si la cadena destino no existe el formato devuelve
el valor cero.
OTRAS FUNCIONES.
-La Función LEN_TRIM devuelve la longitud de la
cadena dada sin los espacios en blanco siendo su sintaxis:
-LEN_TRIM (Cadena de caracteres).
-La Función SCAN busca una subcadena en una cadena
dada y muestra la primera posición en la que coinciden ambas cadenas,
buscando carácter a carácter, siendo su sintaxis:
-SCAN (Cadena1, Cadena2).
-La Función VERIFY devuelve un entero y verifica
que una cadena está incluída en otra, devolviendo la posición del
carácter que sea distinto de los demás y siendo su sintaxis:
-VERIFY (Cadena1, Cadena2).
-Otras Funciones que devuelven un valor lógico y
que sirven para la comparación son:
-LGE (Cadena1, Cadena2), verifica si cadena1 es
mayor o igual que cadena2.
-LGT (Cadena1, Cadena2), verifica si cadena1 es
mayor que cadena2.
-LLE (Cadena1, Cadena2), verifica si cadena1 es
menor o igual que cadena2.
-LLT (Cadena1, Cadena2), verifica si cadena1 es
menor que cadena2.
-En estas cuatro últimas Funciones el argumento
debe ser siempre un carácter.
TEMA 9: FICHEROS.
INTRODUCCION.
ESTRUCTURA DE UN FICHERO.
-Un fichero es una colección de datos organizados
de alguna manera y almacenados generalmente en disco o cinta.
-Un fichero está formado por registros y estos
constan de campos que pueden ser numéricos o de caracteres.
-Los ficheros formateados pueden ser editados,
imprimirse o visualizarse mientras que los ficheros no formateados no pueden
hacer esas acciones.
Aunque la lectura y la escritura son más rápidas y
ocupan poca memoria.
ORGANIZACION DE FICHEROS.
-Se consideran dos tipos de acceso a los registros
de un fichero que son los siguientes:
-Acceso Secuencial.
-Acceso Directo.
-El acceso Secuencial implica el acceso a un fichero
según el orden de almacenamiento de sus registros, uno a uno.
-El acceso Directo implica situarse en un registro
determinado sin que ello implique la consulta de los registros
precedentes.
-La Organización de un fichero define la forma en
que los registros se disponen sobre el soporte de almacenamiento:
-Organización Secuencial.
-Organización Directa.
-Organización Indexada.
-Un fichero con organización Secuencial es una
sucesión de registros almacenados consecutivamente sobre un soporte
externo de tal modo que para acceder al registro n, necesariamente hay que
pasar por los n-1 registros precedentes.
-Un fichero con organización Directa exige soporte
direccionable. Cada posición se localiza por su dirección absoluta,
que en el caso del disco suele venir definida por número de pista y de
sector.
-El lenguaje Fortran no es muy fuerte es la
manipulación de archivos aunque tiene capacidad para manipularlos.
-Los archivos suelen ser pequeños y la información
a tratar suele estar en sentencias DATA.
APERTURA DE UN FICHERO. SENTENCIA "OPEN".
-Esta sentencia es la encargada de la apertura de un
fichero, conectando un fichero a un número de Unidad, de forma que para
referirse después al fichero se hará con el número de Unidad
establecido en la apertura.
-Cuando se quiere crear un fichero en un programa se
utilizará la sentencia OPEN para que quede en una Unidad.
-La sentencia OPEN también es usada para declarar
las propiedades del fichero, si es Secuencial o Directo, si es
Formateado o no Formateado y otras propiedades.
-La sintaxis de la sentencia será la siguiente:
-OPEN ( UNIT= N, FILE='Nombre' , ACCESS=Tipo ,
FORM=Formato ,
STATUS=Estado , IOSTAT=N , ERR=Etiqueta , BLANK=Tipo
,
RECL=N , BLOCKSIZE=N , MODE=Tipo ).
-La sentencia OPEN es la primera sentencia que debe
aparecer al utilizar un fichero.
-La opción UNIT siempre debe figurar en la
sentencia OPEN y se podrá omitir, en cuyo caso N deberá figurar como primer
parámetro.
-Esta opción se encarga de asignar un canal de
comunicación para ejecutar el archivo.
-La opción FILE indica el nombre del fichero que va
a estar conectado a la unidad N. Si no se coloca el nombre del fichero
se podrá pasar por parámetro el nombre de dicho fichero.
-La opción ACCESS, donde Tipo es una expresión de
tipo carácter e indica el tipo de fichero que se va a utilizar, siendo por
defecto Secuencial y puediendo tomar los valores:
-SEQUENTIAL.
-DIRECT.
-La opción FORM, donde Formato es una expresión de
tipo carácter en que el valor por defecto es Secuencial, asigna un
formato al fichero, siendo los valores que puede tomar:
-FORMATTED.
-UNFORMATTED.
-BINARY.
-Si la opción es omitida OPEN asumirá FORMATTED si
el fichero es de tipo Secuencial y UNFORMATTED si es un fichero Directo.
BINARY se utiliza en Fortran 90 y representa a los ficheros binarios.
-La opción STATUS, donde Estado es una expresión
de tipo carácter y se usa para saber si el fichero ya existe o es nuevo y
por tanto va a ser creado. Sus opciones son las siguientes:
-OLD (Si el fichero existe, sino produce error).
-NEW (Crea el nuevo fichero y FILE no debe existir
en la Unidad).
-SCRATCH (Si crea un fichero temporal y no debe
darse nombre al fichero).
-UNKNOWN (Si no se sabe si existe o no el fichero
siendo la opción por defecto).
-Un fichero SCRATCH desaparece cuando se cierra la
Unidad o cuando termina la ejecución.
-La opción IOSTAT, donde N es un identificador de
una variable entera.
Almacena un código numérico de cómo se ejecuta la
sentencia OPEN. Si OPEN se ejecuta sin error se almacena un cero en N.
-La opción ERR, donde Etiqueta es la sentencia
donde se bifurca incondicionalmente si el fichero no puede ser
abierto al producirse un error.
-La opción BLANK, donde Tipo es una expresión de
tipo carácter que puede tomar los siguientes valores:
-NULL (Los blancos son ignorados y es opción por
defecto).
-ZERO (Los blancos son interpretados como ceros).
-Esta opción se usa para especificar la
interpretación de los espacios en blanco en los datos de entrada.
-La opción RECL, donde N es una expresión entera,
indica la longitud en caracteres de los registros en un fichero de
acceso Directo. Sólo debe aparecer en los ficheros Directos.
-La opción BLOCKSIZE, donde N es un número entero,
asigna un tamaño al buffer de lectura intermedio.
-La opción MODE, donde Tipo es una cadena de
caracteres, es el modo de apertura del fichero. La opción por defecto es la
de lectura escritura siendo las opciones:
-READ.
-WRITE.
-READWRITE.
-Todas las opciones son opcionales excepto UNIT que
es obligatorio, y si el fichero es de acceso Directo es obligatorio
especificar RECL.
ESCRITURA DE UN FICHERO SECUENCIAL.
-Consiste en transferir información desde la
memoria principal al soporte externo donde está el fichero.
-Para escribir en un fichero Secuencial se usa WRITE
especificando la Unidad a la que está conectada el fichero indicando
que el fichero es Secuencial.
-La sentencia de escritura tiene la siguiente
sintaxis:
-WRITE ( UNIT= N , FORM=Formato , ERR=Etiqueta ,
IOSTAT=N ,
ENDFILE=Unidad ).
-La única opción obligatoria sería UNIT, todas
las demás han quedado explicadas.
-Al crear un fichero los registros se escriben uno a
continuación del otro, escribiendo un registro especial EOF al final
de los datos escritos.
-Normalmente con CLOSE el registro EOF es
automáticamente escrito al cerrar el fichero, aunque se puede usar la siguiente
sentencia:
-ENDFILE N.
-ENDFILE ( UNIT= N , ERR=Etiqueta , IOSTAT=N ).
-Donde N es el número de la Unidad a la que se
conectó el fichero Secuencial. La sintaxis más empleada es la primera.
Todas las demás opciones ya han quedado explicadas.
-Si se ejecuta ENDFILE, el nombre de la Unidad a la
que está conectado un fichero nuevo, sin datos, creará un fichero
vacío.
SENTENCIA DE CIERRE DE UN FICHERO "CLOSE".
-Esta sentencia rompe la conexión de un fichero con
la Unidad a la que se conectó un OPEN siendo su sintaxis:
-CLOSE ( UNIT= N , STATUS=Tipo , IOSTAT=N ,
ERR=Etiqueta ).
-La opción UNIT, siendo N un entero, es el número
de la Unidad donde se encuentra el fichero que se va a desconectar y
puede omitirse, en cuyo caso, será el primer parámetro de CLOSE.
-La opción STATUS, siendo Tipo una expresión tipo
carácter indica el estado del fichero en ese momento, puediendo tener
los valores:
-KEEP (El fichero se guarda después de ser
cerrado).
-DELETE (El fichero es borrado perdiéndose después
del cierre).
-Por defecto toma el valor KEEP, excepto para los
ficheros que son de tipo SCRATCH.
-Los posibles valores que se pueden sacar de las
opciones FORM y ACCESS son los siguientes:
-Registros Secuencial-Formateados.
-Registros Secuencial-No formateados.
-Registros Directo-Formateados.
-Registros Directo-No formateados.
-Registros Binario-Formateado.
-Registros Binario-No formateado.
-Los registros de tipo Secuencial-Formateados se
almacenan en código ASCII y permiten verse con cualquier editor de texto
y manipularlos.
-Si tenemos las siguientes instrucciones:
-VarI=4
OPEN (33, FILE='FSEQ')
WRITE (33, '(A, I3)') 'RECORD', I/3
WRITE (33, 'C3')
WRITE (33, '(11H El Reg-N3)')
CLOSE (33)
-La salida que dará este ejemplo serán tres
segmentos de longitud variable cuya estructura de registros será la
siguiente:
-Se puede observar como después de la primera marca
de fichero OA, el segundo registro no aparece por ser de 0 bytes,
mientras que el primero tendrá 9 bytes y el tercero tendrá 11 bytes.
-Los registros de tipo Secuencial-No formateados
tienen longitud variable y no están en código ASCII, sino otro
código que lo introduce el programa y lo organiza en bloques físicos de 128
bytes como máximo.
-Si tenemos las siguientes instrucciones:
-CHARACTER Array (3)
INTEGER *4 Datos (35)
DATA Datos /35*-1/, Array / 'X', 'Y', 'Z'/
OPEN (33, FILE='UFSEQ', FORM='UNFORMATTED')
WRITE (33) Datos
WRITE (33) Array
CLOSE (33)
-La salida que dará este ejemplo será la
siguiente:
-Como el bloque tiene un tamaño máximo de 128
bytes por registro, al sacar todos los elementos del Array Datos (Que
necesitará 140 bytes) se particiona en dos registros uno de 128 bytes y
otro de 12 bytes.
-Los registros de tipo Directo-Formateados tienen la
misma longitud, que se deberá especificar en la longitud del
registro.
-A cada registro siempre se le añade el carácter
de control de carro (OD) y el carácter de avance de línea (OA). Si
tenemos las siguientes instrucciones:
-OPEN (33, FILE='FDIR', FORM='FORMATTED',
ACCESS='DIRECT',
RECL=10)
WRITE (33, '(A)', REC=1) 'Registro 1'
WRITE (33, '(I5)', REC=3) 30303
CLOSE (33)
-La salida que dará este ejemplo será la
siguiente:
-Se puede ver que del registro primero se pasa al
tercero. En los ficheros Directos, se reserva espacio para los
registros.
-De esa forma si luego viene un registro segundo se
insertaría entre los registros primero y tercero.
-Los registros de tipo Directo-No formateados es la
opción por defecto, en la que la longitud del registro es la misma para
todos pero el compilador no introduce los caracteres OD y OA.
LECTURA DE UN FICHERO SECUENCIAL.
-Transfiere la información contenida en los
registros del fichero a la memoria del ordenador representada por las variables
que aparecen en la lista de la sentencia de lectura.
-La sentencia READ tiene la sintaxis para ficheros
Secuenciales siguiente:
-READ ( UNIT= N, FORM=Formato , END=Etiqueta ,
ERR=Etiqueta ,
IOSTAT=N , REC=N ) Lista de variables.
-La opción que siempre debe figurar es el número
de Unidad perteneciente al de apertura del fichero Secuencial.
-La opción END, donde Etiqueta es un número entero
indica que al detectar el carácter de fin de fichero transfiera
el control de ejecución del programa a la etiqueta indicada.
-Todas las demás opciones ya se han explicado.
-Para leer un fichero la primera opción a realizar
es abrirlo en la opción STATUS con el valor OLD.
POSICIONAMIENTO EN UN FICHERO SECUENCIAL.
-La lectura y escritura de registros se realiza uno
a uno y en serie.
Hay dos sentencias para regresar un registro
(BACKSPACE) y para posicionarse al principio del fichero (REWIND).
-La sintaxis de BACKSPACE es la siguiente:
-BACKSPACE N.
-BACKSPACE ( UNIT= N, IOSTAT=N , ERR=Etiqueta ).
-N es el número de la Unidad a la cual está
conectado el fichero. Si no hay registro anterior porque el fichero se acaba de
abrir no tiene efecto.
-Todas las demás opciones ya se han explicado.
-La sentencia REWIND tiene la siguiente sintaxis:
-REWIND N.
-REWIND ( UNIT= N, IOSTAT=N , ERR=Etiqueta ).
-El efecto es rebobinar el fichero al comienzo,
apuntando al primer registro. Todas las demás opciones ya se han
explicado.
CREACION DE UN FICHERO DE ACCESO DIRECTO.
-Cada registro de un fichero de acceso Directo es
identificado únicamente por su posición lógica en el fichero o
número de registro que es un entero de 1 a n.
-El acceso a los registros se hace siempre a partir
del número de registro con el que fue creado. En un fichero de
acceso Directo no tiene sentido el registro EOF.
-Por ello ENDFILE no se debe ejecutar sobre estos
ficheros, porque no tiene efecto.
-En un fichero de acceso Directo se reserva espacio
de almacenamiento para todos los posibles registros.
-En los ficheros de acceso Directo los datos de
entrada o de salida deben ir siempre con formato. Este tipo de ficheros
es creado al abrirlo, especificando acceso directo y dándole una
longitud.
-Los ficheros no formateados guardan la información
en código binario, siendo el acceso a los registros más rápidos
porque se elimina el tiempo de conversión a binario.
-Los registros pueden ser escritos o leídos en
cualquier orden. Siempre hay que indicar en las sentencias READ y WRITE un
parámetro REC que indicará el número de registro a acceder.
-El proceso para leer un registro es similar al de
escribir. Hay que especificar el número de registro que se quiere
leer.
SENTENCIA "INQUIRE".
-Con esta sentencia durante la ejecución de un
programa puede obtenerse información sobre las características de una
Unidad o de un fichero.
-Puede ejecutarse antes de que un fichero haya sido
abierto, conectado a una Unidad.
-La información que puede requerirse de un fichero
o de una Unidad es muy variada. La sintaxis para esta sentencia es la
siguiente:
-INQUIRE (UNIT=N, Lista de especificadores).
-Donde N es un número de unidad sobre el que se va
a preguntar siendo la lista de especificadores opcionales los
siguientes:
-ACCESS=Var*10 ('SEQUENTIAL' o 'DIRECT').
-BLANK=Var*4 ('NULL' o 'ZERO').
-DIRECT=Var*7 ('YES', 'NO' o 'UNKNOWN').
-EXIST=Var ('.TRUE.' o '.FALSE.').
-FORM=Var ('UNFORMATTED' o 'FORMATTED).
-FORMATTED=Var ('YES', 'NO' o 'UNKNOWN').
-NAME=Var*3 ('.TRUE.', '.FALSE.' o 'Nombre').
-NEXTREC=N (Registro después del último accedido).
-NUMBER=N (Número de Unidad igual a UNIT).
-OPENED=Var ('.TRUE.' o '.FALSE.').
-RECL=N (Longitud del registro).
-SEQUENTIAL=Var ('YES', 'NO' o 'UNKNOWN').
-UNFORMATTED=Var ('YES', 'NO' o 'UNKNOWN').
-IOSTAT=N (Código de estado).
-ERR=Etiqueta (Bifurcaciones de error).
-BINARY=Var*10 ('YES', 'NO' o 'UNKNOWN').
-BLOKSIZE=N (Tamaño del buffer).
-Si se produce error en INQUIRE todas las variables
que figuran en la sentencia queda un valor indefinido excepto la
variable entera de STATUS y las variables de los especificadores pueden
ser elementos de un Array.
-Otra posibilidad de INQUIRE es preguntar por el
fichero con la siguiente sintaxis:
-INQUIRE (FILE='Nombre', Lista de especificadores).
-La lista de especificadores es la misma que la
anterior. Si el nombre del fichero es un identificador válido para el
sistema y si el fichero existe se añadirán los siguientes:
-DIRECT, FORMATTED, NAME, SEQUENTIAL y UNFORMATTED.
-Si el fichero está abierto puede aplicarse:
-ACCESS, BLANK, FORM, NEXTREC, NUMBER, BELL, IOSTAT
y ERR.
-La ventaja es que provee de información muy
valiosa para abrir ficheros o evitar errores que abortan la ejecución de un
programa.
FICHEROS INTERNOS.
-Cuando el programa ejecuta READ o WRITE con un
fichero o dispositivo externo se realizan las dos operaciones
conjuntamente.
-En los ficheros internos la transferencia de
información se produce entre dos áreas de memoria interna. Un fichero
interno es un área de almacenamiento interno.
-Las entradas o salidas con ficheros internos deben
ser siempre formateadas con los códigos de formato deseados por
el programador.
-Con los ficheros internos hay que especificar
siempre los códigos de formato en las sentencias WRITE y READ.
-Para acceder a más de un registro en un fichero
interno hay que ejecutar una sóla vez la sentencia READ o WRITE.
-Las opciones que no se permiten usar son las
siguientes:
-OPEN, CLOSE, INQUIRE, REWIND, BACKSPACE y ENDFILE.
FICHEROS BINARIOS.
-Es un fichero de tipo Secuencial aunque también
podemos tener ficheros Directos, pero de esta forma permite recibir o
escribir más de un registro a la vez.
-No se separan los registros y se lee de la misma
manera pero en el Directo hay que poner en la opción de formato lo
siguiente:
-FORM='BINARY'.
-Si tenemos las siguientes instrucciones:
-INTEGER *1 VarA (4)
CHARACTER VarB (3)
CHARACTER *4 VarC
DATA VarA /4*7/
DATA VarC /'Esto'/, VarB /'A', 'B', 'C'/
OPEN (33, FILE='FBIN', FORM='BINARY')
WRITE (33) VarB, VarC
WRITE (33) 'Que', 'Quieres'
WRITE (33) VarA
CLOSE (33)
-La salida que producirá en el registro será la
siguiente:
-Notar que la separación es imaginaria. Siempre en
un fichero Directo se han de inicializar las variables normalmente. |
