Características del lenguaje Fortran 95

El componente básico del lenguaje Fortran es su conjunto de caracteres . Sus miembros son:

• las letras A ... Z y a ... z (que son equivalentes fuera de un contexto de caracteres)
• los números del 0 al 9
• el guion bajo _
• los personajes especiales=  : + blank - * / ( ) [ ] , . $ ' ! "  % & ; <> ?

Los tokens que tienen un significado sintáctico para el compilador se construyen a partir de esos componentes. Hay seis clases de tokens:

A partir de los tokens, se construyen las declaraciones . Estas se pueden codificar utilizando el nuevo formato de código fuente libre que no requiere posicionamiento en una estructura de columna rígida:

FUNCIÓN string_concat ( s1 , s2 ) ! Este es un comentario TIPO ( cadena ), INTENCIÓN ( EN ) :: s1 , s2 TIPO ( cadena ) string_concat string_concat % string_data = s1 % string_data ( 1 : s1 % length ) // & s2 % string_data ( 1 : s2 % length ) ! Esta es una continuación string_concat % length = s1 % length + s2 % length FIN FUNCIÓN string_concat

Observe los comentarios finales y la marca de continuación final. Puede haber 39 líneas de continuación y 132 caracteres por línea . Los espacios en blanco son significativos. Cuando un token o una constante de carácter se divide en dos líneas:

... inicio_de & & _ nombre ... 'una &  &cadena muy larga'

&También se requiere un paso adelante en la línea continua.

Fortran tiene cinco tipos de datos intrínsecos : INTEGER, REAL, COMPLEX, LOGICALy CHARACTER. Cada uno de esos tipos puede ser caracterizado adicionalmente por un tipo . El tipo, básicamente, define la representación interna del tipo: para los tres tipos numéricos, define la precisión y el rango, y para los otros dos, las especificidades de la representación de almacenamiento. Por lo tanto, es un concepto abstracto que modela los límites de la representación de los tipos de datos; se expresa como un miembro de un conjunto de números enteros (por ejemplo, puede ser {1, 2, 4, 8} para enteros, que denotan bytes de almacenamiento), pero esos valores no están especificados por el Estándar y no son portátiles. Para cada tipo, hay un tipo predeterminado , que se usa si no se especifica explícitamente ningún tipo. Para cada tipo intrínseco, hay una forma correspondiente de constante literal . Los tipos numéricos INTEGERy REALsolo pueden ser con signo (no hay concepto de signo para el tipo COMPLEX).

1 0 - 999 32767 + 10

INTEGER,PARAMETER::two_bytes=SELECTED_INT_KIND(4)

-1234_two_bytes+1_two_bytes

-1234_2

KIND(1)KIND(1_two_bytes)

RANGE(1_two_bytes)

B'01010101'O'01234567'Z'10fa'

INTEGER,PARAMETER::long=SELECTED_REAL_KIND(9,99)

1.7_long

KIND(1.7_long)PRECISION(1.7_long)RANGE(1.7_long)

(1,3.7_long)

.FALSE..true._one_byte

KIND(.TRUE.)

'A string'"Another"'A "quote"''''''''

TIPO ( 'ASCII' )

Las variables escalares correspondientes a los cinco tipos intrínsecos se especifican de la siguiente manera:

ENTERO ( TIPO = 2 ) :: i REAL ( TIPO = largo ) :: a COMPLEJO :: actual LÓGICO :: Pravda CARÁCTER ( LONGITUD = 20 ) :: palabra CARÁCTER ( LONGITUD = 2 , TIPO = Kanji ) :: palabra_kanji

donde el KINDparámetro opcional especifica un tipo distinto al predeterminado, y la ::notación delimita el tipo y los atributos de los nombres de las variables y sus valores iniciales opcionales, lo que permite especificar e inicializar completamente las variables en una sola instrucción (en estándares anteriores, los atributos e inicializadores debían declararse en varias instrucciones). Si bien no es necesario en los ejemplos anteriores (ya que no hay atributos ni inicialización adicionales), la mayoría de los programadores de Fortran-90 adquieren el hábito de usarlo en todas partes.

LEN=El especificador es aplicable solo a CHARACTERs y especifica la longitud de la cadena (reemplazando la *lenforma anterior). Los especificadores explícitos KIND=y LEN=son opcionales:

CARÁCTER ( 2 , Kanji ) :: palabra_kanji

Funciona igual de bien.

Hay otras características interesantes del carácter. Al igual que una subcadena como en

CARÁCTER ( 80 ) :: línea ... = línea ( i : i ) ! subcadena

Anteriormente era posible, por lo que ahora es la subcadena.

'0123456789' ( i : i )

Además, se permiten cadenas de longitud cero:

line(i:i-1)! zero-length string

Finally, there is a set of intrinsic character functions, examples being

For derived data types, the form of the type must be defined first:

TYPE personCHARACTER(10)nameREAL ageEND TYPE person

and then, variables of that type can be defined:

TYPE(person)you,me

To select components of a derived type, % qualifier is used:

you%age

Literal constants of derived types have the form TypeName(1stComponentLiteral, 2ndComponentLiteral, ...):

you=person('Smith',23.5)

which is known as a structure constructor. Definitions may refer to a previously defined type:

TYPE pointREAL x,yEND TYPE pointTYPE triangleTYPE(point)a,b,cEND TYPE triangle

and for a variable of type triangle, as in

TYPE(triangle)t

each component of type point is accessed as

t%at%bt%c

which, in turn, have ultimate components of type real:

t%a%xt%a%yt%b%xetc.

(Note that the % qualifier was chosen rather than dot (.) because of potential ambiguity with operator notation, like .OR.).

Unless specified otherwise, all variables starting with letters I, J, K, L, M and N are default INTEGERs, and all others are default REAL; other data types must be explicitly declared. This is known as implicit typing and is a heritage of early FORTRAN days. Those defaults can be overridden by IMPLICIT TypeName (CharacterRange) statements, like:

IMPLICIT COMPLEX(Z)IMPLICIT CHARACTER(A-B)IMPLICIT REAL(C-H,N-Y)

Sin embargo, es una buena práctica tipificar explícitamente todas las variables, y esto se puede forzar insertando la instrucción IMPLICIT NONE al principio de cada unidad de programa.

Los arreglos se consideran variables por derecho propio. Cada arreglo se caracteriza por su tipo , rango y forma (que define los límites de cada dimensión). Los límites de cada dimensión son por defecto 1 y tamaño , pero se pueden especificar límites arbitrarios explícitamente. DIMENSIONLa palabra clave es opcional y se considera un atributo; si se omite, la forma del arreglo debe especificarse después del nombre de la variable del arreglo. Por ejemplo,

REAL :: a ( 10 ) ENTERO , DIMENSIÓN ( 0 : 100 , - 50 : 50 ) :: mapa

Declara dos arreglos, rango-1 y rango-2, cuyos elementos están en orden de columna principal . Los elementos son, por ejemplo,

a ( 1 ) a ( i * j )

y son escalares. Los subíndices pueden ser cualquier expresión entera escalar.

Las secciones son partes de las variables de matriz y, a su vez, son matrices:

a ( i : j ) ! rango uno map ( i : j , k : l : m ) ! rango dos a ( map ( i , k : l )) ! vector subíndice a ( 3 : 2 ) ! longitud cero

Los arreglos completos y las secciones de arreglos son objetos con valores de arreglo. Las constantes con valores de arreglo (constructores) están disponibles y se encuentran encerradas entre (/ ... /):

( / 1 , 2 , 3 , 4 / ) ( / ( ( / 1 , 2 , 3 / ), i = 1 , 4 ) / ) ( / ( i , i = 1 , 9 , 2 ) / ) ( / ( 0 , i = 1 , 100 ) / ) ( / ( 0.1 * i , i = 1 , 10 ) / )

utilizando una notación de bucle DO implícita. Fortran 2003 permite el uso de corchetes: [1, 2, 3, 4]y [([1,2,3], i=1,4)] en lugar de los dos primeros ejemplos anteriores, y muchos compiladores ahora lo admiten. Un tipo de datos derivado puede, por supuesto, contener componentes de matriz:

TIPO triplete REAL , DIMENSIÓN ( 3 ) :: vértice FIN TIPO triplete TIPO ( triplete ), DIMENSIÓN ( 4 ) :: t

de modo que

• t(2) es un escalar (una estructura)
• t(2)%vertex es un componente de matriz de un escalar

Las variables pueden recibir valores iniciales según se especifique en una declaración de especificación:

REAL , DIMENSIÓN ( 3 ) :: a = ( / 0.1 , 0.2 , 0.3 / )

y se puede asignar un valor inicial predeterminado al componente de un tipo de datos derivado:

TIPO triplete REAL , DIMENSIÓN ( 3 ) :: vértice = 0.0 FIN TIPO triplete

Cuando las variables locales se inicializan dentro de un procedimiento, adquieren implícitamente el atributo SAVE:

REAL , DIMENSIÓN ( 3 ) :: punto = ( / 0.0 , 1.0 , -1.0 / )​

Esta declaración es equivalente a

REAL , DIMENSIÓN ( 3 ) , GUARDAR :: punto = ( / 0.0 , 1.0 , -1.0 / )

Para variables locales dentro de una subrutina o función. El atributo SAVE hace que las variables locales conserven su valor después de una llamada a procedimiento y, posteriormente, que la variable se inicialice con el valor guardado al regresar al procedimiento.

REAL , DIMENSIÓN ( 3 ), PARÁMETRO :: campo = ( / 0. , 1. , 2. / ) TIPO ( triplete ), PARÁMETRO :: t = triplete ( ( / 0. , 0. , 0. / ) )

TIPO ( triplete ) :: t1 , t2 DATOS t1 / triplete ( ( / 0. , 1. , 2. / ) ) / , t2 % vértice ( 1 ) / 12 3. / DATOS matriz ( 1 : 64 ) / 64 * 0 / DATOS i , j , k / B '01010101' , O '77' , Z 'ff' /

ENTERO , PARÁMETRO :: long = SELECTED_REAL_KIND ( 12 ), & array ( 3 ) = ( / 1 , 2 , 3 / )

Es posible especificar detalles de variables utilizando cualquier expresión escalar entera no constante que también puede incluir referencias a funciones de consulta:

SUBRUTINA s ( b , m , c ) USE mod ! contiene a REAL , DIMENSIÓN (:, :) :: b REAL , DIMENSIÓN ( UBOUND ( b , 1 ) + 5 ) :: x ENTERO :: m CARÁCTER ( LEN =* ) :: c CARÁCTER ( LEN = m + LEN ( c )) :: cc REAL ( SELECTED_REAL_KIND ( 2 * PRECISION ( a ))) :: z

Están disponibles los operadores aritméticos habituales ( presentados aquí en orden creciente de precedencia). +, -, *, /, **

Los paréntesis se utilizan para indicar el orden de evaluación cuando sea necesario:

a * b + c ! * primero a * ( b + c ) ! + primero

Las reglas para expresiones y asignaciones numéricas escalares admiten tipos no predeterminados. Por lo tanto, las reglas de expresiones y asignaciones numéricas de modo mixto incorporan diferentes parámetros de tipo de clase de la manera esperada:

real2 = entero0 + real1

convierte integer0a un valor real del mismo tipo que real1; el resultado es del mismo tipo y se convierte al tipo de real2para la asignación.

Estas funciones están disponibles para el redondeo controlado de números reales a enteros:

• NINT: redondear al entero más cercano, devolver resultado entero
• ANINT: redondear al entero más cercano, devolver el resultado real
• INT: truncar (redondear hacia cero), devolver resultado entero
• AINT: truncar (redondear hacia cero), devolver el resultado real
• CEILING: valor entero más pequeño no menor que el argumento (redondeo hacia arriba) (Fortran-90)
• FLOOR: valor entero más grande no mayor que el argumento (redondeo hacia abajo) (Fortran-90)

Para las operaciones relacionales escalares de tipos numéricos, existe un conjunto de operadores integrados:

< <= == /= > >= .LT. .LE. .EQ. .NE. .GT. .GE.

(Las formas anteriores son nuevas en Fortran-90, y debajo se proporcionan formas equivalentes más antiguas). Ejemplos de expresiones:

a < b . Y . i /= j ! para variables numéricas flag = a == b ! para variables lógicas flags

En el caso de caracteres escalares y dadoCHARACTER(8)result

Es legal escribir

resultado ( 3 : 5 ) = resultado ( 1 : 3 ) ! superposición permitida resultado ( 3 : 3 ) = resultado ( 3 : 2 ) ! no se permite la asignación de cadena nula

La concatenación se realiza mediante el operador '//'.

resultado = 'abcde' // '123' nombre de archivo = resultado // '.dat'

No existen operaciones integradas (excepto la asignación, definida componente por componente) entre tipos de datos derivados, ya sea entre sí o con tipos intrínsecos. Sin embargo, el significado de los operadores existentes o especificados por el usuario puede (re)definirse:

TIPO string80 ENTERO longitud CARÁCTER ( 80 ) valor FIN TIPO string80 CARÁCTER :: char1 , char2 , char3 TIPO ( string80 ) :: str1 , str2 , str3

podemos escribir

str3 = str1 // str2 ! debe definir la operación str3 = str1 . concat . str2 ! debe definir la operación char3 = char2 // char3 ! operador intrínseco solamente str3 = char1 ! debe definir la asignación

Nótese el uso " sobrecargado " del símbolo intrínseco //y del operador con nombre, .concat.. Una diferencia entre los dos casos es que, para un token de operador intrínseco, se aplican las reglas de precedencia habituales, mientras que para los operadores con nombre, la precedencia es la más alta como operador unario o la más baja como operador binario. En

vector3 = matriz * vector1 + vector2 vector3 = ( matriz . veces . vector1 ) + vector2

Las dos expresiones son equivalentes solo si se añaden los paréntesis apropiados, como se muestra. En cada caso, debe haber procedimientos definidos, en un módulo , que definan el operador y la asignación, y la asociación operador-procedimiento correspondiente, como sigue:

OPERADOR DE INTERFAZ ( // ) !Sobrecarga el operador // como procedimiento de invocación string_concat MÓDULO PROCEDIMIENTO string_concat FIN DE INTERFAZ

La función de concatenación de cadenas es una versión más elaborada de la que ya se mostró en la sección de Conceptos básicos . Cabe destacar que, para gestionar el error que se produce cuando las dos cadenas juntas superan el límite preestablecido de 80 caracteres, sería más seguro utilizar una subrutina para realizar la concatenación (en este caso, no sería aplicable la sobrecarga de operadores).

MÓDULO string_type IMPLICIT NONE  TYPE string80 INTEGER length CHARACTER ( LEN = 80 ) :: string_data END TYPE string80 INTERFACE ASSIGNMENT ( = ) MODULE PROCEDURE c_to_s_assign , s_to_c_assign END INTERFACE  INTERFACE OPERATOR ( // ) MODULE PROCEDURE string_concat END INTERFACE CONTAINS  SUBROUTINE c_to_s_assign ( s , c ) TYPE ( string80 ), INTENT ( OUT ) :: s CHARACTER ( LEN =* ), INTENT ( IN ) :: c s % string_data = c s % length = LEN ( c ) END SUBROUTINE c_to_s_assign SUBROUTINE s_to_c_assign ( c , s ) TYPE ( string80 ), INTENT ( IN ) :: s CHARACTER ( LEN =* ), INTENCIÓN ( SALIDA ) :: c c = s % string_data ( 1 : s % longitud ) FIN SUBRUTINA s_to_c_assign TIPO ( cadena80 ) FUNCIÓN string_concat ( s1 , s2 ) TIPO ( cadena80 ), INTENCIÓN ( ENTRADA ) :: s1 , s2 TIPO ( cadena80 ) :: s ENTERO :: n1 , n2 CARÁCTER ( 160 ) :: ctot n1 = LEN_TRIM ( s1 % string_data ) n2 = LEN_TRIM ( s2 %string_data ) SI ( n1 + n2 <= 80 ) entonces s % string_data = s1 % string_data ( 1 : n1 ) // s2 % string_data ( 1 : n2 ) SINO ! Esta es una condición de error que debe manejarse; por ahora, simplemente trunca ctot = s1 % string_data ( 1 : n1 ) // s2 % string_data ( 1 : n2 ) s % string_data = ctot ( 1 : 80 ) FIN SI s % length = LEN_TRIM ( s % string_data ) string_concat = s FIN FUNCIÓN string_concat FIN MÓDULO string_typePROGRAMA principal USAR string_type TIPO ( string80 ) :: s1 , s2 , s3 LLAMAR c_to_s_assign ( s1 , 'Mi nombre es' ) LLAMAR c_to_s_assign ( s2 , ' Linus Torvalds' ) s3 = s1 // s2 ESCRIBIR ( * , * ) 'Resultado: ' , s3 % string_data ESCRIBIR ( * , * ) 'Longitud: ' , s3 % length FIN DEL PROGRAMA

Se requieren operadores definidos como estos para las expresiones que también están permitidas en los constructores de estructuras (ver Tipos de datos derivados ):

str1 = string ( 2 , char1 // char2 ) ! constructor de estructura

En el caso de los arreglos, siempre que tengan la misma forma (conformables), las operaciones y asignaciones se extienden de manera obvia, elemento por elemento. Por ejemplo, dadas las declaraciones de

REAL , DIMENSIÓN ( 10 , 20 ) :: a , b , c REAL , DIMENSIÓN ( 5 ) :: v , w LOGICAL flag ( 10 , 20 )

Se puede escribir:

a = b ! asignación de matriz completa c = a / b ! división y asignación de matriz completa c = 0. ! asignación de matriz completa del valor escalar w = v + 1. ! suma de matriz completa al valor escalar w = 5 / v + a ( 1 : 5 , 5 ) ! división de matriz y suma al indicador de sección = a == b ! prueba relacional y asignación de matriz completa c ( 1 : 8 , 5 : 10 ) = a ( 2 : 9 , 5 : 10 ) + b ( 1 : 8 , 15 : 20 ) ! suma y asignación de sección de matriz v ( 2 : 5 ) = v ( 1 : 4 ) ! asignación de sección superpuesta

El orden de evaluación de las expresiones no se especifica para permitir la optimización en máquinas paralelas y vectoriales. Por supuesto, cualquier operador para matrices de tipo derivado debe estar definido.

Algunas funciones intrínsecas reales que son útiles para los cálculos numéricos son:

Estos son valores de matriz para argumentos de matriz (elementales), como todas las funciones de FORTRAN 77 (excepto LEN):

Potencias, logaritmos y funciones trigonométricas

Números complejos:

Lo siguiente se refiere a los personajes:

La GO TOetiqueta simple existe, pero generalmente se evita ; en la mayoría de los casos, una estructura de ramificación más específica logrará la misma lógica con mayor claridad. 

La prueba condicional simple es la IFsiguiente:IF(a>b)x=y

Una construcción completa IFse ilustra mediante

SI ( i < 0 ) ENTONCES  SI ( j < 0 ) ENTONCES x = 0. SINO z = 0. FIN SI SINO SI ( k < 0 ) ENTONCES z = 1. SINO x = 1. FIN SI

Esta CASEconstrucción reemplaza a la calculada GOTO, pero está mejor estructurada y no requiere el uso de etiquetas de sentencia:

SELECCIONAR CASO ( número ) ! número de tipo entero CASO (: - 1 ) ! todos los valores menores que 0 n_sign = - 1 CASO ( 0 ) ! solo 0 n_sign = 0 CASO ( 1 :) ! todos los valores mayores que 0 n_sign = 1 FIN SELECCIONAR

Cada CASElista de selección puede contener una lista y/o un rango de números enteros, caracteres o constantes lógicas, cuyos valores no pueden superponerse dentro de los selectores ni entre ellos:

CASO ( 1 , 2 , 7 , 10 : 17 , 23 )

Hay una opción predeterminada disponible:

CASO INCOMPETENTE

Solo hay una evaluación y solo un partido.

Una forma simplificada pero suficiente de la DOconstrucción se ilustra mediante:

exterior : HACER interior : HACER i = j , k , l ! de j a k en pasos de l (l es opcional) : SI (...) CICLO : SI (...) SALIR exterior : FIN HACER interior FIN HACER exterior

donde observamos que los bucles pueden tener nombres opcionales, de modo que cualquier instrucción EXIT o CYCLE puede especificar a qué bucle se refiere.

Muchos, aunque no todos, los bucles simples pueden reemplazarse por expresiones y asignaciones de matrices, o por nuevas funciones intrínsecas. Por ejemplo

tot = 0. HACER i = m , n tot = tot + a ( i ) FIN HACER

se convierte simplementetot=SUM(a(m:n))

Para abordar este tema, necesitamos algunas definiciones. En términos lógicos, un programa ejecutable consta de un programa principal y uno o más subprogramas (o procedimientos ), que realizan alguna función. Los subprogramas pueden ser funciones o subrutinas , ya sean externas, internas o de módulo . (Las subrutinas externas son las que ya conocíamos de FORTRAN 77).

Desde un punto de vista organizativo, sin embargo, un programa completo consta de unidades de programa . Estas pueden ser programas principales, subprogramas externos o módulos , y pueden compilarse por separado.

Un ejemplo de un programa principal (y completo) es

PROGRAMA test IMPRIMIR * , '¡Hola mundo!' FIN DEL PROGRAMA test

Un ejemplo de un programa principal y un subprograma externo que forman un programa ejecutable es:

PROGRAMA test LLAMAR print_message FIN PROGRAMA test SUBRUTINA print_message IMPRIMIR * , '¡Hola mundo!' FIN SUBRUTINA print_message

La forma de una función es

FUNCIÓN nombre ( arg1 , arg2 ) ! cero o más argumentos : nombre = ... : FIN FUNCIÓN nombre

La forma de referencia de una función esx=name(a,b)

Un subprograma interno es aquel que está contenido dentro de otro (con un máximo de un nivel de anidamiento) y proporciona un reemplazo para la función de instrucción:

SUBRUTINA exterior REAL x , y : CONTIENE  SUBRUTINA interior REAL y y = x + 1 .: FIN SUBRUTINA interior ! SUBRUTINA obligatoria FIN SUBRUTINA exterior

Decimos que outeres el anfitrión de inner, y que innerobtiene acceso a entidades en outermediante asociación de anfitrión (por ejemplo, a x), mientras que yes una variable localinner de .

El alcance de una entidad nombrada es una unidad de alcance , aquí outerless inner, y inner.

Los nombres de las unidades de programa y los procedimientos externos son globales , y los nombres de las variables DO implícitas tienen un ámbito limitado a la instrucción que las contiene.

Los módulos se utilizan para empaquetar

• Datos globales (sustituye a COMMON y BLOCK DATA de Fortran 77);
• definiciones de tipo (que constituyen en sí mismas una unidad de alcance);
• subprogramas (que entre otras cosas reemplazan el uso de ENTRY de Fortran 77);
• bloques de interfaz (otra unidad de alcance, véase Bloques de interfaz );
• grupos de nombres (consulte cualquier libro de texto).

Un ejemplo de un módulo que contiene una definición de tipo, un bloque de interfaz y un subprograma de función es:

MÓDULO interval_arithmetic TIPO interval REAL lower , upper FIN TIPO interval INTERFACE OPERATOR ( + ) MÓDULO PROCEDIMIENTO add_intervals FIN INTERFACE : CONTIENE  FUNCIÓN add_intervals ( a , b ) TIPO ( interval ), INTENCIÓN ( IN ) :: a , b TIPO ( interval ) add_intervals add_intervals % lower = a % lower + b % lower add_intervals % upper = a % upper + b % upper FIN FUNCIÓN add_intervals ! FUNCIÓN mandatory : FIN MÓDULO interval_arithmetic

y la simple declaración

USE interval_arithmetic

Proporciona asociación de uso a todas las entidades del módulo. Los subprogramas del módulo pueden, a su vez, contener subprogramas internos.

Los atributos PUBLICy PRIVATEse utilizan en las especificaciones de los módulos para limitar el alcance de las entidades. La forma del atributo es

REAL , PÚBLICO :: x , y , z ! predeterminado ENTERO , PRIVADO :: u , v , w

y el formulario de declaración es

PÚBLICO :: x , y , z , OPERADOR (. add .) PRIVADO :: u , v , w , ASIGNACIÓN ( = ), OPERADOR ( * )

El formulario de declaración debe utilizarse para limitar el acceso a los operadores y también puede utilizarse para cambiar la configuración predeterminada general:

PRIVADO ! establece el valor predeterminado para el módulo PÚBLICO :: only_this

Para los tipos derivados existen tres posibilidades: el tipo y sus componentes son todos PÚBLICOS, el tipo es PÚBLICO y sus componentes PRIVADOS (solo el tipo es visible y se pueden cambiar sus detalles fácilmente), o todo es PRIVADO (solo para uso interno en el módulo):

MÓDULO mine  TIPO PRIVADO , PÚBLICO :: lista REAL x , y TIPO ( lista ), PUNTERO :: siguiente FIN TIPO lista TIPO ( lista ) :: árbol : FIN MÓDULO mine

El USEpropósito de esta instrucción es obtener acceso a entidades en un módulo. Tiene opciones para resolver conflictos de nombres si un nombre importado es igual a uno local:

USE mine , local_list => list

o restringir las entidades utilizadas a un conjunto específico:

USA el mío , SOLAMENTE : lista

Estos se pueden combinar:

USE mine , ONLY : local_list => list

Podemos especificar la intención de los argumentos ficticios:

SUBRUTINA barajar ( ncards , cards ) ENTERO , INTENCIÓN ( ENTRADA ) :: ncards ENTERO , INTENCIÓN ( SALIDA ), DIMENSIÓN ( ncards ) :: cards

Además, es posible usar INOUT: en este caso, el argumento real debe ser una variable (a diferencia del caso predeterminado, donde puede ser una constante).

Los argumentos pueden ser opcionales:

SUBRUTINA mincon ( n , f , x , superior , inferior , igualdades , desigualdades , convexo , xinicio ) REAL , OPCIONAL , DIMENSIÓN :: superior , inferior : SI ( PRESENTE ( inferior )) ENTONCES ! comprobar la presencia del argumento real :

nos permite llamar minconpor

LLAMAR mincon ( n , f , x , upper )

Los argumentos pueden ser palabras clave en lugar de argumentos posicionales (que van primero):

LLAMAR mincon ( n , f , x , equalities = 0 , xstart = x0 )

Los argumentos opcionales y con nombre se gestionan mediante interfaces explícitas, es decir, con procedimientos internos o de módulo o con bloques de interfaz.

Cualquier referencia a un subprograma interno o de módulo se realiza mediante una interfaz explícita (es decir, el compilador puede ver todos los detalles). Una referencia a un procedimiento externo (o ficticio) suele ser implícita (el compilador asume los detalles). Sin embargo, también podemos proporcionar una interfaz explícita en este caso. Se trata de una copia del encabezado, las especificaciones y la instrucción END del procedimiento en cuestión, ya sea ubicada en un módulo o insertada directamente.

REAL FUNCTION minimum ( a , b , func ) ! devuelve el valor mínimo de la función func(x) ! en el intervalo (a,b) REAL , INTENT ( in ) :: a , b INTERFACE REAL FUNCTION func ( x ) REAL , INTENT ( IN ) :: x END FUNCTION func END INTERFACE REAL f , x : f = func ( x ) ! invocación de la función de usuario. : END FUNCTION minimum

Una interfaz explícita es obligatoria para

• argumentos opcionales y con nombre;
• Argumentos POINTER y TARGET (véase Punteros );
• Resultado de la función PUNTERO;
• Nuevo estilo de argumentos y funciones de matrices ( Manejo de matrices ).

Permite realizar comprobaciones completas en tiempo de compilación entre argumentos reales y ficticios.

En general, la mejor manera de garantizar que la interfaz de un procedimiento sea explícita es colocar el procedimiento en cuestión en un módulo o utilizarlo como un procedimiento interno.

Los bloques de interfaz proporcionan el mecanismo mediante el cual podemos definir nombres genéricos para procedimientos específicos:

INTERFAZ gamma ! nombre genérico FUNCIÓN sgamma ( X ) ! nombre específico REAL ( SELECTED_REAL_KIND ( 6 )) sgamma , x FIN  FUNCIÓN dgamma ( X ) ! nombre específico REAL ( SELECTED_REAL_KIND ( 12 )) dgamma , x FIN FIN INTERFAZ

donde un conjunto dado de nombres específicos que corresponden a un nombre genérico deben ser todos de funciones o todos de subrutinas. Si esta interfaz está dentro de un módulo, entonces es simplemente

INTERFAZ gamma PROCEDIMIENTO DEL MÓDULO sgamma , dgamma INTERFAZ FINAL

Podemos usar nombres existentes, por ejemplo SIN, y el compilador se encarga de establecer la asociación correcta.

Ya hemos visto el uso de bloques de interfaz para operadores definidos y asignación (ver Módulos ).

La recursión indirecta es útil para la integración multidimensional. Para

volumen = integrar ( fy , límites y )

Podríamos tener

FUNCIÓN RECURSIVA integrar ( f , límites ) ! Integrar f(x) desde límites(1) hasta límites(2) REAL integrar INTERFAZ  FUNCIÓN f ( x ) REAL f , x FIN FUNCIÓN f FIN INTERFAZ REAL , DIMENSIÓN ( 2 ), INTENCIÓN ( EN ) :: límites : FIN FUNCIÓN integrar

y para integrar f(x, y) sobre un rectángulo:

FUNCIÓN fy ( y ) USAR func ! el módulo func contiene la función f REAL fy , y yval = y fy = integrar ( f , xbounds ) FIN

La recursión directa es cuando un procedimiento se llama a sí mismo, como en

FUNCIÓN RECURSIVA factorial ( n ) RESULTADO ( res ) ENTERO res , n SI ( n . EQ . 0 ) ENTONCES res = 1 SINO res = n * factorial ( n - 1 ) FIN SI FIN

Aquí, destacamos la RESULTcláusula y la prueba de terminación.

Esta es una característica para la computación paralela .

En la instrucción y construcción FORALL , cualquier efecto secundario en una función puede impedir la optimización en un procesador paralelo ; el orden de ejecución de las asignaciones podría afectar los resultados. Para controlar esta situación, agregamos la palabra clave a la instrucción OR , una afirmación de que el procedimiento (expresado simplemente): PURESUBROUTINE FUNCTION 

• no altera ninguna variable global ,
• no realiza ninguna E/S,
• no tiene variables guardadas (variables con el SAVEatributo que conserva valores entre invocaciones), y
• Para las funciones, no altera ninguno de sus argumentos.

Un compilador puede comprobar que este es el caso, como en

FUNCIÓN PURA calcular ( x )

Todas las funciones intrínsecas son puras.

Fortran maneja un array de tamaño cero como un objeto legítimo, sin necesidad de codificación especial por parte del programador. Por lo tanto, en

HACER i = 1 , n x ( i ) = b ( i ) / a ( i , i ) b ( i + 1 : n ) = b ( i + 1 : n ) - a ( i + 1 : n , i ) * x ( i ) FIN HACER

No se requiere ningún código especial para la iteración final donde i = n. Observamos que una matriz de tamaño cero se considera definida; sin embargo, una matriz de forma (0,2) no es compatible con una de forma (0,3), mientras que es una instrucción válida de 'no hacer nada'.x(1:0)=3

Estas son una extensión y un reemplazo para los arreglos de tamaño asumido. Dado un argumento real como:

REAL , DIMENSIÓN ( 0:10 , 0:20 ) :: a : CALL sub ( a )​​​​

La especificación del argumento ficticio correspondiente define solo el tipo y el rango de la matriz, no su forma. Esta información debe estar disponible mediante una interfaz explícita, a menudo utilizando un bloque de interfaz (véase Bloques de interfaz ). Por lo tanto, escribimos simplemente

SUBRUTINA sub ( da ) REAL , DIMENSIÓN (:, :) :: da

y esto es como si datuviera dimensiones (11,21). Sin embargo, podemos especificar cualquier límite inferior y la matriz se adaptará en consecuencia.

REAL , DIMENSIÓN ( 0 :, 0 :) :: da

Se pasa la forma, no los límites, donde el límite inferior predeterminado es 1 y el límite superior predeterminado es la extensión correspondiente.

EQUIVALENCE Esta instalación proporciona un reemplazo parcial para los usos a los que se destinaba, útil para arreglos locales y temporales, como en

SUBRUTINA swap ( a , b ) REAL , DIMENSION (:) :: a , b REAL , DIMENSION ( SIZE ( a )) :: work work = a a = b b = work FIN DE SUBRUTINA swap

El almacenamiento propiamente dicho se mantiene normalmente en una pila.

Fortran proporciona asignación dinámica de almacenamiento; se basa en un mecanismo de almacenamiento de montón (y reemplaza otro uso de EQUIVALENCE). Un ejemplo para establecer un arreglo de trabajo para todo un programa es

MÓDULO work_array ENTERO n REAL , DIMENSIÓN (:,:,:), ASIGNABLE :: work FIN DEL MÓDULO PROGRAMA principal USAR work_array LEER ( entrada , * ) n ASIGNAR ( work ( n , 2 * n , 3 * n ), ESTADO = estado ) : DESASIGNAR ( work )

El arreglo de trabajo se puede propagar a través de todo el programa mediante una USE instrucción en cada unidad de programa. Podemos especificar un límite inferior explícito y asignar varias entidades en una sola instrucción. Para liberar almacenamiento muerto escribimos, por ejemplo,

DESALOJAR ( a , b )

La desasignación de matrices es automática cuando salen del ámbito.

Ya hemos realizado todas las asignaciones y operaciones de matrices:

REAL , DIMENSIÓN ( 10 ) :: a , b a = 0. ! difusión escalar; asignación elemental b = SQRT ( a ) ! resultado de la función intrínseca como objeto de matriz

En la segunda tarea, una función intrínseca devuelve un resultado con valores de matriz para un argumento con valores de matriz. Podemos escribir nosotros mismos funciones con valores de matriz (requieren una interfaz explícita):

PROGRAMA test REAL , DIMENSIÓN ( 3 ) :: a = ( / 1. , 2. , 3. / ), & b = ( / 2. , 2. , 2. / ), r r = f ( a , b ) PRINT * , r CONTIENE  FUNCIÓN f ( c , d ) REAL , DIMENSIÓN (:) :: c , d REAL , DIMENSIÓN ( SIZE ( c )) :: f f = c * d ! (o alguna función más útil de c y d) FIN FUNCIÓN f FIN PROGRAMA test

Los procedimientos elementales se especifican con argumentos ficticios escalares que pueden llamarse con argumentos reales en forma de matriz. En el caso de una función, la forma del resultado es la misma que la de los argumentos de la matriz.

La mayoría de las funciones intrínsecas son elementales, y Fortran 95 extiende esta característica a los procedimientos no intrínsecos, lo que permite escribir, en Fortran 90, 22 versiones diferentes para los rangos 0-0, 0-1, 1-0, 1-1, 0-2, 2-0, 2-2, ... 7-7, y además facilita la optimización en procesadores paralelos. Un procedimiento elemental debe ser puro.

SUBRUTINA ELEMENTAL swap ( a , b ) REAL , INTENCIÓN ( ENTRADA/SALIDA ) :: a , b REAL :: trabajo trabajo = a a = b b = trabajo FIN DE LA SUBRUTINA swap

Los argumentos ficticios no se pueden usar en expresiones de especificación (ver arriba ) excepto como argumentos para ciertas funciones intrínsecas ( BIT_SIZE, KIND, LEN, y las de consulta numérica, (ver abajo ).

A menudo, necesitamos enmascarar una asignación. Esto podemos hacerlo usando WHERE, ya sea como una declaración:

DONDE ( a /= 0.0 ) a = 1.0 / a ! evitar la división por 0

(nota: la prueba es elemento por elemento, no sobre todo el array), o como una construcción:

DONDE ( a /= 0.0 ) a = 1.0 / a b = a ! todos los arreglos tienen la misma forma FIN DONDE

o

DONDE ( a /= 0.0 ) a = 1.0 / a EN OTRO LUGAR a = ENORME ( a ) FIN DONDE

Más:

• Está permitido enmascarar no solo la WHEREdeclaración de la WHEREconstrucción, sino también cualquier ELSEWHEREdeclaración que contenga;
• Una WHEREestructura puede contener cualquier número de ELSEWHEREdeclaraciones enmascaradas, pero como máximo una ELSEWHEREdeclaración sin máscara, y esa debe ser la última;
• WHERE Las construcciones pueden estar anidadas unas dentro de otras, simplemente FORALLconstrucciones;
• Una WHEREdeclaración de asignación puede ser una asignación definida, siempre que sea elemental;
• Una WHEREconstrucción puede nombrarse de la misma manera que otras construcciones.

Cuando DOse ejecuta una construcción, cada iteración sucesiva se realiza en orden y una tras otra , lo que supone un impedimento para la optimización en un procesador paralelo. 

PARA TODOS ( i = 1 : n ) a ( i , i ) = x ( i )

donde las asignaciones individuales pueden realizarse en cualquier orden, e incluso simultáneamente. Esto FORALLpuede considerarse una asignación de matriz expresada mediante índices.

PARA TODOS ( i = 1 : n , j = 1 : n , y ( i , j ) /= 0. ) x ( j , i ) = 1.0 / y ( i , j )

con condición de enmascaramiento.

Esta FORALLestructura permite ejecutar varias sentencias de asignación en orden.

a ( 2 : n - 1 , 2 : n - 1 ) = a ( 2 : n - 1 , 1 : n - 2 ) + a ( 2 : n - 1 , 3 : n ) + a ( 1 : n - 2 , 2 : n - 1 ) + a ( 3 : n , 2 : n - 1 ) b ( 2 : n - 1 , 2 : n - 1 ) = a ( 2 : n - 1 , 2 : n - 1 )

es equivalente a las asignaciones de matrices

PARA TODOS ( i = 2 : n - 1 , j = 2 : n - 1 ) a ( i , j ) = a ( i , j - 1 ) + a ( i , j + 1 ) + a ( i - 1 , j ) + a ( i + 1 , j ) b ( i , j ) = a ( i , j ) FIN PARA TODOS

Esta FORALLversión es más legible.

La asignación en una función FORALLes similar a la asignación de un array: como si todas las expresiones se evaluaran en cualquier orden, se almacenaran temporalmente y, a continuación, se ejecutaran todas las asignaciones en cualquier orden. La primera instrucción debe completarse por completo antes de que pueda comenzar la segunda.

Un FORALLpuede estar anidado y puede incluir un WHERE. Los procedimientos a los que se hace referencia dentro de un FORALLdeben ser puros.

Para un caso simple, dado

REAL , DIMENSIÓN ( 100 , 100 ) :: a

Podemos hacer referencia a un único elemento como, por ejemplo, a(1, 1). Para un tipo de datos derivado como

TIPO fun_del REAL u REAL , DIMENSIÓN ( 3 ) :: du FIN TIPO fun_del

Podemos declarar un array de ese tipo:

TIPO ( fun_del ), DIMENSIÓN ( 10 , 20 ) :: tar

y una referencia como es un elemento (¡un escalar!) de tipo fun_del, pero es un array de tipo real, y es un elemento de este. La regla básica que hay que recordar es que un elemento de un array siempre tiene un subíndice o subíndices que califican al menos el último nombre.tar(n,2)tar(n,2)%dutar(n,2)%du(2)

La forma general del subíndice para la sección de la matriz es

 [ inferior ]: [ superior ] [: zancada ]

(donde [ ] indica un elemento opcional) como en

REAL a ( 10 , 10 ) a ( i , 1 : n ) ! parte de una fila a ( 1 : m , j ) ! parte de una columna a ( i , : ) ! fila completa a ( i , 1 : n : 3 ) ! cada tercer elemento de la fila a ( i , 10 : 1 : - 1 ) ! fila en orden inverso a ( ( / 1 , 7 , 3 , 2 / ), 1 ) ! subíndice de vector a ( 1 , 2 : 11 : 2 ) ! 11 es válido ya que no está referenciado a (:, 1 : 7 ) ! sección de rango dos

Tenga en cuenta que un subíndice vectorial con valores duplicados no puede aparecer en el lado izquierdo de una asignación, ya que sería ambiguo. Por lo tanto,

b ( ( / 1 , 7 , 3 , 7 / ) ) = ( / 1 , 2 , 3 , 4 / )

es ilegal. Además, una sección con un subíndice vectorial no debe proporcionarse como argumento real a un argumento OUTficticio INOUT. No se permiten matrices de matrices:

alquitrán % du ! ilegal

Observamos que un valor determinado en una matriz puede referenciarse tanto como un elemento como una sección:

a ( 1 , 1 ) ! escalar (rango cero) a ( 1 : 1 , 1 ) ! sección de matriz (rango uno)

dependiendo de las circunstancias o requisitos. Al calificar objetos de tipo derivado, obtenemos elementos o secciones según la regla indicada anteriormente:

tar % u ! sección de matriz (componente de estructura) tar ( 1 , 1 )% u ! componente de un elemento de matriz

Multiplicación de vectores y matrices

Reducción de matrices

Consulta de matriz

Construcción de matrices

Remodelación de la matriz

Manipulación de matrices

Ubicación de la matriz

Los punteros son variables con el POINTERatributo; no son un tipo de dato distinto (y por lo tanto no es posible la "aritmética de punteros").

REAL , PUNTERO :: var

Conceptualmente, son un descriptor que enumera los atributos de los objetos (objetivos) a los que puede apuntar el puntero, y la dirección, si la hay, de un objetivo. No tienen almacenamiento asociado hasta que se asigna o se asocia de otra manera (mediante asignación de puntero, véase más abajo ):

ASIGNAR ( var )

y se desreferencian automáticamente, por lo que no se requiere ningún símbolo especial. En

var = var + 2.3

El valor del destino de var se usa y se modifica. Los punteros no se pueden transferir a través de E/S. La instrucción

ESCRIBIR * , var

escribe el valor del destino de var y no el descriptor del puntero en sí.

Un puntero puede apuntar a otro puntero y, por lo tanto, a su destino, o a un objeto estático que tenga el TARGETatributo:

REAL , PUNTERO :: objeto REAL , OBJETIVO :: objeto_objetivo var => objeto ! asignación de puntero var => objeto_objetivo

pero están fuertemente tipificados:

ENTERO , PUNTERO :: int_var var => int_var ! ilegal: los tipos deben coincidir

Y, de forma similar, para los arreglos, tanto los rangos como el tipo deben coincidir.

Un puntero puede ser un componente de un tipo derivado:

TIPO entrada ! tipo para matriz dispersa REAL :: valor ENTERO :: índice TIPO ( entrada ), PUNTERO :: siguiente ! nota recursión FIN TIPO entrada

y podemos definir el comienzo de una cadena enlazada de dichas entradas:

TIPO ( entrada ), PUNTERO :: cadena

Después de las asignaciones y definiciones adecuadas, las dos primeras entradas podrían ser tratadas como

cadena % cadena de valor % siguiente % cadena de valor % cadena de índice % siguiente % cadena de índice % siguiente cadena % siguiente % siguiente

pero normalmente definiríamos punteros adicionales para apuntar, por ejemplo, a la primera y a la entrada actual de la lista.

El estado de asociación de un puntero es uno de

Hay que tener cuidado de no dejar un puntero "colgante" al usarlo DEALLOCATEen su destino sin anular ningún otro puntero que haga referencia a él.

La función intrínseca ASSOCIATEDpuede comprobar el estado de asociación de un puntero definido:

SI ( ASOCIADO ( ptr )) ENTONCES

o entre un puntero definido y un destino definido (que, a su vez, puede ser un puntero):

SI ( ASOCIADO ( ptr , objetivo )) ENTONCES

Una forma alternativa de inicializar un puntero, también en una declaración de especificación, es utilizar la NULLfunción:

REAL , PUNTERO , DIMENSIÓN (:) :: vector => NULL () ! tiempo de compilación vector => NULL () ! tiempo de ejecución