Ciencias Místicas >> Área de Informática >> Programación >> Curso de Fortran
| |
|
|
|
||
| PRINCIPAL | ELECTRÓNICA | INFORMÁTICA | TECNOLOGÍA | ||
|
Ciencias Místicas >> Área de Informática >> Programación >> Curso de Fortran |
|||||
Curso de Fortran
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.
-
TEMA 9: FICHEROS.
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.
| |
|
|
|
||
| PRINCIPAL | ELECTRÓNICA | INFORMÁTICA | TECNOLOGÍA | ||
| Ciencias Místicas - www.cienciasmisticas.com.ar - El sitio de electrónica, informática y tecnología. | |||||