Inicialización de arreglos de 2 variablesInicialización de arreglos de 2 variables

INTEGER , DIMENSIÓN (4, 3) : : iniDO i=1, 4 DO j= 1,3

ini(i, j) = j END DOEND DO

i=1 1 2 3

i=2 1 2 3

i=3 1 2 3

i=4 1 2 3

j=1 j=2 j=3

Pero si inicializamos con:(/1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3/)

Ini es de 4x3

Ini es de 1x12

Aunque los 2 arreglos tienen el mismo numero de elementos, no tienen la misma forma y no pueden ser usados en la misma operación. Para transformalo está la función intrínseca RESHAPE

Ej ini= RESHAPE ((/1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3/), (/4, 3/)

Convierte al vector 1X12 en una matriz de 4X3 la cual es asignada a ini: INTEGER, DIMENSION (4,3) : : ini (4,3)=&

RESHAPE ((/1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3/), (/4, 3/)

Buena costumbre: Cuando se trabaja con matrices conservar su forma. Leerlas y escribirlas con DO o DO implícitos y al realizar operaciones→ programas mas entendibles.

Matrices y subconjuntos de matricesMatrices y subconjuntos de matrices

Se puede realizar operaraciones aritméticas con dos matrices cuando son conformes o una es un escalarEj

1 2 3 4 5

6 7 8 9 10

11 12 13 14 15

16 17 18 19 20

21 22 23 24 25

a=

Para realizar un subconjunto de la matriz a

1

6

11

16

21

a( : , 1)=

a(1, : ) = [ 1 2 3 4 5 ]

1 3 5

6 8 10

11 13 15a(1: 3, 1: 5: 2) =

Arreglos de mas de 2 dimensionesArreglos de mas de 2 dimensiones

Ej 2x2x2

A(1,1,1) A(2,1,1) A(1,2,1) A(2,2,1) A(1,1,2) A(2,1,2) A(1,2,2) A(2,2,2)

Generalizando para N dimensiones:El primer subíndice es el que se mueve mas rápidamente, un poco mas lento el segundo… el último es el más lento de todos.Esto se debe tener en cuenta para inicializar, leer o escribir…..

Enmascarar : la construcción WHEREEnmascarar : la construcción WHERE

Ej: Queremos calcular el logaritmo a una matriz DO i=1, ifin

DO j=1, jfin logval(i,j)= log(valor(i,j))END DO

END DO

Otra forma:logva= log (valor)

Pero no tubimos en cuenta si exiistia algun valor negativo o un 0 para la cual la función LOG no es válida. Para evitar ese error se deberia programar:

DO i=1,ifin DO j=1,jfin

IF(valor(i,j) >0.) then logval(i, j) = LOG(valor(i,j))ELSE logval(i, j) = -99999.END IF

END DOEND DO

A esta asignación se le dice enmascarar

En FORTRAN 90 existe una función que realiza esta asignación: WHERE[nombre] WHERE ( mask_exp)Sentencias de asignación del arreglo !Bloque 1ELSEWHERE [nombre] Sentencias de asignación del arreglo !Bloque 2END WHERE [nombre]

Si la expresión mask_exp es verdad se ejecuta el Bloque 1, en caso contrario se ejecuta el Bloque 2.

EjWHERE (valor>0)logval=LOG(valor)ELSEWHERElogval=-99999.ENDWHERE

El FORTRAN 95 agrega una clausula mas al WHERE

[nombre] WHERE ( mask_exp1)Sentencias de asignación del arreglo !Bloque 1ELSEWHERE ( mask_exp2) [nombre] Sentencias de asignación del arreglo !Bloque 2ELSEWHERE [nombre] Sentencias de asignación del arreglo !Bloque 3END WHERE [nombre]

En los FORTRAN 90/95 también es válidoWHERE(mask_exp) sentencia de asignación del arreglo

Usando DO e IF

Usando WHERE

Analizar un conjunto de datos de entrada cuyo rango se debe encontrar entre -1000 y 1000. Si un valor no esta dentro de este intervalo asignarle el valor del límite inferior o superior según sea su signo.

Forall permite aplicar operaciones a elemento por elemento de una matriz o a un subconjunto , ya sea a través de los índices o/y una expresión lógica. (FORTRAN 95)En general:[nombre] FORALL (in1= icom, ifin, incr, [in2= ico, m2, ifin2, incr…..exp_log]

sentencia 1 …….. sentencia n END FORALL [nombre]

Ej SI se quiere conocer la inversa de una matriz de números realesFORALL(i=1:n, j=1: m , r(i,j)/=0)r(i, j) =1./ r (i, j)END FORALL

FORALL puede representar un DO anidado combinado con un IFDO i= 1,n DO j=1,m

IF (r (i, j)/= 0.) THEN r (i, j)=1./ r (i, j)

END IF END DOEND DO

FORALL (in1= icom, ifin, incr, [in2= ico, m2, ifin2, incr…..exp_log] sentencia de asignación

Cuando utilizamos las sentencias Do e IF las setencias dentro de ella se realizan en forma secuencial, en la forma seleccionada por el procesador.

FORALL (i=2:n-1, j=2,m-2)a( i, j) = SQRT(a( i, j))b( i, j) = 1./ a( i, j)

END FORALL

Realiza todos a( i, j) y cuando termina hace los b( i, j)

Hasta ahora el tamaño de los arreglos que hemos utilizado fue declarado junto con el nombre de la variable.

Ej: INTEGER , DIMENSIÓN (4, 3) : : ini

Esto se denomina STATIC MEMORY ALLOCATION. El espacio en memoria para almacenar el contenido del arreglo es siempre el mismo a lo largo de todo el programa.

En algunos casos, esto puede resultar inconveniente si hay algún arreglo que interviene en nuestro programa del que no conocemos a priori el tamaño que va a tener. Para salvar este problema generalmente se definen arreglos muy grandes que eventualmente permitan ajustarse a muchas situaciones, pero esto puede ser ineficiente si no utilizamos el tamaño completo de las variables ya que estamos usando mucha memoria.

Para resolver este problema, se introdujo la DYNAMIC MEMORY ALLOCATION que permite definir el tamaño de un arreglo durante la ejecución del programa. Esto hace que podamos adaptar los tamaños de los arreglos al problema específico que estamos resolviendo en cada caso.

ALLOCATABLE ARRAYSALLOCATABLE ARRAYS

REAL, ALLOCATABLE, DIMENSION(:) :: X ! La variable X tiene una sola dimensión

Este atributo le dice al programa que el tamaño de X no será determinado en el momento de la declaración sino más adelante. Si bien no hay que especificar el tamaño, si las dimensiones, esto lo hacemos colocando un “: “.

REAL, ALLOCATABLE, DIMENSION(:,:) :: X !En este otro caso X tiene 2 dimensiones.

Para lograr asignarle un espacio en la memoria y poder utilizar a la variable X disponemos de la sentencia ALLOCATE.

ALLOCATE ( X(10,20))

Esta sentencia le indica al programa que reserve un espacio de 10 filas por 2 columnas en la memoria para la variable X. A partir de este momento podemos utilizar la variable X como lo hacíamos antes.

Para permitir que el tamaño de un arreglo sea asignado durante la ejecución del

Programa → el atributo ALLOCATABLE en la declaración de las variables.

ALLOCATE(X(N,M)) ! Esto también es válido si N y M son 2 INTEGER.

Para liberar el espacio que está ocupado por la variable X en la memoria

⇨ DEALLOCATE

DEALLOCATE ( X )

IMPORTANTE ⇨ después de haber hecho esto no podremos acceder más a la variable X, su contenido se ha perdido.

EJ: Tipiar y compilar el siguiente programa, ejecutarlo mirando como varía la memoria utilizada por el sistema con el monitor del sistema de windows.

PROGRAM pepe

REAL, ALLOCATABLE, DIMENSION(:,:) :: X

WRITE(*,*)"Antes de asignar a X espacio en memoria, presione enter"

READ(*,*)

ALLOCATE(X(50000,1000))

WRITE(*,*)"X ya está en la memoria de la máquina, presione enter"

READ(*,*)

DEALLOCATE(X)

WRITE(*,*)"X fue eliminado de la memoria de la máquina"

STOP

END PROGRAM pepe