fortran90 -...

Introducción a las Herramientas Informáticas Unix para el Desarrollo de la Investigación. 2002

Introducción a las Herramientas Informáticas Unix para el

Desarrollo de la Investigación

Francisco de [email protected]

Dpto. de Estadística, I.O. yComputación

Fortran9024−25 de junio de 2002


Presentación

� Nombre� Campo de trabajo� Experiencia en informática� Módulos del curso que ha realizado� Motivación que le ha llevado a matricularse


Contenidos del Curso

1.− Introducción

2.− Código fuente, tipos y estructuras de control3.− Procedimientos y Módulos4.− Proceso de vectores5.− Punteros

6.− Nuevas características de entrada/salida7.− Procedimientos intrínsecos8.− Características redundantes

9.− Desarrollos futuros


1Introducción


Introducción

Índice� 1.1 Historia� 1.2 Objetivos� 1.3 Principales características� 1.4 Otras características� 1.5 Disponibilidad de compiladores� 1.6 Referencias� 1.7 Lista de recursos� 1.8 Convenios de codificación


Historia

FORmula TRANslation

� 1954 Fortran I� 1958 Fortran II� 1958 Fortran IV� 1966 Fortran 66 standard� 1978 Fortran 77 standard� 1991 Fortran 90 standard� La próxima revisión se espera que ocurra

dentro de unos 10 años


Objetivos de Fortran 90

� Evolucionar el lenguaje� Características obsoletas

� Estandarizar las extensiones de las diferentes compañías

� Portabilidad

� Modernizar el lenguaje� Facilitando su utilización a través de nuevas

características como los tipos derivados o el formato libre

� Introducción de gestión de memoria dinámica� Modularización a través de la definición de los

módulos� Portabilidad numérica a través de la selección

de precisión� Sentencias case, exit, cycle� Sobrecarga de operadores


Objetivos del lenguaje

� Proporcionar capacidad de paralelismo de datos

� Operaciones paralelas sobre vectores para una mejor utilización de procesadores vectoriales y máquinas paralelas

� Compatibilidad con Fortran77� Fortran77 es un subconjunto de Fortran90

� Mejorar la seguridad� Reduciendo el riesgo de errores en códigos

estándar

� Concordancia con el estándar� Los compiladores han de notificar códigos no

estándar y características anticuadas


Principales Características

� Proceso de vectores

� Memoria dinámica

� Módulos

� Procedimientos:� Parámetros opcionales y parámetros con

nombre� Procedimientos internos� Procedimientos recursivos

� Punteros


Otras Características

� Formato del código fuente

� Especificaciones / implicit none

� Tipos de datos parametrizados (kind)

� Tipos derivados y sobrecarga de operadores

� Estructuras de control

� Nuevas funciones intrínsecas

� Nuevas características de entrada/salida


Características obsoletas

Fortran90 sigue manteniendo algunas características que califica de obsoletas. Pueden ser eliminadas en la siguiente revisión del lenguaje:

http://www.ccti.ull.es/cpu/f90/f90_reference_manual_a.txt

� if aritmético� Variables real y double en bucles do y

expresiones de control� Terminación del do con sentencias distintas de

continue o end do� Sentencias assign y goto asignadas� Especificadores asignados en sentencias

format� Saltos a un end if desde dentro de un bloque if� return alternado� Sentencia pause� Descriptor H edit


Disponibilidad

Compiladores de Fortran90� Where can I get a f95 compiler?http://www.physics.ohio−state.edu/~wilkins/computing/f95.htmlhttp://www.fortran.com/fortran/metcalf.htm

� Cray CF90 − YMP vectorización. Mensajes limitados y algunas funciones intrínsecas no están bien ajustadas

� DEC Fortran90 − DEC OSF/1. Incluye extensiones HPF

http://www.ccti.ull.es/cpu/f90/f90.htm

� EPC Fortran90 − SPARC Solaris, IBM RS/6000, Intel 3/486, Motorola 88000

� IBM XLF V3 − RISC System 6000

� Lahey − Fujitsu LF90 − Para DOS y Windowshttp://www.lahey.com/


Disponibilidad

� Microway − DOS, OS/2, Unix� NA Software F90+ − 386/486, Sparc, T800, T9000� Portland Grouphttp://www.pgroup.com/

� NAG f90 − Diversas plataformas Unix y VAX/VMS. Utiliza C como lenguaje intermedio

http://www.nag.com/nagware.asp

� Pacific Sierra VAST−90 − Utiliza Fortran77 como lenguaje intermedio

� Parasoft − F77 como lenguaje intermedio

� Absofthttp://www.cs−software.com/software/fortran/absoft/absoft.html

� Salford FTN90 − Implementación para PC�s del

NAG f90. Genera código directamente


Referencias

Bibliografía y Referencias� Adams, J. C. et. al. (1992) Fortran 90

Handbook. McGraw−Hill.

ISBN 0−07−000406−4

� Brainerd, W. S. et. al., (1994) Programmer’s Guide to Fortran 90. 2nd edition , Unicomp. ISBN 0−07−000248−7

� Counihan, M. (1991) Fortran 90. Pitman. ISBN 0−273−03073−6


Referencias

Bibliografía y Referencias� Hahn, B. D. (1994) Fortran 90 for Scientists

and Engineers. Edward Arnold. ISBN: 0−340−60034−9

� Kerrigan, J. (1993) Migrating to Fortran 90. O’Reilly and Associates. ISBN 1−56592−049−X

� Metcalf, M. & Reid, J. (1992) Fortran 90 Explained. Oxford University Press. ISBN: 0−19−850558−2

� Morgan, J. S. & Schonfelder, J. L. (1993) Programming in Fortran 90. Alfred Waller Ltd. ISBN 1−872474−06−3

� Smith, I M. Programming in Fortran 90. Wiley. 0471−94185−9


Referencias

Bibliografía y Referencias

� Este Curso

http://webpages.ull.es/~fsande/doctorado/curso_doc.html

� Recursos sobre Fortran:

http://webpages.ull.es/~fsande/doctorado/curso_doc.html

http://www.csi.ull.es/~sande/compi2/recursos.html

� Pueden encontrar:� FAQ� Cursos y tutoriales� Grupos de discusión� Repositorios de software


Convenios de codificación

� Reservar las mayúsculas solo para constantes. Utilizaremos minúsculas para las palabras reservadas.

� Indentar 2 columnas en el cuerpo de las unidades de programa, bloques interface, bucles do, bloques if, bloques case, etc.

� Incluir siempre el nombre del programa, subrutina o función en su sentencia end

� En las sentencias use utilizar la cláusula only para documentar explícitamente todos los elementos que son accedidos desde ese módulo

� En sentencias call y referencias a funciones utilizar parámetros con nombre para los parámetros opcionales


Conexión al sistema

t el net t ei de. cct i . ul l . es

l ogi n: i c2al uXXpasswd: i hi u2001/usr / l ocal / bi n/ t cshhome> mkdi r f 90home> cd f 90home/ f 90> cp / t mp/ i ni c i o. t ar

.home/ f 90> t ar xvf i ni c i o. t arhome/ f 90> cd i ni c i ohome/ f 90> f 90 hol a. f 90home/ f 90> l s −lhome/ f 90> . / a. outhome/ f 90> man f 90


2Código Fuente,

Tipos yEstructurasde Control



1.− Introducción2.− Código fuente, tipos y estructuras de

control3.− Procedimientos y Módulos4.− Proceso de vectores5.− Punteros

6.− Nuevas características de entrada/salida7.− Procedimientos intrínsecos8.− Características redundantes9.− Desarrollos futuros


Código Fuente, Tipos yEstructuras de Control

Índice� 2.1 Formato del código fuente� 2.2 Especificaciones� 2.3 implicit none� 2.4 Valores de clase (Kind)� 2.5 Tipos derivados� 2.6 Sentencias de control� 2.7 Ejercicios


Código Fuente

� Las líneas pueden tener hasta 132 caracteres� Se permiten letras minúsculas� Identificadores hasta 31 caracteres (incluyendo

el subrayado, underscore) (El primer carácter ha de ser una letra). Usar identificadores significativos!!

� Se usa punto y coma (;) para separar diferentes sentencias en la misma línea

� Los comentarios pueden comenzar con exclamación (!)

� El Ampersand (&) se usa como signo de continuación

� El juego de caracteres incluye

+ < > ; ! ? % − “ &

� Nuevos operadores relacionales:

< <= == /= >= >


Código Fuente

Ejemplo:

pr ogr am pr ogr ama_en_f or mat o_l i br e! nombr es l ar gos con subr ayado! No hay col umnas especi al esi mpl i c i t none

! Mayúscul as y mi núscul asr eal : : t x, t y, t z ! Coment ar i o f i nal

! Var i as sent enci as por l í neat x = 1. 0; t y = 2. 0; t z = t x * t y;

! Las l í neas se pueden par t i rpr i nt * , &t x, t y, t zend pr ogr am pr ogr ama_en_f or mat o_l i br e


Especificaciones

Una especificación es una forma (extendida) de declaración donde se colocan juntas todas las características de una entidad

tipo [ [, atributo ] ... :: ] lista

� El tipo puede ser integer, real, complex, logical o character con un valor de clase opcional:i nt eger [ ( [ k i nd=] ki nd−val ue) ]char act er [ ( act ual −par amet er −l i st ) ]t ype ( t ype−name)

� El atributo puede serpar amet er publ i cpr i vat e poi nt ert ar get al l ocat abl edi mensi on( ext ent −l i st ) i nt ent ( i nout )opt i onal saveext er nal i nt r i nsi c

� Se pueden inicializar variables en las especificaciones


Especificaciones

Ejemplosr eal : : a = 2. 61828, b = 3. 14159! Dos var i abl es r eal es decl ar adas e! i ni c i al i zadas

i nt eger , par amet er : : N = 100, M = 1000! Decl ar aci ón e i ni c i al i zaci ón de dos! const ant es ent er as

char act er ( l en = 8) : : ch! Decl ar aci ón de una cadena de car act er es! de l ongi t ud 8

i nt eger , di mensi on( −3: 5, 7) : : i a! Decl ar aci ón de un vect or de ent er os con ! l í mi t e i nf er i or negat i vo

i nt eger , di mensi on( −3: 5, 7) : : i a, i b, i c( 5, 5)! Vect or es de 9x7 component es! Los í ndi ces de i c var í an en [ 1, 5] [ 1, 5]


implicit none

� En Fortran77 los tipos implícitos permiten la utilización de variables no declaradas. Esto ha sido la causa de muchos errores de programación

� implicit none obliga a declarar todas las variables que se utilizan en un programa

� implicit none puede ir precedida en una unidad de programa solamente por sentencias use y format


Valores de clase

� Hay 5 tipos intrínsecos: real, integer, complex, character y logical

� Cada tipo puede tener asociado un valor entero no negativo llamado el parámetro de clase de tipo (Kind). El parámetro de clase es un entero no negativo.

� Se trata de una característica útil para escribir código portable que requiera una precisión numérica determinada

� Los valores de clase dependen de la máquina en cuestión, pero todo procesador ha de soportar al menos 2 clases para real y complex y 1 para integer, logical y character

� Hay diversas funciones intrínsecas para obtener y establecer los parámetros de clase


Valores de clase

realr eal ( k i nd=wp) : : r a ! o bi en:r eal ( wp) : : r a

� Declara una variable, ra, cuya precisión está determinada por el parámetro de clase wp

� Los valores de clase son dependientes del sistema

� Una variable real de 8 bytes (64 bits) habitualmente tiene un valor de clase 8 ó 2

� Una variable real de 4 bytes (32 bits) habitualmente tiene un valor de clase de 4 ó 1


Valores de clase

� La función intrínseca kind, que tiene un parámetro de cualquier tipo intrínseco devuelve la clase de tipo de su parámetro. Por ejemplo:

r eal ( k i nd = 2) : : x ! x decl ar ada de cl ase de t i po 2

r eal : : y ! y decl ar ada de cl ase de t i po ! por def ect oi nt eger : : i , ji = k i nd( x) ! i =2j = k i nd( y) ! j t i ene el val or por ! def ect o de l os r eal es ! El val or de j depende ! del s i st ema


Valores de clase

r eal

� La función intrínseca selected_real_kind tiene dos parámetros enteros opcionales, p y r El valor p especifica el número de dígitos decimales y r especifica el mínimo rango de exponente que se desea

� La función selected_real_kind (p, r) devuelve el valor de clase que se ajusta o que excede los requisitos dados por p y r. Si más de un valor de clase satisface los requisitos el valor que se devuelve es el que tenga la mínima precisión decimal. Si la precisión no está disponible se retorna −1. Si el rango no está disponible, −2

http://www.ccti.ull.es/cpu/f90/f90_reference_manual_9.txt


Valores de clase

r eal

� El uso de kind con esta función da una gran portabilidad:

i nt eger , par amet er : : i dp=ki nd( 1. 0D)r eal ( k i nd=i dp) : : r a

� La variable r a se declara de doble precisión.

� Nótese que el valor de clase depende del sistema

i nt eger , par amet er : : I DP = ki nd( 1. 0D)compl ex ( k i nd=I DP) : : r ai z1, r ai z2


Valores de clase

integer

� Los enteros habitualmente tienen 16, 32 ó 64 bits

� Para declarar un entero de forma que dependa del sistema, indique el valor de clase asociado con el rango de enteros que se desea:

i nt eger , par amet er : : & I 8=sel ect ed_I NT_ki nd( 8)

i nt eger ( k i nd=I 8) : : i a, i b, i c

� Las variables ia, ib, ic tomarán valores en el

rango de al menos [−108, 108] si lo permite el procesador


Valores de clase

pr ogr am mayor esi mpl i c i t nonei nt eger , par amet er : : & I 8 = sel ect ed_I NT_ki nd( 8)i nt eger ( k i nd=I 8) : : i apr i nt * , huge( i a) , k i nd( i a)end pr ogr am mayor es

� Este código imprime el mayor entero disponible para este tipo de enteros, y su valor de clase

i nt eger , par amet er : : & I 10 = sel ect ed_r eal _ki nd( 10, 200)r eal ( k i nd=I 10) : : apr i nt * , r ange( a) , pr eci s i on( a) , k i nd( a)

� Imprime el rango del exponente, los dígitos de precisión y el valor de clase de la variable a


Tipos derivados

� Son definidos por el usuario

� Pueden contener diferentes tipos intrínsecos (básicos) y otros tipos derivados

� Las componentes se acceden usando el símbolo (%)

� El único operador predefinido para tipos derivados es el de asignación (=)

� Se pueden (re)definir operadores (los estudiaremos con la sobrecarga de operadores)


Tipos derivados

Ejemplos:� Definición de la forma del tipo derivado:

t ype mat r i cul a char act er ( l en=2) : : l et r a i nt eger : : numer o char act er ( l en=2) : : pr ovend t ype mat r i cul a

� Declaración de variables de ese tipo:t ype( mat r i cul a) : : coche1, coche2mat r i cul a : : coche1 ! I ncor r ect o!

� Asignar un valor constante a coche1:coche1 = mat r i cul a(

�AG’ , 2227,

�TF’ )

� Uso de % para asignar una componente de coche2:coche2%l et r a =

�BZ’


Tipos derivados

Ejemplos:� Definir un vector de un tipo derivado:

t ype ( mat r i cul a) , di mensi on( n) : : coches

� Definir un tipo derivado conteniendo otro:t ype househol d char act er ( l en=1) : : name char act er ( l en=50) : : addr ess t ype( mat r i cul a) : : carend t ype househol d

� Declarar una estructura de tipo household:t ype( househol d) : : myhouse

� Utilizar % para referenciar una componente letra:myhouse%car %l et r a =

�BZ

�

� Una constante de un tipo derivado:t ype punt os: : or i gi n=punt os( 0. 0, 0. 0, 0. 0)


Estructuras de Control

� Fortran 90 posee tres constructores de bloque:

if do case

� Todos ellos pueden ser anidados y puede dárseles nombres para incrementar la legibilidad y fiabilidad



if� La Forma general de un if es:

[ name: ] i f ( l ogi cal expr essi on) t hen bl ockel se i f ( l ogi cal expr essi on) t hen [ name] bl ock] . . . [ el se [ name] bl ock] end i f [ name]

Ejemplo:

sel ecci on: i f ( i < 0) t hen cal l negat i vo el se i f ( i ==0) t hen sel ecci on cal l cer o el se sel ect cal l posi t i vo end i f sel ecci on



Bucles do� Forma general:

[ name: ] do [ cont r ol c l ause] bl ock end do [ name]

� La cláusula de control puede ser:

� Una cláusula de control de iteracióncount = i ni c i al , f i nal [ , i ncr ]

� una cláusula de control whilewhi l e ( expr . l ogi ca)

� ninguna



Bucles do� Clausula de control de iteración:

f i l s : do i = 1, ncol s: do j = 1, m a( 1, j ) = i + j end do col s end do f i l s

� Cláusula de control while:ci er t o: do whi l e ( i <= 100). . .Body of l oop. . .end do t r ue



Bucles do

� Uso de exit y cycle:� Se sale de un bucle con exit� cycle transfiere control al end do� exit y cycle, por defecto se refieren al bucle más

interno pero pueden referirse a un bucle con nombre



Bucles doUso de exit y cycle:ext er : do i = 1, ni nt er m: do j = 1, mi nt er n: do k = 1, l . . .i f ( a( i , j , k) <0) exi t ext er ! Sal t a f uer ai f ( j ==5) cycl e i nt er m ! Omi t e j ==5 y ! hace j =6i f ( i ==5) cycl e ! Sal t a el r est o ! Del bucl e i nt er no ! Y pasa a su ! Si gui ent e i t er aci ón. . . end do i nt er n end do i nt er m end do ext er



Bucles do� Sin cláusula de control:

dor ead( * , * ) xi f ( x < 0) exi ty = sqr t ( x). . .end do

� Nótese que esta forma puede tener el mismo efecto que un bucle do−while



case� Es una forma estructurada de seleccionar

diferentes opciones, dependiendo del valor de una única expresión

� Sirve para reemplazar a:� Un goto calculado (Fortran77)� Repetidos if ... then ... else

� Forma General:[ name: ] sel ect case ( expr essi on) [ case ( sel ect or ) [ name] bl ock] . . . end sel ect [ name]



case

� La expresión ha de ser de tipo character, logical o integer

� El selector ha de ser default o bien uno ó más valores del mismo tipo que la expresión:

� Un único valor� Un rango de valores separados por : (solamente

integer o character)� Una lista de valores o rangos. El valor mayor o

menor del rango puede omitirse



case

� Ejemplo:col our : sel ect case ( ch)

case (�C

�,

�D

�,

�G

�:

�M

�)

col our = �red

�

case (�X

�:)

col our = �green

�

case def aul t

col our = �blue

�

end sel ect col our

� Por compatibilidad con Fortran77, la sentencia goto sigue estando disponible, pero es preferible usar if, do, case, exit y cycle en su lugar


3Procedimientos

yMódulos



1.− Introducción




Procedimientos y Módulos

Índice� 3.1 Unidades de programa� 3.2 Procedimientos� 3.3 bloques interface� 3.4 Procedimientos internos� 3.5 Argumentos procedurales� 3.6 Cláusula result para funciones� 3.7 Funciones que devuelven vectores� 3.8 Procedimientos recursivos� 3.9 Procedimientos genéricos� 3.10 Módulos� 3.11 Sobrecarga de operadores� 3.12 Definición de operadores� 3.13 Sobrecarga del operador de asignación� 3.14 Ámbito� 3.15 Estructura de los programas� 3.16 Ejercicios


Unidades de Programa

ProcedimientosInternos

Procedimientosde módulo

ProcedimientoExterno

ProgramaPrincipal

Módulo


Unidades de programa

� Un programa sólo puede tener un único programa principal y todas las unidades de programa que se desee (módulos o procedimientos externos)

� Un módulo se utiliza para que diferentes programas compartan código (datos y subrutinas)


Programa Principal

� Forma:

pr ogr am nombr e_de_pr ogr ama [ sent enci as_de_especi f i caci ón] [ sent enci as_ej ecut abl es] . . .end [ pr ogr am [ nombr e_de_pr ogr ama] ]

� Ejemplo:

pr ogr am pr ueba. . .. . .! end! end pr ogr amend pr ogr am pr ueba


Procedimientos

� Llamamos procedimientos de forma genérica a Funciones y Subrutinas

� Una función devuelve un único resultado y no suele modificar los valores de sus parámetros. Las subrutinas realizan tareas generalmente más complejas y retornan valores a través de sus parámetros

� Estructuralmente los procedimientos pueden ser:

� Externos (autocontenidos, no necesariamente Fortran)

� Internos (dentro de una unidad de programa)� de Módulo (miembros de un módulo)

� Fortran 77 sólo tiene procedimientos externos� Un bloque interface se utiliza para definir los

detalles de los parámetros de un procedimiento. Es obligatorio para los procedimientos externos


Procedimientos Externos

� Forma:

subr out i ne nombr e( par ámet r os_f or mal es) [ sent enci as_de_especi f i caci ón] [ sent enci as_ej ecut abl es]. . .end [ subr out i ne [ nombr e] ]

O bien:

f unct i on nombr e( dummy−ar gument −l i st ) [ sent eci as_de_especi f i caci ón]

[ sent eci as_ej ecut abl es]. . .end [ f unct i on [ nombr e] ]


Procedimientos Internos

� Cualquier unidad de programa (un programa principal, un módulo o un procedimiento externo) puede contener procedimientos internos

� Los procedimientos internos se colocan todos juntos al final de una unidad de programa y precedidos por la sentencia contains

� Tienen la misma forma que los procedimientos externos excepto en que la palabra subroutine/function ha de aparecer en la sentencia end



� Las variables definidas en la unidad de programa permanecen accesibles (definidas) en los procedimientos internos, a menos que se redefinan allí

� Es una buena práctica declarar todas las variables que se utilicen en un subprograma (parámetros y variables locales)

� No se permite anidar procedimientos internos



� Ejemplo:pr ogr am pr i nci pali mpl i c i t noner eal : : a, b, cr eal : : suma_ppal. . .suma_ppal = suma( ). . .cont ai ns

f unct i on suma( )r eal : : suma ! a, b y c ya

def i ni dassuma = a + b + cend f unct i on suma. . .end pr ogr am pr i nci pal

Tiene efecto sobretodos los proc. internos

que contenga


Procedimientos internos

� implicit none en una unidad de programa también tiene efecto sobre todos los procedimientos internos que contenga. No obstante, se recomienda volver a usarlo, tanto por claridad como para evitar errores:

subr out i ne ar i t met i ca( n, x, y, z) i mpl i c i t none i nt eger : : n r eal , di mensi on( 100) : : x, y, z . . .cont ai ns

f unct i on suma( a, b, c) r esul t ( sum) i mpl i c i t none r eal , i nt ent ( i n) : : a, b, c r eal : : sum sum = a + b + c end f unct i on suma

end subr out i ne ar i t met i ca


Bloques interface

� Si se suministra explícitamente una interface para un procedimiento, el compilador puede comprobar inconsistencias en los parámetros

� En el caso de los subprogramas intrínsecos, los subprogramas internos y los módulos, el compilador conoce siempre esta información y se dice que es explícita

� Cuando se invoca un subprograma externo, esta información no está disponible y se dice que es implícita

� Fortran90 utiliza los bloques interface para especificar una interface explícita para los procedimientos externos

� Hay que utilizar siempre bloques interface en las unidades de programa que invoquen procedimientos externos


Bloques interface

� Forma general:i nt er f acecuer po_de_l a_i nt er f ace. . .end i nt er f ace ! Oj o: no se pone nombr e

� Donde cuerpo_de_la_interface es una copia exacta de la especificación del subprograma, su especificación de argumentos y su sentencia end

� Ejemplo:

i nt er f acer eal f unct i on f unc( x)r eal , i nt ent ( i n) : : x ! Lo ver emosend f unct i on f uncend i nt er f ace

� El bloque interface se coloca en la unidad de programa que realiza la llamada


Argumentos − Intent

Sirve para especificar si un parámetro de un procedimiento es para:

� Entrada (in) (No puede ser modificado)� Salida (out)� o ambos (inout)

� Ejemplosi nt eger , i nt ent ( i n) : : xr eal , i nt ent ( out ) : : yr eal , i nt ent ( i nout ) : : Z

subr out i ne i nt er c_r eal ( a, b) i mpl i c i t none r eal , i nt ent ( i nout ) : : a, b r eal : : t emp t emp = a a = b b = t empend subr out i ne i nt er c_r eal! l l amada: cal l i nt er c_r eal ( x, y)


Parámetros con nombre

� Se utiliza para evitar confusión cuando un procedimiento tiene varios parámetros. Evita el tener que recordar el orden de los parámetros.

� Ejemplo: Si se tiene la función

r eal f unct i on ar ea( i ni c i o, f i n, er r or ) i mpl i c i t none r eal , i nt ent ( i n) : : i ni c i o, f i n,

er r or . . .end f unct i on ar ea

� La llamada podría hacerse:

a = ar ea( 0. 0, 100. 0, 0. 01) b = ar ea( i ni c i o=0. 0, er r or =0. 01, f i n=100. 0)c = ar ea( 0. 0, er r or =0. 01, f i n=100. 0)


Parámetros con nombre

� Una vez que se usa un nombre para uno de los parámetros, el resto de parámetros han de usarlo también.

Así no es posible:

c=ar ea( 0. 0, er r or =0. 01, 100. 0) ! pr ohi bi do

� Aquí no se necesita una interface porque ar ea es una función interna. Sí haría falta si se tratara de un procedimiento externo con parámetros


Argumentos opcionales

� En ciertas ocasiones, no todos los parámetros necesitan estar presentes en una llamada. Un parámetro se puede declarar como opcional:

r eal f unct i on ar ea( i ni c i o, f i n, er r or ) i mpl i c i t none r eal , i nt ent ( i n) , opt i onal : : i ni c i o, & f i n, er r or . . .end f unct i on ar ea

� La llamada podría realizarse:

a=ar ea( 0. 0, 100. 0, 0. 010)b=ar ea( i ni c i o=0. 0, f i n=100. 0, er r or =0. 01)c=ar ea( 0. 0)d=ar ea( 0. 0, er r or =0. 01)


Parámetros opcionales

� La función lógica (intrínseca) present se utiliza para comprobar la presencia de un parámetro opcional:

r eal f unct i on ar ea( i ni c i o, f i n, er r or ) i mpl i c i t none r eal , i nt ent ( i n) , opt i onal : : i ni c i o, & f i n, er r orr eal t t ol . . .i f ( pr esent ( er r or ) ) t hen t t ol = er r orel se t t ol = 0. 01end i fend f unct i on ar ea

� No se podría modificar er r or , porque es intent(in). Por ello se usa una variable local, ttol


Parámetros opcionales

� Si el procedimiento es externo y tiene parámetros opcionales, se ha de suministrar una interface. Si la función del ejemplo anterior fuera externa sería necesario el siguiente bloque interface:

i nt er f ace r eal f unct i on ar ea( i ni c i o, f i n, er r or ) r eal , i nt ent ( i n) , opt i onal : : i ni c i o, & f i n, er r or end f unct i on ar eaend i nt er f ace


Tipos derivados como Argumentos

� Los parámetros de un procedimiento pueden ser de un tipo derivado si:

1.− El procedimiento es interno a la unidad de programa en la que se define el tipo derivado

2.− el tipo derivado se define en un módulo que es accesible desde el procedimiento


Parámetros procedurales

� En Fortran77 un parámetro procedural se ha de declarar como external

� En Fortran90 un procedimiento que es pasado como parámetro debe ser un procedimiento externo o un procedimiento de módulo

� No se permite pasar como parámetro un procedimiento interno

� Para procedimientos externos se recomienda suministrar un bloque interface en la unidad de programa que realiza la llamada

� Un procedimiento de módulo tiene una interface explícita por defecto


Argumentos procedurales

� Ejemplo:

La unidad de programa que realiza la llamada:. . .i nt er f ace r eal f unct i on f unc( x, y) r eal , i nt ent ( i n) : : x, y end f unct i on f uncend i nt er f ace. . .cal l ar ea( f unc, i ni c i o, f i n, er r or )

La función externa:

r eal f unct i on f unc( x, y) i mpl i c i t none r eal , i nt ent ( i n) : : x, y . . .end f unct i on f unc


Cláusula result para funciones

� Las funciones pueden tener una variable resultado.

El identificador de resultado que se utilice dentro de la función ha de ser especificado entre paréntesis al final de la sentencia function.

Ejemplo:

f unct i on suma( a, b, c) r esul t ( sum_abc)

i mpl i c i t none r eal , i nt ent ( i n) : : a, b, c r eal : : sum_abc sum_abc = a + b + cend f unct i on suma

� Las funciones directamente recursivas (la recursividad se estudia más adelante) han de tener una variable result


Funciones que devuelven vectores

� El resultado de una función no tiene porqué ser un escalar.

� El tipo de una función que devuelve un vector no se especifica en la sentencia function inicial sino en una declaración de tipo en el cuerpo de la función, en la que hay que especificar las dimensiones del vector:

f unct i on suma_vec ( a, b, n) i mpl i c i t none r eal , di mensi on ( n) : : suma_vec i nt eger , i nt ent ( i n) : : n r eal , di mensi on ( n) , i nt ent ( i n) : : a,

b do i = 1, n suma_vec( i ) = a( i ) + b( i ) end doend f unct i on suma_vec

� Si la función fuera externa, habría que especificar una interface en el programa llamador


Procedimientos Recursivos

� Los procedimientos se pueden invocar recursivamente:

� P1 invoca a P2 y P2 invoca a P1 o bien� P1 invoca directamente a P1 (se requiere result)

� Los procedimientos recursivos han de declararse como tales:

r ecur si ve f unct i on f act ( n) r esul t ( r es) i mpl i c i t none i nt eger i nt ent ( i n) : : n i nt eger : : r es i f ( n == 1) t hen r es=1 el se r es=n * f act ( n − 1) endi fend f unct i on f act

� ¡La recursividad es Ineficiente!


Procedimientos Genéricos

� Cuando se utilizan proc. genéricos, se usa un mismo identificador para el procedimiento y el código que se ejecuta depende del tipo de los parámetros (como en C++)

� Un procedimiento genérico se define utilizando un bloque interface y usando un identificador genérico para todos los procedimientos definidos dentro de ese bloque interface

� La forma general es:

i nt er f ace gener i c_name cuer po_especi f i co_de_l a_i nt er f ace cuer po_especi f i co_de_l a_i nt er f ace . . .end i nt er f ace

� Todos los procedimientos de un bloque interface genérico han de diferenciarse de forma no ambigua y por lo tanto todos han de ser subrutinas o todos funciones



� Ejemplo:

subr out i ne i nt er c_r eal i mpl i c i t none r eal , i nt ent ( i nout ) : : a, b r eal : : t emp t emp = a a = b b = t empend subr out i ne i nt er c_r eal

subr out i ne i nt er c_i nt i mpl i c i t none i nt eger , i nt ent ( i nout ) : : a, bi nt eger : : t emp t emp = a a = b b = t empend subr out i ne i nt er c_i nt



� Interface genérica:

i nt er f ace i nt er cambi a

subr out i ne i nt er c_r eal ( a, b) r eal , i nt ent ( i nout ) : : a, b end subr out i ne i nt er c_r eal

subr out i ne i nt er c_i nt ( a, b) i nt eger , i nt ent ( i nout ) : : a, b end subr out i ne i nt er c_i nt

end i nt er f ace

� Llamada:cal l i nt er cambi a( x, y)

� Vea un ejemplo en ej 2_modul es/ ej empl os/

gener i c_i nt er cambi a. f 90


Módulos

� Se trata de una característica del lenguaje que incide (positivamente) sobre la estructura de los programas

� Constituyen una forma de compartir datos y/o procedimientos entre diferentes unidades de programa

� Los módulos juegan un papel importante en la definición de tipos y operadores asociados

� La forma general es:

modul e nombr e [ sent eci as_de_especi f i caci ón] [ sent eci as_ej ecut abl es][ cont ai ns pr ocedi mi ent os_de_módul o]end [ modul e [ nombr e] ]

� Al módulo se accede a través de la sentencia use


Módulos:Datos globales

� En Fortran las variables son habitualmente entidades locales. Utilizando módulos es posible hacer accesibles un conjunto de datos a diferentes unidades de programa:modul e gl obal es r eal , save : : a, b, c i nt eger , save : : i , j , kend modul e gl obal es

� El atributo save permite declarar datos como globales (es un sustituto del COMMON de Fortran77)

� Los datos se utilizan en otras unidades de programa a través de la sentencia use:use gl obal es

� La sentencia use no es ejecutable y debe aparecer al principio de la unidad de programa antes que cualquier otra sentencia y después de program, function o subroutine


Módulos:Datos globales

� Una unidad de programa puede invocar código de diferentes módulos utilizando una serie de sentencias use.

Nótese que un módulo puede usar a su vez otros módulos, pero un módulo no puede usarse a sí mismo (ni directa ni indirectamente)

� Ejemplos de uso de la sentencia use:

use gl obal es! Per mi t e acceder a t odas l as var i abl es! del módul o

use gl obal es, onl y : a, c! Per mi t e acceder sól o a l as var i abl es

a! y c

use gl obal es, r =>a, s=>b! Per mi t e acceder a l as var i abl es a y b! a t r avés de l os i dent i f i cador es r y s


Módulos:Procedimientos de módulo

� Los procedimientos que se especifican dentro de un módulo se llaman procedimientos de módulo

� Son procedimientos que pueden ser accedidos (utilizados) por otras unidades de programa

� Puede haber varios procedimientos de módulo contenidos en el mismo módulo

� Han de estar codificados en Fortran (los externos pueden estar en otro lenguaje)

� Tienen la misma forma que los procedimientos externos salvo que:

� Los procedimientos de un módulo deben aparecer después de una sentencia contains

� La sentencia end ha de tener especificada una subroutine o function

� Se invocan mediante la sentencia call o referencia a la función, pero sólo desde una unidad de programa que haya declarado con una sentencia use la utilización del módulo en cuestión


� Los procedimientos de módulo son especialmente útiles para un conjunto de tipos derivados y sus correspondientes operaciones

modul e modul o_punt os t ype punt os r eal : : x, y end t ype punt os

cont ai ns f unct i on suma_punt os( p, q) t ype ( punt os) , i nt ent ( i n) : : p, q t ype ( punt os) : : suma_punt os suma_punt os%x = p%x + q%x suma_punt os%y = p%y + q%y end f unct i on suma_punt os

end modul e modul o_punt os



� El programa principal podría declarar:

use modul o_punt ost ype ( punt os) : : px, py, pz . . .pz = suma_punt os( px, py)



Módulos:Procedimientos genéricos

� La utilización de módulos permite parámetros de tipos derivados y por tanto procedimientos genéricos con tipos derivados

� Veamos como ejemplo, una extensión del procedimiento intercambia genérico que hemos desarrollado, para intercambiar puntos:


Módulos

modul e i nt er cambi o_gener i co i mpl i c i t none t ype punt os r eal : : x, y end t ype punt os i nt er f ace i nt er cambi a modul e pr ocedur e i nt er c_r eal , & i nt er c_i nt , i nt er c_l og, i nt er c_punt os end i nt er f ace

cont ai ns subr out i ne i nt er c_punt os ( a, b) i mpl i c i t none t ype ( punt os) , i nt ent ( i nout ) : : a, b t ype ( punt os) : : t emp t emp = a a = b b = t emp end subr out i ne i nt er c_punt os


Módulos

subr out i ne i nt er c_r eal i mpl i c i t none r eal , i nt ent ( i nout ) : : a, b r eal : : t emp t emp = a a = b b = t emp end subr out i ne i nt er c_r eal ! Rut i nas s i mi l ar es par a i nt er cambi ar! ot r os t i pos de dat os. . .end modul e i nt er cambi o_gener i co


Módulos:Private y Public

� Por defecto, todas las entidades de un módulo son accesibles a las unidades de programa que utilicen la sentencia use

� A veces interesa prohibir el uso de ciertas entidades al programa llamador para forzar al usuario a utilizar las rutinas del módulo en lugar de las suyas propias o también para permitir flexibilidad a la hora de realizar cambios internos sin necesidad de informar a los usuarios del módulo o cambiar la documentación

� Esto se consigue a través de la sentencia private:

pr i vat e : : sub1, sub2

� o el atributo private:

i nt eger , pr i vat e, save : : f i l , col


Sobrecarga de operadores

� En Fortran90 se puede extender el significado de un operador intrínseco para que actúe sobre tipos de datos adicionales: a ello se le llama sobrecarga de operadores. Para conseguirlo se necesita un bloque interface de la forma:

i nt er f ace oper at or ( op_i nt r i nseco) cuer po_de_l a_i nt er f aceend i nt er f ace

� Por ejemplo, el operador �+

� podría extenderse a

variables de tipo carácter para concatenar dos cadenas de caracteres ignorando los espacios sobrantes, y el código podría colocarse en un módulo:


Sobrecarga de operadores

� Ahora la expresión �cha + chb

� tiene

significado en cualquier programa que �use

�

este módulo

� Obsérvese en el ejemplo el bloque interface. La función que define el operador está en un módulo y no es necesario tener interfaces explícitas para procedimientos de módulo que están dentro del mismo módulo

� Cuando se da un nombre genérico o un operador para un conjunto de procedimientos, se necesita un bloque de interface. El bloque interface tiene la forma:

i nt er f ace . . . l i s t a_de_pr ocedi mi ent os_de_modul o end i nt er f ace


Definición de operadores

� Se pueden definir nuevos operadores

� Resulta especialmente útil para tipos definidos por el usuario

� Los operadores definidos han de tener �.

� (punto)

al principio y al final. Por ejemplo, en el ejemplo anterior podríamos haber definido .mas. en lugar de sobrecargar +

� La operación se ha de definir a través de una función que tenga uno o dos parámetros no opcionales con atributo intent(in) (que sean de entrada)

� Veamos un Ejemplo: calcular la distancia euclídea entre dos elementos del tipo derivado punto:


Definición de operadores: distancia_principal.f90

pr ogr am pr i nci pali mpl i c i t noneuse di st anci a_modt ype( punt os) : : px, py . . .di st anci a = px . di st . py . . .end pr ogr am pr i nci pal


modul e di st anci a_mod i mpl i c i t none . . . t ype punt os r eal : : x, y end t ype punt os . . . i nt er f ace oper at or ( . di st . ) modul e pr ocedur e cal cdi st end i nt er f ace . . .cont ai ns . . . f unct i on cal cdi st ( px, py) i mpl i c i t none r eal : : cal cdi st t ype ( punt os) , i nt ent ( i n) : : px, py cal cdi st = & sqr t ( ( px%x−py%x) * * 2 +( px%y−py%y) * * 2 ) end f unct i on cal cdi st . . .end modul e di st anci a_mod

Definición de operadores: distancia_mod.f90


Módulos mon_mod.f90

� Veamos otro ejemplo que define en un módulo un tipo derivado y todas las operaciones asociadas:

modul e di ner os i mpl i c i t none

t ype past a i nt eger : : eur os, cent s end t ype past a

i nt er f ace oper at or ( +) modul e pr ocedur e sumar _past a end i nt er f ace

i nt er f ace oper at or ( −) modul e pr ocedur e negar _past a,

r est a_past a end i nt er f ace



cont ai ns

f unct i on sumar _past a( a, b) i mpl i c i t none t ype ( past a) : : sumar _past a t ype ( past a) , i nt ent ( i n) : : a , b i nt eger : : acar r eo, t mp_cent s t mp_cent s = a%cent s + b%cent s acar r eo = 0 i f ( t mp_cent s > 100) t hen t mp_cent s = t mp_cent s − 100 acar r eo = 1 end i f sumar _past a%eur os=a%eur os + & b%eur os+acar r eo sumar _past a%cent s = t mp_cent s end f unct i on sumar _past a



f unct i on negar _past a( a) i mpl i c i t none t ype ( past a) : : negar _past a t ype ( past a) , i nt ent ( i n) : : a negar _past a%eur os = −a%eur os negar _past a%cent s = −a%cent s end f unct i on negar _past a



f unct i on r est a_past a( a, b) i mpl i c i t none t ype ( past a) : : r est a_past a t ype ( past a) , i nt ent ( i n) : : a, b i nt eger : : t mp_eur os, t mp_cent s, acar r eo t mp_cent s = a%cent s − b%cent s t mp_eur os = a%eur os − b%eur os

! Par a i ncor por ar acar r eos necesar i os i f ( ( t mp_cent s < 0) . and. ( t mp_eur os > 0) ) t hen t mp_cent s = 100 + t mp_cent s t mp_eur os = t mp_eur os − 1 el se i f ( ( t mp_cent s>0) . and. ( t mp_eur os<0) ) t hen t mp_cent s = t mp_cent s − 100 t mp_eur os = t mp_eur os + 1 end i f r est a_past a%cent s = t mp_cent s r est a_past a%eur os = t mp_eur os end f unct i on r est a_past a

end modul e di ner os


Sobrecarga del operador de asignación

� Al usar tipos derivados puede ser necesario extender el significado del operador de asignación (=)

r eal : : axt ype ( punt os) : : px. . .ax = px ! Se asi gna un punt o a un r eal. . . ! No es vál i do s i no se def i ne

� Siguiendo con el ejemplo, supongamos que queremos que ax tome el valor máximo de las componentes de px. Esta asignación se ha de hacer a través de una subrutina con 2 parámetros no opcionales, el primero de ellos intent(out) o intent(inout) y el segundo intent(in).

Debe crearse un bloque interface de asignación:

i nt er f ace assi gnment ( =) cuer po_de_l a_subr ut i na_i nt er f aceend i nt er f ace



� La definición de la asignación se podría colocar en un módulo como:

modul e mod_sobr ecar ga_assi gn i mpl i c i t none t ype punt os r eal : : x, y end t ype punt os . . . i nt er f ace assi gnment ( =) modul e pr ocedur e assi gn_punt os end i nt er f acecont ai ns subr out i ne assi gn_punt os ( ax, px) r eal , i nt ent ( out ) : : ax t ype ( punt os) , i nt ent ( i n) : : px ax = max( px%x, px%y) end subr out i ne assi gn_punt os . . .end modul e mod_sobr ecar ga_assi gn



� El programa principal necesita invocar a este módulo con una sentencia use:

use mod_sobr ecar ga_assi gnr eal : : axt ype ( punt os) : : px. . .ax = px ! Cor r ect o


Ámbito

� El ámbito de un identificador (de variable, función, subrutina) o etiqueta es el conjunto de entidades no−solapadas donde el identificador o etiqueta puede utilizarse sin ambigüedad

� Estas entidades (unidades de ámbito) son:� Una definición de tipo (derivado)

� Un cuerpo de interface de procedimiento, excluyendo las definiciones de tipos y cuerpos de interface definidos dentro de él

� Una unidad de programa o procedimiento interno, excluyendo las definiciones de tipos, cuerpos de interfaces y subprogramas contenidos en él


Ámbito

Etiquetas� Cada subprograma, interno o externo tiene su

propio conjunto de etiquetas. La misma etiqueta puede usarse en un programa principal y sus procedimientos internos sin ambigüedad. Por lo tanto el ámbito de una etiqueta es un programa principal o un procedimiento excluyendo cualquier procedimiento interno que pueda contener

Identificadores� El ámbito de un identificador declarado en una

unidad de programa se extiende desde desde su cabecera hasta su sentencia end

� El ámbito de un identificador declarado en un programa principal o subprograma externo se extiende a todos los subprogramas que contenga a menos que el mismo identificador se redefina en ellos

� El ámbito de un identificador declarado en un subprograma interno es sólo el propio subprograma y no otros subprogramas internos.


Ámbito

Identificadores

� El ámbito del identificador de un subprograma interno, y del número y tipo de sus parámetros se extiende a través de la unidad de programa en que está contenido y por lo tanto a todos los otros subprogramas internos

� El ámbito de un identificador declarado en un módulo se extiende a todas las unidades de programa que use(n) ese módulo, a menos que el identificador tenga atributo private o que sea renombrado en el programa que usa el módulo o que la sentencia use tenga una cláusula use only

� El ámbito de un identificador declarado en un módulo se extiende a todos los subprogramas internos excepto aquellos en los que el identificador sea redefinido


Ámbito

Consideremos las unidades de ámbito señaladas anteriormente

� Entidades declaradas en diferentes unidades de ámbito son siempre diferentes, aunque tengan los mismos identificadores y propiedades

� Dentro de una unidad de ámbito, cada entidad con nombre ha de tener un identificador diferente, con la excepción de los procedimientos genéricos

� Los identificadores de unidades de programa son globales, de modo que han de ser diferentes entre sí y diferentes de cualquier entidad local a las unidades de programa

� El ámbito de un identificador de un procedimiento interno se extiende sólo a toda la unidad de programa que lo contiene

� El ámbito de un identificador declarado en un procedimiento interno es ese procedimiento interno


Ámbito

� Se dice que los identificadores son accesibles por asociación de anfitrión o por asociación de uso:

� Asociación de anfitrión: el ámbito de un identificador declarado en una unidad de programa se extiende desde la cabecera de la unidad de programa hasta su sentencia end

� Asociación por uso: el ámbito de un identificador declarado en un módulo, cuando no tiene el atributo private, se extiende a cualquier unidad de programa que use el módulo


Ámbito

Ejemplomodul e ambi t o1 ! ambi t o 1. . . ! ambi t o 1cont ai ns ! ambi t o 1 subr out i ne ambi t o2 ! ambi t o 2 t ype ambi t o3 ! ambi t o 3 . . . ! ambi t o 3 end t ype ! ambi t o 3 i nt er f ace ! ambi t o 3100 . . . ! ambi t o 4 end i nt er f ace ! ambi t o 3 r eal x, y ! ambi t o 2 . . . ! ambi t o 2cont ai ns ! ambi t o 2 f unct i on ambi t o5( . . . ) ! ambi t o 5 r eal y ! ambi t o 5 y = x + 1. 0 ! ambi t o 5100 . . . ! ambi t o 5 end f unct i on ambi t o5 ! ambi t o 5 end subr out i ne ambi t o2 ! ambi t o 2end modul e ambi t o1 ! ambi t o 1


Estructura de los programas

Sentencias PROGRAM , FUNCTI ON, SUBROUTI NEo MODULE

Sentencias USESentencia I MPLI CI T NONE

SentenciasPARAMETER

SentenciasI MPLI CI T

SentenciasPARAMETER

yDATA

Definiciones de tiposderivados,Bloques interface,Sentencias de declaraciónde tipos, ySentencias deespecificación

SentenciasFORMAT

Sentencias ejecutablesSentencia CONTAI NS

Subprogramas internos oSubprogramas del módulo

Sentencia END

Orden de las sentencias



Cuando utilizar bloques interface

� Cuando un módulo o procedimiento externo es invocado:

� Si el módulo define o sobrecarga un operador o sobrecarga la asignación

� Si el módulo utiliza un identificador genérico

� Se utiliza un bloque interface cuando un procedimiento externo:

� Es invocado con un argumento con nombre y/o opcional

� es una función que devuelve un vector o un puntero o bien una función de caracteres que no es ni constante ni de longitud conocida

� Tiene un parámetro que es un vector de forma asumida o un puntero

� Es argumento de otro subprograma (en este caso no es obligatorio, pero se recomienda)



Resumen� Estilo Fortran77:

� Programa principal con procedimientos externos, posiblemente en una librería

� No hay interfaces explícitas de modo que el compilador no comprueba inconsistencias en los parámetros de las llamadas a subprograma

� Fortran90 simple:� Programa principal con procedimientos internos� Las interfaces son explícitas, de modo que el

compilador detecta posibles inconsistencias

� Fortran90 con módulos:� Programa principal y módulo(s) conteniendo

interfaces y posiblemente especificaciones y la posibilidad de procedimientos externos (y de librerías precompiladas)

� Una versión F90 del estilo F77 con interfaces para permitir al compilador la comprobación de inconsistencias en los parámetros

� Programa principal y módulo(s) conteniendo especificaciones, interfaces y procedimientos



Resumen� Fortran90 con módulos:

� Un programa F90 estructurado consiste en un programa principal y módulos que contienen especificaciones, interfaces y procedimientos. Los procedimientos externos dejan de ser necesarios

� La introducción de nuevas características en el lenguaje tales como tipos derivados, sobrecarga, subprogramas internos y módulos hacen posible el desarrollo de código F90 sofisticado


4Proceso de

vectores



1.− Introducción




Proceso de vectores

Índice� 4.1 Terminología� 4.2 Especificaciones� 4.3 Operaciones sobre vectores� 4.4 Sentencia y constructor where� 4.5 Procedimientos intrínsecos simples� 4.6 Secciones de vectores� 4.7 Posición del elemento versus indexación� 4.8 Vectores de tamaño cero� 4.9 Constructores de vectores� 4.10 Vectores dinámicos� 4.11 Vectores automáticos� 4.12 Vectores con forma asumida� 4.13 Funciones intrínsecas para operar con

vectores� 4.14 Ejemplo� 4.15 Ejercicios


Terminología

� Hablaremos en general de vectores (arrays) para referirnos a vectores multidimensionales (matrices)

� Fortran90 permite vectores de hasta 7 dimensiones

r eal , di mensi on( 50) : : wr eal , di mensi on( 5: 54) : : xr eal y( 50)r eal z( 11: 60)! w, x, y, z vect or es de 50 el ement os

� Rango de un vector: número de dimensiones� Extensión: número de elementos en una

dimensión� Forma: vector de extensiones. El vector contiene

la extensión de cada dimensión� Tamaño: Número de elementos. Es el producto

de extensiones� 2 vectores son compatibles si tienen la misma

forma. Cualquier vector es compatible con un escalar


Terminología

Ejemplo

r eal , di mensi on : : a( −3: 4, 7)r eal , di mensi on : : b( 8, 2: 8)r eal , di mensi on : : d( 8, 1: 8)i nt eger : : c

� El vector a tiene:Rango: 2Ext ensi ones: 8 y 7For ma: ( / 8, 7/ )Tamaño: 56

� El vector a es compatible con b y c, pero no con d (d tiene forma (/8, 9/)


Especificaciones

t i po [ [ , di mensi on ( l i s t a_de_ext ensi ones) ] [ , at r i but o] . . . : : ] i dent i f i cador es

� tipo: tipo básico o derivado� dimension es opcional, pero necesario para definir

dimensiones por defecto� La lista de extensiones da las dimensiones del

vector. Puede ser:�

Una constante entera�

Una expresión entera usando parámetros formales�

:� para mostrar que el vector es dinámico o de forma

asumida� Los atributos pueden ser los que ya hemos

estudiado: (parameter, public, private, pointer, target, allocatable, dimension(extent−list), intent(inout), optional, save, external, intrinsic)

� identificadores: Una lista de identificadores de vector que opcionalmente pueden tener dimensiones y valores iniciales


Especificaciones

� Inicialización de vectores de 1 dimensión conteniendo 3 elementos:

i nt eger , di mensi on( 3) : : &i a=( / 1, 2, 3/ ) , i b=( / ( i , i =1, 3) / )

� Declaración de un vector automático l b. la es un vector de argumentos dummy y size una función intrínseca que da el tamaño del vector lal ogi cal , di mensi on( si ze( l a) ) : : l b

� Declaración de 2 vectores bidimensionales dinámicos a y b. La forma (nº de elementos en cada dimensión) se definiría con una sentencia allocate posterior:

r eal , di mensi on ( : , : ) , al l ocat abl e : : a, b� Declaración de 2 vectores tridimentionales de

forma asumida. La forma se tomaría de los parámetros actuales de la rutina llamadora:

r eal , di mensi on( : , : , : ) : : a, b


Operaciones sobre vectores

� En Fortran90 es posible realizar operaciones sobre todos los elementos de un vector sin necesidad de usar bucles

� Para ello, los vectores implicados deben ser compatibles

� Las operaciones entre dos vectores compatibles se realizan elemento a elemento y todos los operadores intrínsecos están definidos para vectores compatibles. P. ej.:

3 4 8 5 2 1 15 8 85 6 6 * 3 3 1 = 15 18 6

� Si uno de los operandos es un escalar, éste se

expande � para ser compatible con el otro

operando. Esta expansión de escalares es útil a la hora de inicializar o escalar vectores



� Un concepto fundamental con respecto a las asignaciones en operaciones sobre vectores es que la evaluación de la expresión del lado derecho de la asignación se realiza antes de que ocurra cualquier asignación.

Esto es importante cuando aparecen vectores en ambos lados de la asignación: si no fuera así los elementos de los vectores de la parte derecha se podrían ver afectados antes de que la operación se completara.



� Consideremos tres vectores del mismo tamaño. Asignemos 0 a todos los elementos y luego hagamos a(i) = a(i)/3.1 + b(i)*sqrt(c(i)) para

todo i� Solución en Fortran 77:

r eal a( 20) , b( 20) , c( 20) . . . do 10 i =1, 20 a( i ) =010 cont i nue . . . do 20 i =1, 20 a( i ) =a( i ) / 3. 1 + b( i ) * sqr t ( c( i ) )20 20 cont i nue

� Solución en Fortran 90:r eal , di mensi on( 20) : : a, b, c. . .a = 0. . .a = a / 3. 1 + b * sqr t ( c) ! sqr t Par a cada ! el ement o



� Consideremos tres matrices bidimensionales de la misma forma. Multiplicar dos de las matrices elemento a elemento asignando el resultado a la tercera matriz

� Fortran 77 r eal a( 5, 5) , b( 5, 5) , c( 5, 5) . . . do 20 i = 1, 5 do 10 j = 1, 5 c( j , i ) = a( j , i ) * b( j , i )10 cont i nue 20 cont i nue

� Fortran 90 r eal , di mensi on ( 5, 5) : : a, b, c . . . c = a * b



� Consideremos una matriz tridimensional. Hallar el máximo valor menor que 1000 en la matriz. En Fortran90 el código es:

r eal , di mensi on( 10, 10, 10) : : aamax = maxval ( a, mask = ( a <1000) )

mask es una función que devuelve un vector lógico: sólo los elementos de a que se corresponden con elementos de mask participan en la llamada a maxval

� Hallar el valor medio de los valores mayores que 3000 en un vector

av = sum( a, mask=( a > 3000) ) / & count ( mask=( a > 3000) )

� Funciones intrínsecas sobre vectores:�

maxval − retorna el valor máximo de los elementos de un vector

�sum − la suma de los elementos del vector

�count − El número de elementos TRUE


Procedimientos intrínsecos elementales

� Fortran90 permite procedimientos intrínsecos sobre vectores. El procedimiento se aplica a cada elemento del vector (matriz). De nuevo, los operandos deben ser compatibles. Veamos ejemplos:

� 1.− Hallar la raiz cuadrada de todos los elementos de una matriz:

b = sqr t ( a)

� 2.− Hallar la longitud de una cadena dada por un vector de caracteres ch, ignorando los espacios en blanco:

l engt h = l en_t r i m( ch)


Sentencia where

� Se usa para realizar asignaciones sólo si se cumple una condición lógica, y es útil para para realizar operaciones sobre ciertos elementos de un vector.

Un ejemplo simple es evitar una división por cero:

r eal , di mensi on( 5, 5) : r a, r b. . .wher e( r b > 0. 0) r a = r a / r b

� Forma general:

wher e( l ogi cal −ar r ay−expr essi on) &ar r ay−var i abl e = ar r ay−expr essi on

� Se evalúa la expresión lógica y todos los elementos de la

�array−expression

� que tienen un valor true se

evalúan y asignan. Los elementos que resultan false no se cambian. La expresión lógica ha de tener la misma forma que el vector


Sentencia where

� También es posible controlar asignaciones sobre un vector a través de un vector lógico. En este caso la forma del constructo where es:wher e ( l ogi cal −ar r ay−expr essi on) ar r ay−assi gnment −st at ement send wher e

o bienwher e ( l ogi cal −ar r ay−expr essi on) ar r ay−assi gnment −st at ement sel sewher e ar r ay−assi gnment −st at ement send wher e

� Ejemplo:r eal , di mensi on( 5, 5) : : r a, r b. . .wher e( r b > 0. 0) r a = r a / r bel sewher e r a = 0. 0end wher e


Secciones de vectores

� Una parte de un vector (lo que se llama una sección) puede referenciarse especificando un rango de subíndices mediante:

� Un subíndice simple:

)2,2(

00000

00000

00000

0000

00000

ra

X

=

1 Una tripleta de subíndices:[ l i m_i nf ] : [ l i m_sup] [ : st r i de]

Por defecto se toman los límites declarados y stride=1

Los siguientes ejemplos muestran secciones de vectores utilizando tripletas de subíndices:



)2:2,2:2(

00000

00000

00000

0000

00000

ra

X

=

)5:3,3(

00000

00000

00

00000

00000

raXXX =

)3(:,

0000

0000

0000

0000

0000

ra

X

X

X

X

X

=

)4:2,2::1(

00

00000

00

00000

00

ra

XXX

XXX

XXX

=

Un elemento. Forma: (/1/)

Una Subcolumna. Forma: (/3/)

Una columna. Forma: (/5/)

Stride 2 en filas. Forma: (/3, 3/)



� Un vector de subíndices. Es una expresión entera de rango 1 (vector de enteros). Cada elemento de la expresión ha de definirse con valores en el rango de los límites del vector

�padre

�. Los elementos del

vector de subíndices pueden estar en cualquier orden

Un ejemplo de expresión entera de rango 1 es:( / 3, 2, 12, 2, 1/ )

Veamos ejemplos de uso:

r eal , di mensi on : : r a( 6) , r b( 3)i nt eger , di mensi on ( 3) : : i vi v = ( / 1, 3, 5 / ) ! expr . ent er a de r ango 1r a = ( / 1. 2, 3. 4, 3. 0, 11. 2, 1. 0, 3. 7 / )r b = r a( i v) ! i v es el vect or de subí ndi ces! = ( / r a( 1) , r a( 3) , r a( 5) / ) ! = ( / 1. 2, 3. 0, 1. 0 / )

r a( i v) = ( / 1. 2, 3. 4, 5. 6/ )! = r a( ( / 1, 3, 5/ ) ) = ( / 1. 2, 3. 4, 5. 6/ )! = r a( 1: 5: 2) = ( / 1. 2, 3. 4, 5. 6/ )



� Se permite utilizar varias veces el mismo vector de subíndices. No se pueden repetir elementos en la parte izquierda (muchos a uno), pero sí en la parte derecha (uno a muchos):

r eal , di mensi on : : r a( 6) , r b( 3)i nt eger , di mensi on ( 3) : : i v

i v = ( / 1, 3, 1/ )r a( i v) = ( / 1. 2, 3. 4, 5. 6/ ) !

Pr ohi bi do! = r a( / 1, 3, 1/ ) = ( / 1. 2, 3. 4,

5. 6/ )

r b = r a( i v) ! Per mi t i do

! = r a( / 1, 3, 1/ ) = ( / 1. 2, 3. 4, 1. 2/ )


Asignaciones con vectores

� Tanto vectores completos como secciones de vectores se pueden usar como operandos en asignaciones con vectores, siempre que sean compatibles. Por ejemplo:

r eal , di mensi on( 5, 5) : : r a, r b, r ci nt eger : : i . . .! For ma ( / 5, 5/ ) y escal arr a = r b + r c * i

! For ma ( / 3, 2/ )r a( 3: 5, 3: 4) = r b( 1: : 2, 3: 5: 2) + r c( 1: 3,

: 2)

! For ma ( / 5/ )r a( : , 1) = r b( : , 1) + r b( : , 2) + r c( : , 3)


Recursividad

� Es importante saber cómo obtener recursividad en Fortran90. Por ejemplo el código:do i = 2, n x( i ) = x( i ) + x( i −1)end do

No produce el mismo resultado que:x( 2: n) = x( 2: n) + x( 1: n−1)

En el primer caso, la asignación es:x(i) = x(i) + x(i−1) + x(i−2) + ... + x(1)

Mientras que en el segundo:x(i) = x(i) + x(i−1) !Comprobarlo!

En Fortran90 se puede obtener el efecto recursivo del bucle do utilizando la función intrínseca sum, que devuelve la suma de todos los elementos del vector parámetro:x( 2: n) = ( / ( sum( x( 1: i ) ) , i = 2, n) / )


Posición del elemento versus indexación

� Las funciones intrínsecas maxloc y minloc devuelven la posición de los valores máximo y mínimo del vector pasado como parámetro. Si el límite inferior no es 1 hay que tener en cuenta que estas funciones devuelven la posición y no el subíndice:

r eal , di mensi on ( 1: 8) : : r ar eal , di mensi on ( −3: 4) : : r bi nt eger , di mensi on ( 1) : : l ocmax1, l ocmax2r eal : : max1, max2r a=( / 1. 2, 3. 4, 5. 4, 11. 2, 1. 0, 3. 7,

1. 0, 1. 0/ )r b = r a! Par a hal l ar el val or máxi mo:l ocmax1 = maxl oc( r a) ! = ( / 4 / )l ocmax2 = maxl oc( r b) ! = ( / 4 / )

� max1 = r a( l ocmax( 1) )! OK por que el l í mi t e i nf er i or de r a es 1max2 = r b( l bound( r b) + l ocmax2( 1) − 1)! Se necesi t a est o s i el l í mi t e i nf er i or! no es 1


Vectores de tamaño cero

� Si el límite inferior de un vector es mayor que el superior, el vector tiene tamaño cero. Estos vectores siguen las reglas normales

� Son útiles para operaciones de contorno (no se necesita código especial para tratar los límites de un modo especial):

do 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 ) ! Tamaño cer o cuando i =nend do


Constructores de vectores

� Un constructor de vectores crea un vector de rango 1 conteniendo valores especificados. Los valores se pueden dar listándolos o bien usando un bucle implícito o una combinación de ambos

� Forma general:( / ar r ay−const r uct or −val ue−l i st / )

� Ejemplo:r eal , di mensi on( 6) : : aa=( / ar r ay−const r uct or −val ue−l i st / )

� Donde �array−constructer−value−list

� puede ser:

( / ( i , i = 1, 6) / ) ! = ( / 1, 2, 3, 4, 5, 6/ )( / 7, ( i , i =1, 4) , 9/ ) ! = ( / 7, 1, 2, 3, 4, 9/ )( / 1. 0/ r eal ( i ) , i = 1, 6) / )! =( / 1. 0/ 1. 0, 1. 0/ 2. 0, 1. 0/ 3. 0, 1. 0/ 4. 0, 1. 0/ 5. 0,

1. 0/ 6. 0/ )( / ( ( i +j , i =1, 3) , j =1, 2) / )! = ( / ( ( 1+j , 2+j , 3+j ) , j =1, 2) / )! = ( / 2, 3, 4, 3, 4, 5/ )( / a( i , 2: 4) , a( 1: 5: 2, i +3) / )! =( / a( i , 2) , a( i , 3) , a( i , 4) , a( 1, i +3) , a( 3, i +3) ,a( 5, i +3) / )



� Es posible transferir los valores de un vector de rango 1 a un vector de diferente forma utilizando la función reshape, que tiene la forma:r eshape( f uent e, shape, [ , pad] [ , or der ] )

� Donde el parámetro fuente puede ser un array de cualquier clase, y sus elementos se distribuyen para formar un nuevo vector (reshape) con forma shape, (que es devuelto por la función)

� Si fuente tiene más elementos que el vector al que se asigna, entonces los elementos no deseados se ignoran

� Si reshape tiene más elementos que fuente, entonces pad ha de estar presente. pad es un vector del mismo tipo que fuente que se usa (quizás repetidamente) para rellenar

� order permite que los elementos de reshape se coloquen en órdenes diferentes al del vector. Ha de tener el mismo tamaño y forma que shape y contiene las dimensiones de reshape en el orden en que deben recorrerse



Ejemplor eal , di mensi on( 3, 2) : : r ar a=r eshape( ( / ( ( i + j , i = 1, 3) , j = 1, 2) / ) , &shape=( / 3, 2/ ) )! Cr ea el vect or :

=

54

43

32

ra

r a=r eshape( ( / ( ( i +j , i =1, 3) , j =1, 2) / ) , shape= & ( / 3, 2/ ) , or der ( 2, 1) )! El r esul t ado ser í a:

=

54

34

32

ra


Vectores dinámicos

� En Fortran77 todo el manejo de memoria era estático

� Fortran90

� Permite obtener y liberar memoria dinámica a través de los vectores dinámicos

� Permite a los vectores locales a un procedimiento tener tamaños y formas diferentes en cada llamada a través de los vectores automáticos

� Reduce los recursos globales necesarios para almacenamiento en memoria

� Simplifica los parámetros de las subrutinas


Vectores dinámicos

� Un vector dinámico se declara en una sentencia de declaración de tipo con el atributo allocatable

� El rango del vector debe especificarse en la declaración incluyendo el número adecuado de

�:

�

en el atributo dimension� Un vector bidimensional se podría declarar:

r eal , di mensi on( : , : ) , al l ocat abl e : : a

� La declaración no reserva memoria para el vectoral l ocat e ( a( 0: n, m) )al l ocat e ( a( 0: n+1, m) )deal l ocat e ( a)

� La forma general de estas sentencias:al l ocat e( al l ocat e−obj ect −l i st &

[ , STAT=checkst at ] )deal l ocat e( al l ocat e−obj ect −l i st &[ , STAT=checkst at ] )

� Si STAT está presente, toma el valor 0 si la operación se realizó correctamente o un valor positivo si hubo un error


Vectores dinámicos

Ejemploi nt eger nr eal , di mensi on( : , : ) , al l ocat abl e : : r ai nt eger : : checkst at . . .r ead( * , * ) nsi ze1, nsi ze2ALLLOCATE( r a( nsi ze1, nsi ze2) ,

STAT=checkst at )i f ( checkst at > 0) t hen! . . . Hubo un er r or . . .end i f . . .deal l ocat e ( r a)

Se pueden alojar/desalojar varios vectores en la misma sentencia

i f ( al l ocat ed( a) ) deal l ocat e( a)ori f ( . not . al l ocat ed( a) ) al l ocat e( a( 5,

20) )


Vectores dinámicos

� Si un vector dinámico se declara con el atributo save:

r eal , di mensi on( : ) , al l ocat abl e, save : : a

� el vector estará disponible incluso a la salida del procedimiento en que fue alojado

� Los vectores dinámicos: han de ser creados y liberados dentro de la

misma unidad de programa El resultado de una función no puede ser un

vector dinámico No se puede usar vectores dinámicos en una

definición de tipo derivado


Vectores Automáticos

� Llamaremos vector automático a un vector que tiene forma explícita dentro de un procedimiento y cuyos límites se dan cuando el procedimiento es invocado

� a través de los parámetros formales � a través de variables definidas por asociación por

uso o asociación por hospedaje� Asociación por uso es cuando las variables

declaradas en el cuerpo de un módulo se hacen disponibles a un programa a través de una sentencia use. Asociación por hospedaje es cuando las variables declaradas en una unidad de programa se hacen disponibles a sus procedimientos internos

� Los vectores automáticos se crean al entrar al procedimiento y se liberan al salir del mismo

� No existe un mecanismo para comprobar si hay suficiente memoria para un vector automático

� Es frecuente usar la función intrínseca size al declarar vectores automáticos:si ze( ARRAY [ , DI M] )



Ejemplossubr out i ne sub( n, a) i mpl i c i t none i nt eger : : n r eal , di mensi on( n, n) , i nt ent ( i nout ) : :

a r eal , di mensi on( n, n) : : wor k1 r eal , di mensi on( si ze( a, 1) ) : : wor k2 . . .end subr out i ne sub

Los vectores work1 y work2 toman su tamaño de los parámetros formales n y a

� El siguiente ejemplo muestra los límites de un vector automático dependiendo de una variable global definida en un módulo.



modul e aut o_mod i mpl i c i t none i nt eger : : n=1 ! Por def ect o n=1cont ai ns subr out i ne sub i mpl i c i t none r eal , di mensi on( n) : : w

wr i t e ( * , * ) �Límites−tamaño de w:

�&

, l bound( w) , ubound( w) , s i ze( w) end subr out i ne subend modul e aut o_mod

pr ogr am aut o_ar r aysuse aut o_mod i mpl i c i t none

n = 10 cal l subend pr ogr am aut o_ar r ays



� Supongamos que el programa principal declara un vector de tamaño NxN pero a una subrutina ha de pasar como parámetro una sección de tamaño N1xN1 (N1 < N). Para conseguir esto en Fortran77 hemos de pasar como parámetros tanto N como N1, mientras que en Fortran90 se puede simplificar el código:



pr ogr am ar r ay ! For t r an77 i nt eger n, n1 par amet er ( n=10) r eal a( n, n) , wor k( n, n) r eal r es . . . r ead( * , * ) n1 i f ( n1 . LE. n) t hen cal l sub( a, n, n1, r es, wor k) el se c . . . Hubo un er r or . . . end i f . . . end pr ogr am ar r ay

subr out i ne sub( a, n, n1, r es, wor k) i nt eger n, n1 r eal a( n, n) r eal wor k( n1, n1) r eal r es . . . r es=a( . . . ) . . .end subr out i ne sub



PPROGRAM ar r ay ! For t r an90 i mpl i c i t none r eal , al l ocat abl e, di mensi on( : , : ) : : a r eal : : r es i nt eger : : n1, al l oc_st at . . . r ead( * , * ) n1 al l ocat e( a( n1, n1) , STAT=al l oc_st at ) i f ( al l oc_st at / = 0) t hen ! . . . Hubo un er r or . . . end i f cal l sub( a, n1, r es) deal l ocat e( a, STAT=al l oc_st at ) i f ( al l oc_st at / = 0) t hen ! . . . Hubo un er r or . . . end i f . . .cont ai ns



cont ai ns

subr out i ne sub( a, n1, r es) i mpl i c i t none i nt eger , i nt ent ( i n) : : n1 r eal , i nt ent ( i nout ) : : r es r eal , di mensi on( n1, n1) , i nt ent ( i n) : : a r eal , di mensi on( n1, n1) : : wor k . . . r es=a( . . . ) . . . end subr out i ne subend pr ogr am ar r ay


Vectores con forma asumida

� Un vector de forma asumida es un vector cuya forma no es conocida sino que toma cualquier forma dependiendo de un parámetro actual

� Cuando se declara un vector de forma asumida cada dimensión se especifica como:[ l ower _bound] :

� donde el límite inferior se toma como 1 si se omite

� Los vectores de forma asumida hacen posible el paso de vectores entre unidades de programa sin necesidad de pasar las dimensiones como parámetros. Si un procedimiento externo tiene un vector de forma asumida como parámetro formal ha de darse un bloque de interface en la unidad de programadora que invoque al procedimiento

� Consideremos el siguiente subprograma externo con vectores de forma asumida ra, rb y rc


Vectores con forma asumida

subr out i ne sub( r a, r b, r c) i mpl i c i t none r eal , di mensi on( : , : ) , i nt ent ( i n) : : r a ! For ma ( 10, 10) r eal , di mensi on( : , : ) , i nt ent ( i n) : : r b ! For ma ( 5, 5) ! = r eal , di mensi on( 1: 5, 1: 5) : : r b r eal , di mensi on( 0: , 2: ) , i nt ent ( out ) : : r c ! For ma ( 5, 5) ! = r eal , di mensi on ( 0: 4, 2: 6) : : r c . . .end subr out i ne sub! El pr og. Ppal . Deber í a t ener una i nt er f ace:

r eal , di mensi on ( 0: 9, 10) : : r a ! Shape ( 10, 10)

i nt er f ace subr out i ne sub( r a, r b, r c) r eal , di mensi on( : , : ) , i nt ent ( i n) : : r a, r b r eal , di mensi on( 0: , 2: ) , i nt ent ( out ) : : r c end subr out i ne subend i nt er f ace . . .cal l sub ( r a, r a( 0: 4, 2: 6) , r a( 0: 4, 2: 6) )


Ejemplo

pr ogr am ar r ay i mpl i c i t none r eal , al l ocat abl e, di mensi on( : , : ) : : a r eal : : r es i nt eger : : n1

i nt er f ace subr out i ne sub( a, r es) r eal , di mensi on( : , : ) , i nt ent ( i n) : : a r eal , di mensi on( si ze( a, 1) , s i ze( a, 2) ) : : wor k end subr out i ne sub end i nt er f ace . . . r ead ( * , * ) n1 al l ocat e ( a( n1, n1) ) ! Vect or di námi co cal l sub( a, r es) . . .cont ai ns

subr out i ne sub( a, r es) i mpl i c i t none r eal , i nt ent ( out ) : : r es r eal , di mensi on( : , : ) , i nt ent ( i n) : : a

! Vect or de f or ma asumi da r eal , di mensi on ( si ze( a, 1) , s i ze( a, 2) ) : : wor k

! Vect or aut omát i co . . . r es = a( . . . ) . . . end subr out i ne sub end pr ogr am ar r ay


Funciones intrínsecas para vectores

� ReduccionesALL( MASK[ , DI M] )Tr ue si t odos l os el ement os son t r ue

ANY( MASK[ , DI M] )Tr ue si al gún el ement o es Tr ue

COUNT( MASK[ , DI M] )Númer o de el ement os t r ue

maxval ( ARRAY[ , DI M] [ , MASK] )Máxi mo del vect or

MI NVAL( ARRAY[ , DI M] [ , MASK] )Mí ni mo del vect or

PRODUCT( ARRAY[ , DI M] [ , MASK] )Pr oduct o de t odos l os el ement os

SUM( ARRAY[ , DI M] [ , MASK] )Suma de t odos l os el ement os



� Consultaal l ocat ed( ARRAY)Tr ue si el vect or ha si do cr eado

l bound( ARRAY[ , DI M] )Lí mi t es i nf er i or es del vect or

shape( f uent e)For ma del vect or ( o escal ar )

s i ze( ARRAY[ , DI M] )Tamaño del vect or

ubound( ARRAY[ , DI M] )Lí mi t e super i or del vect or



� Construcción

MERGE( TSOURCE, FSOURCE, MASK)Mezcl a dos vect or es en t ér mi nos de l a

máscar a

pack( ARRAY, MASK[ , VECTOR] )Empaquet a el ement os en el vect or en

t ér mi nos de l a máscar a

SPREAD( f uent e, DI M, ncopi as)Const r uye un vect or dupl i cando una

secci ón de ot r o

UNPACK( VECTOR, MASK, FI ELD)Desempaquet a el ement os de un vect or

en t ér mi nos de l a máscar a



� Reshaper eshape( f uent e, shape[ , pad] [ ,

or der ] )Cambi a l a f or ma de un vect or

� Posición en el vectorMAXLOC( ARRAY[ , MASK] )Posi c i ón del máxi mo

MI NLOC( ARRAY[ , MASK] )Posi c i ón del mí ni mo

� Manipulación de vectoresCSHI FT( ARRAY, SHI FT[ , DI M] )Real i za una r ot aci ón ci r cul ar

EOSHI FT( ARRAY, SHI FT[ , BOUNDARY] [ , DI M] )

Rot aci ón “ � nd−of f ”

TRANSPOSE( MATRI X)Tr aspone una mat r i z



� Aritmética vectorial y matricialDOT_PRODUCT( VECTOR_A, VECTOR_B)Pr oduct o escal ar

MATMUL( MATRI X_A, MATRI X_B)Pr oduct o de mat r i ces

Ejemplos� Los siguientes ejemplos ilustran el uso de

algunas de estas funciones intrínsecas. Tres estudiantes realizan 4 exámenes. Las calificaciones (sobre 100 puntos) se almacenan en un vector de enteros:

=

55214566

80504571

60907685

)4:1,3:1(score


Funciones vectoriales intrínsecas: Ejemplos

� Máxima nota:maxval ( scor e) ! = 90

� Máxima nota para cada estudiante:maxval ( scor e, DI M = 2)! = ( / 90, 80, 66/ )

� Alumno con la nota máxima:maxl oc ( maxval ( SCORE, DI M = 2) )! = maxl oc ( ( / 90, 80, 66 / ) ) = ( / 1 / )

� Nota media:aver age = sum( scor e) / s i ze( scor e) ! =62! aver age es una var i abl e ent er a

=

55214566

80504571

60907685

)4:1,3:1(score



n_gt _aver age = count ( above) ! = 6! n_gt _aver age es un ent er o

� Empaquetar todas las notas por encima de la media:. . .i nt eger , al l ocat abl e, di mensi on ( : ) : : & scor e_gt _aver age . . .al l ocat e ( scor e_gt _aver age( n_gt _aver age)scor es_gt _aver age = pack ( scor e, above)! = ( / 85, 71, 66, 76, 90, 80 / )

=

55214566

80504571

60907685

)4:1,3:1(score

�Número de calificaciones por encima de la media:above = scor e > aver age! above( 3, 4) es un vect or l ógi co

=

FFFT

TFFT

FTTT

above!



� ¿Algún alumno puntuó siempre por encima de la media?:ANY ( ALL ( above, DI M = 2) ) ! = . FALSE.

� ¿Todos los alumnos puntuaron por encima de la media en cualquiera de los exámenes?ANY ( ALL ( above, DI M = 1) )

! = . TRUE.

=

55214566

80504571

60907685

)4:1,3:1(score


Ejemplo: Conjugado del gradiente

pr ogr am conj ugat e_gr adi ent s

i mpl i c i t none i nt eger : : i t er s, i t s , n l ogi cal : : conver ged r eal : : er r or , up, al pha, bet a r eal , al l ocat abl e : : &a( : , : ) , b( : ) , x( : ) , r ( : ) , & u( : ) , p( : ) , xnew( : ) r ead ( * , * ) n, er r or , i t s al l ocat e &( a( n, n) , b( n) , x( n) , r ( n) , u( n) , p( n) , xnew( n) ) open ( 10, f i l e=’ dat a’ ) r ead ( 10, * ) a r ead ( 10, * ) b x = 1. 0 r = b − MATMUL( a, x) p = r i t er s = 0


Ejemplo: Conjugado del gradiente

do i t er s = i t er s + 1 u = MATMUL( a, p) up = DOT_PRODUCT( r , r ) al pha = up / DOT_PRODUCT( p, u) xnew = x + p * al pha r = r − u * al pha bet a = DOT_PRODUCT( r , r ) / up p = r + p * bet a conver ged = ( maxval ( ABS( xnew−x) ) / & maxval ( ABS( x) ) < er r or ) x = xnew i f ( conver ged . OR. i t er s == i t s) exi t end do wr i t e ( * , * ) i t er s wr i t e ( * , * ) xend pr ogr am conj ugat e_gr adi ent s


5Punteros



1.− Introducción

2.− Código fuente, tipos y estructuras de control3.− Procedimientos y Módulos4.− Proceso de vectores5.− Punteros6.− Nuevas características de entrada/salida7.− Procedimientos intrínsecos8.− Características redundantes9.− Desarrollos futuros


Punteros

Índice� 5.1 − Significado de un puntero� 5.2 − Especificaciones� 5.3 − Asignaciones de punteros� 5.4 − Estado de una asociación de punteros� 5.5 − Memoria dinámica� 5.6 − Argumentos puntero� 5.7 − Funciones que devuelven punteros� 5.8 − Vectores de punteros� 5.9 − Listas enlazadas� 5.10 − Ejercicios


Significado de un puntero

� Una variable de tipo puntero (o simplemente un puntero) tiene el atributo pointer y puede apuntar a otra variable de un tipo adecuado, que tendrá el atributo target o bien a un área de memoria alojada dinámicamente

� Los punteros en F90 son diferentes a los de C o Pascal: no contienen un dato en sí mismos y no deberían interpretarse como una dirección. Más bien deberían verse como variables que se asocian dinámicamente (en tiempo de ejecución) con otros datos que sí tienen asignado un espacio de memoria física (

target � )

� Los beneficios más interesantes de la introducción de punteros son:

� Una alternativa más flexible a los arrays dinámicos� Una herramienta para crear y manipular listas

enlazadas y otras estructuras de datos dinámicas


Especificaciones

� La forma general de declarar una variable puntero y un destino (target) son:

t ype [ [ , at t r i but e] . . . ] poi nt er : : l i s t of poi nt er var i abl es

t ype [ [ , at t r i but e] . . . ] t ar get : : l i s t of t ar get var i abl es

Donde

� El tipo especifica el tipo de variables que pueden ser apuntadas por el puntero (incluyendo tipos derivados)

� La lista de atributos da el resto de atributos del tipo de datos (si tiene alguno/s)

� Una variable puntero ha de tener el mismo tipo, parámetros y rango que su variable destino


Especificaciones

� La declaración de un puntero a vectores especifica el tipo y rango de los vectores a los que puede apuntar (sólo el rango, no los límites del vector)

� El atributo dimensión de un puntero a vectores no puede especificar una forma explícita o una forma asumida sino que debe tomar la forma de un vector de forma diferida de modo similar a como se hace con los vectores dinámicos. Así por ejemplo la declaración:

r eal , di mensi on( : ) , poi nt er : : p

� Declara un puntero p, que puede apuntar a vectores de reales de rango 1. La declaración:

r eal , di mensi on( 20) , poi nt er : : p

Es errónea y no es admitida por el compilador F90


Asignaciones de punteros

� Un puntero puede convertirse en un alias de una variable destino (target) a través de una sentencia de asignación de punteros, que es ejecutable y tiene la forma:poi nt er => t ar get

� Donde pointer es una variable con atributo pointer y target es una variable con atributo target o bien atributo pointer

� Una vez que un puntero se convierte en alias de un destino, se puede utilizar en cualquier punto en lugar de la variable destino



� Ejemplos:

r eal , poi nt er : : p1, p2r eal , t ar get : : t 1 = 3. 4, t 2 = 4. 5p1 => t 1 ! p1 apunt a a t 1pr i nt * , t 1, p1 ! ambos val en 3. 4p2 => t 2 ! p2 apunt a a t 2 pr i nt * , t 2, p2 ! ambos val en 4. 5

t 1

p1 3. 4

t 2

p2 4. 5



t 1

p1 3. 4

t 2

p2 4. 5

p2 => p1 ! p2 apunt a al dest i no de p1pr i nt * , t 1, p1, p2 ! Todos val en 3. 4

t 1

p23. 4

t 2

4. 5p1

t 1 = 5. 2pr i nt * , t 1, p1, p2 ! Todos val en 5. 2

�Téngase en cuenta que la asignación:p2 => p1 + 4. 3 ! Er r or

No está permitida porque no se puede asociar un puntero con una expresión aritmética


t 1

p1 3. 4

t 2

p2 3. 4

� Comparemos lo anterior con el siguiente código, en el que sólo la última línea es diferente:

r eal , poi nt er : : p1, p2r eal , t ar get : : t 1 = 3. 4, t 2 = 4. 5p1 => t 1 ! p1 apunt a a t 1p2 => t 2 ! p2 apunt a a t 2 p2 = p1 ! Asi gnaci ón nor mal ,! equi val ent e a t 2 = t 1

Asignación de punteros / asignaciones normales

t 1

p1 3. 4

t 2

p2 4. 5

�Después de que la última asignación se ejecuta, la situación es:

�La sentencia tiene el mismo efecto que t 2=t 1 puesto que p1 es un alias de t 1 y p2 lo es de t 2


Punteros a vectores

� El destino de un puntero puede ser también un vector. Veamos ejemplos de su uso:

r eal , di mensi on ( : ) , poi nt er : : pv1r eal , di mensi on ( : , : ) , poi nt er : : pv2r eal , di mensi on ( −3: 5) , t ar get : : t v1r eal , di mensi on ( 5, 10) , t ar get : : t v2i nt eger , di mensi on( 3) : : v = ( / 4, 1, −3/ )pv1 => t v1 ! pv1 es un al i as de t v1pv1 => t v1( : ) ! pv1 apunt a a t v1 con! Subí ndi ces de secci ónpv1 => t v2( 4, : ) ! pv1 apunt a a l a 4ª

f i l a! de t v2pv2 => t v2( 2: 4, 4: 8) ! pv2 apunt a a una! secci ón de t v2pv1 => t v1( 1: 5: 2) ! pv1 apunt a a una! Secci ón de t v1 pv1 => t v1( v) ! Er r or


Punteros a vectores

r eal , di mensi on ( : ) , poi nt er : : pv1r eal , di mensi on ( −3: 5) , t ar get : : t v1pv1 => t v1 ! pv1 es un al i as de t v1

pv1 => t v1( : ) ! pv1 apunt a a t v1 con! Subí ndi ces de secci ón

t v1( −3: 5)

pv1( −3: 5)

t v1( −3: 5)

pv1( 1: 9)

pv1 => t v1( 1: 5: 2) ! pv1 apunt a a una! Secci ón de t v1

t v1( 1: 5: 2)

pv1( 1: 3)


Punteros a vectores

r eal , di mensi on ( : ) , poi nt er : : pv1r eal , di mensi on ( : , : ) , poi nt er : : pv2r eal , di mensi on ( 5, 10) , t ar get : : t v2pv1 => t v( 4, : ) ! pv1 apunt a a l a 4ª

f i l a! de t v2

pv2 => t v2( 2: 4, 4: 8) ! pv2 apunt a a una! secci ón de t v2

t v2( 4, : )

pv1( 1: 10)

t v2( 2: 4, 4: 8)

pv2( 1: 3, 1: 5)


Punteros a vectores

� Hay varios aspectos a tener en cuenta:

� El puntero pv1 se asocia en diferentes momentos con vectores (secciones de vector) de diferentes extensiones. Esto se permite porque lo que cuenta es el rango, no la extensión

� Si un puntero a vector se hace alias de un vector, sus extensiones son las mismas que las del vector al que apunta. Así con la asignación pv1 => t v1, pv1 tiene los mismos límites que tv1, es decir −3:5. Si un puntero a vector apunta a una sección de vector, su límite inferior en cada dimensión se renumera siempre a 1.

Así con pv1 => t v1( : ) , donde se use el subíndice de la sección de vector los límites de pv1 son 1:9 en lugar de −3:5; de modo que pv1(1) se interpreta como tv1(−3), pv1(2) es tv1(−2), y así sucesivamente. Esta renumeración también ocurre cuando tv2 se interpreta como la sección tv2(2:4, 4:8)


Punteros a vectores

� Es lícito asociar un puntero a vector con una sección de vector definida por una tripleta de subíndices, pero no se permite asociarlo con una sección definida por subíndices. Así

pv1 => t v1( 1: 5: 2)

� es correcto con pv1( 1) siendo un alias de tv1(1), pv1(2) de tv1(3), y pv1(3) de tv1(5), pero la asignación de punteros:

pv1 => t v1( v) ! Er r or

no es admitida por el compilador


Estado de una asociación de punteros

� Todo puntero tiene uno de los siguientes estados de asociación:1.− Indefinido − cuando es inicialmente especificado en

una sentencia de declaración2.− Null (disociado) − cuando se hace nulo con una

sentencia NULLIFY3.− Asociado − cuando apunta a un destino

� Un puntero puede disociarse explícitamente de su destino (target) usando una sentencia NULLIFY:NULLI FY( l i st of poi nt er s)

� La función intrínseca associated puede usarse para comprobar el estado de asociación de un puntero usando 1 ó 2 parámetros:associ at ed( p, [ , t ] )

� Si el 2º parámetro no aparece, retorna .TRUE. si el puntero p está asociado con agún destino y .FALSE. en caso contrario. El 2º parámetro puede ser un puntero en cuyo caso retorna .TRUE. si ambos punteros están asociados al mismo destino o disociados y .FALSE. en caso contario


Estado de una asociación de punteros

� Una restricción de associated es que no se le pueden pasar punteros indefinidos. Por ello se recomienda asociar un puntero después de su declaración o disociarlo explícitamente con NULLIFY

Ejemplos:r eal , poi nt er : : p, q ! I ndef i ni dosr eal , t ar get : : t = 3. 4 p => t ! p apunt a a tq => t ! q t ambi én apunt a a t

pr i nt * , � associated(p)=",associated(p) !.T.pr i nt * , " associ at ed( p, q) =" , associ at ed( p, q) ! . T.NULLI FY( p)pr i nt * , " associ at ed( p) = " , associ at ed( p) ! . F.pr i nt * , " associ at ed( p, q) =" , associ at ed( p,

q) ! . F.. . .p => t ! p apunt a a tNULLI FY( p, q)

� Nótese que la disociación de p no afectó a q a pesar de que ambos apuntaban al mismo objeto. Después de anular un puntero, puede asociársele de nuevo con el mismo u otro objeto


Memoria dinámica

� También un puntero puede asociarse con un área de memoria alojada dinámicamente a través de la sentencia allocate. Esta sentencia crea (sin nombre) un área de memoria del tamaño, tipo y rango especificados y con un atributo target:

r eal , poi nt er : : pr eal , di mensi on ( : , : ) , poi nt er : : pvi nt eger : : m, n. . .al l ocat e ( p, pv( m, n) )

� Aquí el puntero p apunta a un área de memoria dinámica con capacidad para almacenar un real.

El puntero pv apunta a un vector (matriz) de tamaño m x n

� La memoria dinámica puede liberarse:deal l ocat e( pv)

haciendo que el estado de pv pase a ser NULL


Memoria dinámica

� La forma general de estas sentencias es:

al l ocat e( poi nt er [ ( di m. speci f i cat i on) ] . . . [ , STAT = st at us] )

deal l ocat e( poi nt er . . . [ , STAT = st at us]

� Donde poi nt er es una variable puntero y la especificación de dimensión especifica la extensión de cada dimensión si el puntero tiene los atributos pointer y dimension (es un puntero a un vector).

st at us es un entero que tomará el valor 0 si la demanda/liberación de memoria ocurrió correctamente. Ambas sentencias pueden solicitar/liberar memoria para varios punteros

� La programación con punteros entraña algunos peligros si no se diseña con precaución:


Memoria dinámica

� Referencias suspendidas:

. . .r eal , poi nt er : : p1, p2al l ocat e ( p1)p1 = 3. 4p2 => p1. . .deal l ocat e ( p1) ! Las r ef er enci as a p2. . . ! ahor a ser án er r or es! y l os r esul t ados son! i mpr edeci bl es. . .


Memoria dinámica

� Memoria inaccesible:

. . .r eal , di mensi on( : ) , poi nt er : : pal l ocat e ( p( 1000) ). . .

� Si el puntero p es anulado (NULLIFY), se hace apuntar a otra zona de memoria o este código está en un subprograma y el subprograma es abandonado (p no tiene atributo save) sin liberar la memoria, no habrá forma de referenciar ese bloque de memoria y por tanto no podrá ser liberado

� Solución: liberar cualquier bloque de memoria antes de modificar un puntero que apunte a ella


Argumentos puntero

� Los punteros, asociados o no, se pueden pasar como parámetros a los subprogramas pero sólo si se dan las siguientes condiciones:

Si un procedimiento tiene un puntero o destino como parámetro formal, la interface al procedimiento ha de ser explícita

Si un parámetro formal es un puntero, el parámetro actual ha de ser un puntero con el mismo tipo, parámetros de tipo y rango

Un parámetro formal de tipo puntero no puede tener atributo intent

� Si el parámetro actual es un puntero pero el formal no lo es, el parámetro formal se asocia con el destino del puntero

� Consideremos el siguiente código:


Argumentos puntero

. . . ! Uni dad de pr og. Que i nvoca a sub1 y sub2

i nt er f ace ! i nt er f ace par a sub2 subr out i ne sub2( b) r eal , di mensi on( : , : ) , poi nt er : : b end subr out i ne sub2end i nt er f acer eal , di mensi on( : , : ) , poi nt er : : p. . .al l ocat e ( p( 50, 50) )cal l sub1( p)cal l sub2( p). . .subr out i ne sub1( a) ! a no es un punt er o s i nor eal , di mensi on( : , : ) : : a ! un vect or de . . . ! f or ma asumi daend subr out i ne sub1 subr out i ne sub2( b) ! b es un punt er o r eal , di mensi on( : , : ) , poi nt er : : b . . . deal l ocat e( b) . . .end subr out i ne sub2


Argumentos puntero

� Los aspectos a tener en cuenta aquí son: Tanto sub1 como sub2 son procedimientos

externos. Puesto que sub2 tiene un parámetro formal puntero, se necesita un bloque interface en la unidad llamadora (no es necesario para sub1). Una alternativa hubiera sido usar un módulo o un procedimiento interno para suministrar una interface explícita por defecto

La unidad de programa llamadora hace que el puntero p sea un alias de un vector de 50x50 reales e invoca a sub2. Esto asocia el parámetro formal puntero b con el parámetro actual puntero p. Cuando sub2 libera b se libera también p en el programa llamador y hace que p pase a ser NULL

� Los vectores dinámicos no pueden usarse como parámetros formales y deben ser alojados y liberados en la misma unidad de programa. Se permite pasar como parámetros actuales vectores dinámicos con memoria asignada, pero no sin que les haya sido asignada memoria


Funciones que devuelven punteros

� El resultado de una función puede tener el atributo pointer, lo cual es útil si el tamaño del resultado depende de cálculos realizados en la función. Veamos un ejemplo: Una función que devuelve todos los valores >0 de un vector:

. . .i nt eger , di mensi on( 100) : : xi nt eger , di mensi on( : ) , poi nt er : : p. . .p => gt zer o( x). . .cont ai ns f unct i on gt zer o( a) i nt eger , di mensi on( : ) , poi nt er : : gt zer o i nt eger , di mensi on( : ) : : a i nt eger : : n . . . ! n = nº de val or es> 0 i f ( n == 0) NULLI FY( gt zer o) el se al l ocat e ( gt zer o( n) ) endi f . . . ! Poner l os val or es en gt zer o end f unct i on gt zer o. . .


Funciones que devuelven punteros

Consideraciones:

� La función gt zer o se ha codificado como un procedimiento interno porque la interface a una función que devuelve un puntero ha de ser explícita

� El resultado de la función puede utilizarse como una expresión en una sentencia de asignación de punteros (pero ha de asociarse antes con un destino −target− definido). Como resultado el puntero p apunta a un vector dinámico de enteros del tamaño correcto que contiene todos los valores positivos del vector x


Vectores de punteros

� Un vector de punteros no se puede declarar directamente:

r eal , di mensi on( 20) , poi nt er : : p ! Er r or

� No puede hacerse porque pointer es un atributo y no un tipo de datos. Un puntero puede ser una componente de un tipo derivado. Un vector de punteros se declara a través de un tipo derivado:

t ype r eal _poi nt er r eal , di mensi on( : ) , poi nt er : : pend t ype r eal _poi nt er

� Ahora se puede definir un vector de variables de este tipo:t ype( r eal _poi nt er ) , di mensi on( 100) : : a

� Y se puede hacer referencia al i−ésimo puntero:a( i ) %p


Vectores de punteros

� Un ejemplo en el que cada columna de una matriz triangular inferior se representa mediante un vector dinámico de tamaño creciente:

i nt eger , par amet er : : n = 10t ype( r eal _poi nt er ) , di mensi on( n) : : ai nt eger : : i

do i = 1, n al l ocat e ( a( i ) %p( i ) ) ! Ref er enci a al end do i −ési mo punt er o

� Nótese que a( i ) %p apunta a un vector dinámico de reales de tamaño i y por lo tanto esta representación utiliza sólo la mitad de la memoria que se necesitaría con un vector bidimensional convencional


Listas enlazadas

� Una componente de tipo puntero de un tipo derivado puede apuntar a un objeto del mismo tipo, lo cual permite crear listas enlazadas y otras estructuras de datos dinámicas:

t ype node i nt eger : : val ue !

Dat os t ype ( node) , poi nt er : : next ! Punt er oend t ype node

� En una estructura de este tipo los nodos− No tienen porqué almacenarse de forma contigua en

memoria− Pueden crearse dinámicamente (en tiempo de

ejecución)− Pueden insertarse en cualquier posición de la lista− Pueden eliminarse dinámicamente

� Por todo ello, el tamaño de estas estructuras puede crecer, casi arbitrariamente, conforme se ejecuta el programa


Listas enlazadas

� Una lista enlazada consiste habitualmente en elementos de un tipo derivado que contiene uno o varios campos de datos más un campo que es un puntero al siguiente elemento del mismo tipo en la lista

Campos de dat os

Punt er o

Campos de dat os

Punt er o

Campos de dat os

Punt er o...

cabecera cola


Listas enlazadas

pr ogr am si mpl e_l i nked_l i st i mpl i c i t none t ype node i nt eger : : val ue ! Campo de dat os t ype ( node) , poi nt er : : next ! Campo punt er o end t ype node i nt eger : : num, st at us t ype ( node) , poi nt er : : l i st , cur r ent ! bui l d up t he l i st NULLI FY( l i st ) ! I ni c i al ment e, vaci ar l a l i st a do r ead * , num ! Leer num del t ecl ado i f ( num == 0) exi t ! Hast a que se l ea un 0 al l ocat e( cur r ent , STAT = st at us) ! Cr ear nodo i f

( st at us > 0) st op ’ Fal l o al cr ear nodo’ cur r ent %val ue = num cur r ent %next => l i st ! Apunt ar al ant er i or l i s t => cur r ent ! Act ual i zar head end do ! Recor r er l a l i st a i mpr i mi endo l os val or es cur r ent => l i st ! Cur r ent es un al i as de l i st do i f ( . not . associ at ed( cur r ent ) ) exi t pr i nt * , cur r ent %val ue cur r ent => cur r ent %next end doend pr ogr am si mpl e_l i nked_l i st


Listas enlazadas

! Recor r er l a l i s t a el i mi nando nodos:cur r ent => l i s tdo i f ( . not . associ at ed( cur r ent ) ) exi t l i s t => cur r ent %next deal l ocat e( cur r ent ) cur r ent => l i s tend do


6Nuevas

características de entrada/salida



1.− Introducción

2.− Código fuente, tipos y estructuras de control3.− Procedimientos y Módulos4.− Proceso de vectores5.− Punteros6.− Nuevas características de entrada/salida7.− Procedimientos intrínsecos8.− Características redundantes9.− Desarrollos futuros


Entrada/Salida

Índice� 6.1 − Introducción � 6.2 − Entrada/Salida (E/S) sin avance� 6.3 − Consultar lista de E/S (INQUIRE)� 6.4 − NAMELIST� 6.5 − Nuevos descriptores de edición� 6.6 − Nuevos especificadores de sentencias� 6.7 − Ejercicios


Introducción

� Las sentencias de entrada/salida (E/S) en Fortran90 son respectivamente read y write

� Cada una de ellas puede adoptar 3 formas diferentes:

r ead <ch_var >, <l i st a_de_ent r ada>r ead <et i quet a>, <l i st a_de_ent r ada>r ead * , <l i st a_de_ent r ada>

pr i nt <ch_var >, <l i st a_de_ent r ada>pr i nt <et i quet a>, <l i st a_de_ent r ada>pr i nt * , <l i s t a_de_ent r ada>

� <ch_var> es una constante de caracteres, una variable de tipo character o un vector de caracteres

� <etiqueta> es la etiqueta de una sentencia en el código

� Las listas corresponden a las variables que se desea leer o escribir


Introducción

� La primera forma de sentencia de E/S se denomina de formato empotrado porque el formato en sí mismo forma parte de la sentencia:

pr i nt ( <l i st a_de_descr i pt or es>)

�,

<l i s t a_sal i da>

� En la segunda variante, la etiqueta corresponderá con una sentencia format, que contiene el formato que se desea en la operación de E/S

� La tercera forma es la que se conoce como E/S dirigida por lista. Se trata de la forma más simple y la que más hemos utilizado a lo largo del curso.

En esta forma el asterisco indica que se desea un formato de entada o salida acorde con el tipo de los valores a leer/escribir


Formateadores de E/S

I w Escribe un entero en los siguientes wcaracteres

Fw.d I mpr ime un número real en lossiguientes w caracteres utilizando dposiciones decimales

Ew.d I mpr ime un número real en lossiguientes w caracteres utilizando unformato de exponente con d posicionesdecimales y 4 dígitos para el exponente

Aw Escribe una cadena de caracteres en lossiguientes w caracteres

A Escribe una cadena de caracterescomenzando en la siguiente posición

Lw I mpr ime L−1 espacios en blanco seguidospor T o F para indicar un valor lógico

nX I gnora las siguientes n posicionesTc I mpr ime el siguiente elemento

comenzando en el carácter cTLn I mpr ime el siguiente elemento

comenzando n posiciones antes ( TL)TRn O después ( TR) de la posición actual"c1c2...cn" I mpr ime la cadena de caracteres c 1c2...cn

comenzando en la siguiente posición’c1c2...cn’ I mpr ime la cadena de caracteres c 1c2...cn

comenzando en la siguiente posición


E/S sin avance

� En Fortran 77, cualquier sentencia read o write involucra a registros completos. Hay ocasiones en que resulta conveniente leer/escribir sólo parte de un registro, y leer/escribir el resto más tarde. En F90 esta capacidad la proporciona la E/S sin avance

� La E/S sin avance elimina la necesidad de que los registros sean leídos como un todo y de que la longitud de los registros sea conocida de antemano. Se especifica mediante

advance=’ NO�

En la sentencia read o write e inhibe el avance automático hasta el siguiente registro al ejecutar la sentencia. Si se especifica

advance=’ YES’

� O no se ha especificado nada, entonces se utiliza la forma normal (con avance) de E/S


E/S sin avance

� Se puede especificar E/S con y sin avance en el mismo registro o fichero. Una aplicación común de esta posibilidad es escribir una pregunta en pantalla sin usar avance, y leer la siguiente posición en la pantalla. Por ejemplo:

wr i t e( * , ’ ( " Tamaño? " ) ’ , advance=’ NO’ )r ead( * , ’ ( I 5) ’ ) s i ze

� A veces es útil determinar cuantos caracteres han sido leídos en una entrada sin avance. Esto se puede conseguir utilizando el especificador size (en la sentencia read), que tiene la forma:

si ze=char act er _count

� Al finalizar la lectura sin avance, a la variable entera char act er _count se le asigna el número de caracteres leídos, excluyendo caracteres de relleno


E/S sin avance

� Se puede detectar si una lectura sin avance lee más allá del final de un registro utilizando el especificador IOSTAT, que tiene la forma:

I OSTAT=i o_st at us

� Al finalizar una sentencia read, a i o_st at us se le asigna un valor que indica si se ha alcanzado un fin de fichero o fin de registro.

� Es necesario estudiar la documentación del compilador que se utilice para comprobar el valor de IOSTAT devuelto en estas situaciones


Consulta de la lista de E/S

� Se utiliza para determinar la longitud de una lista de elementos de salida sin formato. La forma es:

I NQUI RE( I OLENGTH=l engt h) out put −l i st

� La longitud puede usarse como valor para el especificador RECL en una operación open subsiguiente. Por ejemplo:

i nt eger : : r ec_l en. . .I NQUI RE( I OLENGTH=r ec_l en) name, t i t l e, &age, addr ess, t el. . .open( uni t =1, f i l e=’ TEST’ , RECL=r ec_l en, &FORM=’ UNFORMATTED’ ). . .wr i t e( 1) name, t i t l e, age, addr ess, t el. . .


NAMELIST

� NAMELIST da la capacidad de agrupar juntas un conjunto de variables para simplificar la E/S. NAMELIST es una sentencia de especificación y ha de aparecer antes que las sentencias ejecutables. La forma general es:

NAMELI ST/ namel i st −gr oup−name/ var i abl e−l i st

� Se trata de de una característica del lenguaje que debería evitarse siempre que sea posible

� En sentencias read o write el nombre de lista debe especificarse con el especificador NML o puede sustituir al especificador de formato. No se necesitan listas de E/S.


NAMELIST

� Un registro de E/S para un grupo NAMELIST tiene un formato específico:

&namel i st −gr oup−name var 1=x, var 2=y, var 3=z

� Es posible omitir elementos cuando se está introduciendo datos y esos elementos no cambian. Tampoco hay que introducir los elementos en el orden especificado por la sentencia NAMELIST

� El siguiente ejemplo muestra el grupo llamado cl ot hes :

i nt eger : : s i ze=2char act er ( l en=4) : : col our ( 3) = &( / ’ r ed’ , ’ pi nk’ , ’ bl ue’ / )NAMELI ST / c l ot hes/ s i ze, col ourwr i t e( * , NML = cl ot hes)

La salida sería:

&CLOTHES si ze = 2, COLOUR = r edpi nkbl ue/


Descriptores de edición

� Los descriptores de edición especifican exactamente cómo se convertirán en cadenas de caracteres los valores en un dispositivo de salida o fichero interno o cómo se convierten en cadenas de caracteres en un dispositivo de entrada o fichero interno

� Fortran90 posee los siguientes descriptores de edición nuevos con respecto a F77:

EN (Engineering − ingeniería). Análogo a E pero

con exponentes divisibles por 3ES (Scientific). Análogo a E pero con el valorantes del punto decimal en [1, 10]

B BinarioO OctalZ HexadecimalG Descriptor Generalizado aplicable

a todos

los tipos intrínsecos


Descriptores de edición

� El siguiente ejemplo muestra la diferencia entre los descriptores de edición E, EN, ES y G

pr ogr am e_en_es_g_compar e i mpl i c i t none r eal , di mensi on( 4) : : & x=( / 1. 234, −0. 5, 0. 00678, 98765. 4/ ) pr i nt ’ ( 4E14. 3/ 4EN14. 3/ 4ES14. 3/ 4G14. 3) ’ , & x, x, x, xend pr ogr am e_en_es_g_compar e

� La salida sería:

0. 123E+01 −0. 500E+00 0. 678E−02 0. 988E+051. 234E+00 −500. 000E−03 6. 780E−03

98. 765E+031. 234E+00 −5. 000E−01 6. 780E−03 9. 877E+041. 23 −0. 500 0. 678E−02 0. 988E+05


Nuevos especificadores de sentencias

� Las sentencias INQUIRE, open, read y write no son nuevas, pero se han añadido unos cuantos especificadores nuevos:

� INQUIREPOSI TI ON=ASI S, REWI ND, APPEND o UNDEFI NEDI ndi ca l a posi c i ón en el f i cher o t al como

se especi f i có en l a sent enci a openACTI ON=r ead, wr i t e, READWRI TE o UNDEFI NEDDELI M=APOSTROPHE, QUOTE, NONE o UNDEFI NEDI ndi ca el car áct er ut i l i zado par a

del i mi t ar const ant es de car act er es con E/ S di r i gi da por l i s t as o por NAMELI ST. Por def ect o es NONE ( ni nguna)

PAD=YES o NO

‘ � ES’ si gnf i ca que el r egi st r o de ent r ada ha de r el l enar se con bl ancos. El def ect o es PAD=‘ � ES’

READWRI TE=YES, NO o UNKNOWNI ndi ca s i par a un f i cher o est á per mi t i do

o no l eer y escr i bi r o no est á det er mi nado



� INQUIREr ead=YES, NO o UNKNOWNI ndi ca s i par a un f i cher o est á per mi t i do

o no l eer o no est á det er mi nadowr i t e=YES, NO o UNKNOWNI ndi ca s i par a un f i cher o est á per mi t i do

o no escr i bi r o no est á det er mi nado

� openLos especi f i cador es POSI TI ON, ACTI ON,

DELI M y PAD t i enen l os mi smos val or es y s i gni f i cados que con I NQUI RE. Hay un val or adi c i onal :

STATUS=REPLACESi el f i cher o a abr i r no exi st e, se cr ea,

y s i exi st e se bor r a y se cr ea uno nuevo



� read/writeNML=namel i st _nameSe ut i l i za en l ugar del especi f i cador de

f or mat o cuando se usa un gr upo NAMELI STadvance=YES o NO

� readEOR=l abelTr ansf i er e el cont r ol a l a sent enci a

et i quet ada cuando ocur r e una condi c i ón de f i n de r egi st r o

si ze=char act er _count


7Procedimientos

intrínsecos



1.− Introducción




Procedimientos intrínsecos

Índice

� 7.1 − Procedimientos elementales� 7.2 − Funciones de consulta� 7.3 − Funciones de transformación� 7.4 − Subrutinas intrínsecas no elementales� 7.5 − Procedimientos intrínsecos para vectores� 7.6 − Ejercicios


Procedimientos elementales

� Se especifican para parámetros escalares, pero también son aplicables a parámetros vectoriales compatibles aplicando el procedimiento elemento a elemento

� Funciones elementales

� Funciones Numéricas:cei l i ng( A)El menor ent er o mayor que A

f l oor ( A)El mayor ent er o que no exceda A

modul o( A, P)Rest o de A/ P ( ambos r eal es o ent er os)



� Funciones de caracteres:achar ( I )El car áct er en l a posi c i ón I de l a

secuenci aadj ust l ( st r i ng)Aj ust a a l a i zqui er da cambi ando bl ancosadj ust r ( st r i ng)Aj ust a a l a der echa cambi ando bl ancosi achar ( C)Posi c i ón del car áct er C en l a secuenci ai ndex( st r i ng, subst r i ng [ , back] )Posi c i ón de comi enzo de subst r i ng dent r o

de st r i ng. Si hay más de una subcadena se r et or na l a posi c i ón de l a pr i mer a ( o de l a úl t i ma si back es t r ue)

l en_t r i m( st r i ng)Longi t ud de l a cadena el i mi nando bl ancos



� Funciones de caracteres:scan( st r i ng, SET [ , back] )Í ndi ce del car áct er más a l a i zqui er da

( más a l a der echa si back es t r ue) de l a cadena que per t enece a SET. Cer o s i ni nguno per t enece

ver i f y( st r i ng, SET [ , back] )La posi c i ón del car áct er más a l a

i zqui er da ( más a l a der echa si back es t r ue) de l a cadena que no est á en SET. Cer o s i t odos est án en SET

� Funciones de manipulación de bitsBTEST( I , POS)Tr ue si el bi t POS del ent er o I es 1I AND( I , J)Y l ógi co de l os bi t s de I y JI BCLR( I , POS)Pone a 0 el bi t POS de II BI TS( I , POS, l en)Ext r ae una secuenci a de l en bi t s de I

comenzando en el bi t POS



� Funciones de manipulación de bitsI BSET( I , POS)Pone a 1 el bi t POS de II EOR( I , J)O−Excl usi va l ógi ca de l os bi t s de I , JI OR( I , J)O−I ncl usi va l ógi ca de l os bi t s de I , JI SHFT( I , SHI FT)Val or de I con sus bi t s r ot ados SHI FT

posi c i ones a l a i zqui er da ( der echa si es negat i vo) y con cer os por el ext r emo opuest o

I SHFTC( I , SHI FT[ , s i ze] )Val or de I con una r ot aci ón ci r cul ar de

sus si ze bi t s más a l a der echa r ot ados SHI FT posi c i ones a l a i zqui er da ( der echa si es negat i vo)

NOT( I )Compl ement o l ógi t o de t odos l os bi t s de I



� Funciones de valores de clasesel ect ed_i nt _ki nd( R)Cl ase del par ámet r o de t i po par a el r ango

de exponent e dado. Se r et or na −1 si no est á di sponbi l e esa cl ase

sel ect ed_r eal _ki nd( P, R)Cl ase del par ámet r o de t i po par a l a

pr eci s i ón y r ango de exponent e dados. Se r et or na −1 si l a pr eci s i ón no est á di sponbl e, −2 si no l o est á el r ango y −3 si no l o est á ni nguno de l os dos

� Funciones de manejo de Punto flotanteexponent ( X)Exponent e de Xf r act i on( X)Par t e f r acci onal de Xnear est ( X, S)El s i gui ent e númer o di f er ent e ( en l a

máqui na en cuest i ón) en l a di r ecci ón dada por el s i gno de S



� Funciones de manejo de Punto flotanteRRSPACI NG( X)El r ecí pr oco del espaci ado r el at i vo de

l os númer os más pr óxi mos a XSCALE( X I )Convi er t e X a I ( r eal a ent er o)SET_exponent ( X, I )Real cuyo si gno y par t e f r acci onal son

l os de X y cuya par t e de exponent e es ISPACI NG( X)Espaci ado absol ut o de l os númer os

cer canos a X� Funciones lógicas

l ogi cal ( L [ , k i nd] )Convi er t e ent r e c l ases de númer os l ógi cos

� Subrutina elementalcal l MVBI TS( FROM, FROMPOS, l en, TO, TOPOS)Copi a l en bi t s de FROM comenzando en l a

posi c i ón FROMPOS hast a l a posi c i ón TO, comenzando en l a posi c i ón TOPOS


Funciones de consulta

associ at ed( poi nt er [ , t ar get ] )Tr ue si el punt er o est á asoci ado con el

dest i no. Si t ar get apar ece, sól o es t r ue s i est á asoci ado con el dest i no especi f i cado

bi t _si ze( I )Númer o máxi mo de bi t s que pueden

al macenar se en un ent er o

ki nd( X)Val or de cl ase de t i po par a X

pr esent ( A)Tr ue si el par ámet r o opci onal A ha si do

pasado a l a subr ut i na



� Funciones de consulta numéricasdi gi t s( X)Númer o de dí gi t os s i gni f i cat i vos en l a

r epr esent aci ón de Xepsi l on( X)Númer o que es casi despr eci abl e compar ado

con 1 en l a r epr esent aci ón i nt er na de númer os del t i po de X

huge( X)El mayor númer o en l a r epr esent aci ón de

númer os del t i po de Xmaxexponent ( X)Máxi mo exponent e en l a r epr esent aci ón de

númer os del t i po de Xmi nexponent ( X)Mí ni mo exponent e en l a r epr esent aci ón de

númer os del t i po de Xpr eci s i on( X)Pr eci s i ón deci mal en l a r epr esent aci ón de

X



� Funciones de consulta numéricasr adi x( X)Base de l a r epr esent aci ón de númer os del

t i po de Xr ange( X)Rango del exponent e deci mal en l a

r epr esent aci ón que i ncl uye X de t i po ent er o, r eal y compl ej o

t i ny( X)El menor númer o posi t i vo en l a

r epr esent aci ón de númer os del t i po de X


Funciones de Transformación

r epeat ( st r i ng, ncopi as)Concat ena ncopi as de st r i ng

t r ansf er ( f uent e, MOLD [ , s i ze] )La mi sma r epr esent aci ón f í s i ca que f uent e

per o de t i po MOLD

t r i m( st r i ng)El i mi na l os espaci os en bl anco sobr ant es

de st r i ng


Subrutinas intrínsecas no elementales

cal l dat e_and_t i me( [ DATE] [ , TI ME] [ , ZONE] [ VALUES] )

Leer l a f echa y l a hor a del r el oj i nt er no

r andom_number ( HARVEST)Devuel ve un númer o pseudoal eat or i o en el

r ango [ 0, 1)

r andom_seed( [ s i ze] [ , PUT] [ , GET] )I ni c i al i za o r ei ni c i al i za el gener ador de

númer os pseudoal eat or i os

syst em_cl ock( [ count ] [ , count _RATE] [ count _max] )Devuel ve un ent er o del r el oj i nt er no


Procedimientos intrínsecos para vectores

� ReduccionesALL( MASK[ , DI M] )Tr ue si t odos l os el ement os son t r ueANY( MASK[ , DI M] )Tr ue si al gún el ement o es t r ueCOUNT( MASK [ , DI M] )Númer o de el ement os t r ueMAXVAL( ARRAY [ , DI M] [ , MASK] )Val or del mayor el ement oMI NVAL( ARRAY [ , DI M] [ , MASK] )Val or del menor el ement oPRODUCT( ARRAY [ , DI M] [ , MASK] )Pr oduct o de l os el ement os del vect orSUM( ARRAY [ , DI M] [ , MASK] )Suma de l os el ement os del vect or


� Consultaal l ocat ed( ARRAY)t r ue si el vect or ha si do al oj adol bound( ARRAY[ , DI M] )Lí mi t es i nf er i or es del vect orshape( f uent e)For ma del vect or ( o escal ar )s i ze( ARRAY[ , DI M] )Tamaño del vect orubound( ARRAY[ , DI M] )Lí mi t es super i or es del vect or



� ConstrucciónMERGE( TSOURCE, FSOURCE, MASK)Mezcl a vect or es de acuer do a MASKpack( ARRAY, MASK[ , VECTOR] )Empaquet a el ement os en VECTOR de acuer do

a MASKSPREAD( f uent e, DI M, ncopi as)Const r uye un vect or dupl i cando una

secci ón de ot r oUNPACK( VECTOR, MASK, FI ELD)Desempaquet a el ement os de vect or de

acuer do a MASK � Cambio de forma

r eshape( f uent e, shape[ , PAD] [ , ORDER] )Cambi a l a f or ma de un vect or

� Posición en un vectorMAXLOC( ARRAY[ , MASK] )Posi c i ón del el ement o máxi moMI NLOC( ARRAY[ , MASK] )Posi c i ón del el ement o mí ni mo



� Manipulación de vectoresCSHI FT( ARRAY, SHI FT[ , DI M] )Real i za una r ot aci ón ci r cul arEOSHI FT( ARRAY, SHI FT[ , BOUNDARY] [ , DI M] )Real i za una r ot aci ón si n f i nTRANSPOSE( MATRI X)Tr aspone l a mat r i z

� Aritmética vectorial y matricialDOT_PRODUCT( VECTOR_A, VECTOR_B)Pr oduct o escal arMATMUL( MATRI X_A, MATRI X_B)Pr oduct o de mat r i ces



8Características redundantes con

respecto a Fortran77



1.− Introducción




Características redundantes

Índice

� 8.1 − Forma del código fuente� 8.2 − Datos� 8.3 − Control� 8.4 − Procedimientos� 8.5 − Entrada/Salida


Características Redundantes

� Fortran90 incluye características redundantes (deprecated) que se pueden seguir usando puesto que no está previsto que desaparezcan en la siguiente revisión, pero se desaconseja su utilización en programas nuevos puesto que en el futuro sí es posible que desaparezcan

� Estas características redundantes se clasifican dentro de 5 categorías: forma del código fuente, datos, control, procedimientos y E/S


Forma del código fuente

� El formato fijo, que estaba basado en el aspecto de una tarjeta perforada ha sido sustituido por el formato libre y éste debería usarse en los programas nuevos. Es posible hacer modificaciones sencillas al formato fijo para producir código que es legal tanto en formato libre como fijo

� Se recomienda la utilización de módulos en lugar de usar líneas INCLUDE. Esta directiva se utilizaba para incluir ficheros texto en un lugar específico


Datos

� Fortran 77 tiene dos formas de variables y constantes reales: real y double precision. Han sido sustituidas por el concepto de tipos de datos parametrizados que dan mayor portabilidad numérica. No debería usarse double precision en programas nuevos

� El peligroso concepto de tipo implícito y la sentencia IMPLICIT no deberían usarse. Se aconseja el uso de implicit none

� Se recomienda el uso de la nueva forma de declarar variables usando dos puntos (::) entre el tipo y la lista de variables. Asimismo se recomienda usar los atributos parameter, dimension, etc. en la declaración más que en forma de sentencias

� Generalmente no se necesita la sentencia DATA puesto que las variables pueden ser inicializadas en una sentencia de declaración


Datos

� Los bloques COMMON y BLOCK DATA no deberían usarse puesto que el uso de módulos elimina la necesidad de su utilización. De forma análoga, la sentencia EQUIVALENCE ha dejado de ser necesaria por la introducción de los módulos, manejo dinámico de memoria, punteros y la función intrínseca transfer

� Se recomienda no utilizar nunca el atributo SEQUENCE


Control

� Características obsoletas de F77 son:� Sentencia if aritmética� Terminación compartida de un do. Terminación de

un do en una sentencia diferente de continue o end do

� Variables do y de control de expresiones de tipo real o double precision

� Sentencias assign y GO TO asignados� Saltos hacia un end if desde fuera de un bloque if� return alternado� Sentencia pause

� Estas características no deberían usarse en códigos nuevos o revisados. Pueden reemplazarse por sentencias if, do, case, exit y cycle

� Con la introducción de modernas estructuras de control y de especificaciones de cadenas de caracteres la necesidad de etiquetas es redundante

� El constructo do y las sentencias exit y cycle sustituyen el uso de la sentencia continue al final de un bucle do


Control

� Las sentencias GO TO y GO TO calculados deberían sustituirse por los constructos if, do y case y las sentencias exit y cycle

� Se puede utilizar el bucle do combinado con la sentencia exit como forma equivalente a los bucles do while


Procedimientos

� Las funciones intrínsecas con nombres específicos para diferentes tipos de datos se han sustituido por versiones genéricas. Aún se necesitan nombres específicos cuando una función intrínseca se utiliza como parámetro actual en una llamada

� La sentencia ENTRY permite que un procedimiento tenga más de un punto de entrada. En F90 es innecesaria puesto que en un módulo cada punto de entrada se convierte en un procedimiento de módulo

� La utilización de procedimientos de módulo y procedimientos internos hacen innecesarios los procedimientos externos. Los procedimientos externos y la sentencia external son redundantes en F90


Entrada / Salida

� Los especificadores de formato asignados deberían sustituirse por especificaciones de cadenas de caracteres

� Los especificadores end, EOR y ERR se utilizan cuando ocurren condiciones anómalas en entrada/salida. Se recomienda el uso de IOSTAT en lugar de éstos

� La entrada/salida usando �Namelist

� es una

característica mal diseñada y se desaconseja su utilización

� Se desaconseja la utilización de 6 descriptores de edición: D, BN, BZ, P, G y X

� El descriptor de edición D se sustituye por el E y los BN y BZ por el especificador BLANK


Entrada / Salida

� El descriptor de edición P permite que los datos numéricos se escalen tanto al hacer entrada o salida. Esto podría conducir a confusión y por tanto se desaconseja

� El descriptor de edición G es un descriptor generalizado que se puede utilizar al leer o escribir valores de cualquier tipo intrínseco. Se aconseja la utilización de los descritptores I, E, EN, F, L o A puesto que a través de éstos se comprueba que los tipos de datos son los correctos

� El descritptor de edición X tiene el mismo efecto que el TR y se recomienda el uso de este último


9Desarrollos

futuros



1.− Introducción




Desarrollos Futuros

Índice

� 9.1 − Fortran95� 9.2 − Arquitecturas paralelas


Fortran95

� Fortran95 se esperaba que hubiera sido simplemente una actualización de F90 consistente fundamentalmente en clarificaciones y correcciones de aquél.

� El mayor cambio significativo se espera que sea Fortran2000

� Sin embargo Fortran95 debería suministrar algunas características nuevas:

�Sentencia y constructo FORALL

�FORALL permite asignaciones vectoriales más simples:

FORALL ( i =1: n) a( i , i ) =iFORALL ( i =1: n, j =1: n, y( i , j ) / =0 . and. &i / =j ) x( i , j ) =1. 0/ y( i , j )FORALL ( i =1: n) a( i , i ) =i b( i ) =i * iend


Fortran95

� El atributo PURE

que permite una utilización segura de procedimientos en las sentencias FORALL

� Funciones intrínsecas para la consulta del tiempo de CPU:

cal l CPU_TI ME( t 1)� Parámetros dinámicos en los subprogramas� where anidados:

wher e ( mask1). . . wher e ( mask2) . . . el sewher e . . . end wher eel sewher e. . .end wher e


Fortran95

� Inicialización de entidades

Estado inicial para punteros y tipos:

r eal , poi nt er : : P( : ) =>NULL( )

t ype st r i ng char act er , poi nt er : : ch( : ) =>NULL( )ENDTYPE


Arquitecturas paralelas

� Es muy importante en la actualidad que un nuevo estándar como lenguaje de programación permita una compilación y ejecución eficiente tanto en supercomputadores como en arquitecturas convencionales.

F90 se dice que es eficiente en arquitecturas convencionales y vectoriales, pero es menos eficiente en arquitecturas paralelas. Sin embargo las tendencias arquitectónicas se han desplazado desde las máquinas vectoriales a los computadores masivamente paralelos. Este interés en arquitecturas paralelas ha conducido al desarrollo de tres estándares de facto:

�High Performance Fortran (HPF)

�OpenMP

�Message Passing Interface (MPI)


HPF

� El objetivo de High Performance Fortran (HPF) es suministrar una serie de extensiones a Fortran90 para soportar:

�Expresión de paralelismo de datos

�Máxima eficiencia sobre máquinas MIMD y SIMD con acceso no uniforme a memoria

�Sintonización de código para diferentes arquitecturas

�Desviación mínima de otros estándares de programación

�Definir interfaces abiertas a otros lenguajes

�Potenciar la incorporación de conocimientos de la comunidad científica de computación de altas prestaciones


HPF

� Fotran 90 soporta paralelismo de datos a través de las operaciones sobre vectores y funciones intrínsecas sobre vectores. HPF extiende este soporte con:

�Directivas de compilación para alineamiento y distribución de datos

�Características de ejecucón concurrente utilizando la sentencia FORALL

�La directiva INDEPENDENT que permite al programador informar al compilador del comportamiento de un bucle do o de una sentencia FORALL

�Funciones intrínsecas para consultar detalles específicos de la arquitectura

�Una librería de rutinas para soportar operaciones globales


OpenMP

� La API de OpenMP da soporte para programación en paralelo en diversas plataformas de memoria compartida tanto en Fortran como en C/C++

� Definida de forma conjunta por un grupo de fabricantes de software y hardware, OpenMP es un modelo portable y escalable que suministra a los programadores en paralelo una interface simple y flexible para el desarrollo de aplicaciones paralelas.

� http://www.openmp.org/h� ttp://www.compunity.org/


Un ejemplo en OpenMP

* Copy new solution into old!$omp parallel

!$omp do do j=1,m do i=1,n uold(i,j) = u(i,j) enddo enddo

* Compute stencil, residual, & update

!$omp do private(resid) reduction(+:error) do j = 2,m−1 do i = 2,n−1 * Evaluate residual resid = (ax*(uold(i−1,j) + uold(i+1,j)) & + ay*(uold(i,j−1) + uold(i,j+1)) & + b * uold(i,j) − f(i,j))/b* Update solution u(i,j) = uold(i,j) − omega * resid* Accumulate residual error error = error + resid*resid end do enddo!$omp enddo nowait

!$omp end parallel


MPI

� MPI (Message Passing Interface) es un estándar propuesto para:

�Paso de mensajes explícito

�Programas de aplicaciones

�Arquitecturas MIMD de memoria distribuida

�Redes de estaciones de trabajo

� Se necesita un estándar de este tipo por diferentes motivos:

�Portabilidad y facilidad de uso

�Es el momento adecuado para definir un estándar en este campo

�Construcción de librerías de programas

�Es un prerequisito para el desarrollo de la industria del software concurrente

�Suministra a los vendedores de hardware con un conjunto bien definido de rutinas que han de implementar eficientemente


MPI

� MPI contiene:�

Paso de mensajes punto a punto�

Rutinas de comunicación colectiva� Para movimiento de datos (versiones uno a todos

y todos a todos de las rutinas de broadcast, scatter y gather)

� Cómputos globales (rutinas reduce y scan)�

Soporte para grupos de procesadores y para contextos de comunicaciones

� Las comunicaciones combinan contextos y grupos para la seguridad de mensajes y de threads de ejecución

�Soporte para topologías de aplicación (mallas y grafos)


Referencias

� Máquina de cálculo científico de la ULL:ht t p: / / www. cct i . ul l . es/ cpu/

� Fortran 77ht t p: / / www. cct i . ul l . es/ cpu/ f 77/ f 77. ht m

� Fortran 90ht t p: / / www. cct i . ul l . es/ cpu/ f 90/ f 90. ht m

� Procedimientos intrínsecos en Fortran 90ht t p: / / www. cct i . ul l . es/ cpu/ f 90/ f 90_r ef er

ence_manual _9. t xt� HPF

ht t p: / / www. cct i . ul l . es/ cpu/ hpf / hpf . ht m� MPIht t p: / / www−uni x. mcs. anl . gov/ mpi / i ndex. ht ml

fortran90 -...

Documents