Arreglos (vectores, matrices, ….)
Un arreglo es un grupo de variables o constantes, todas del mismo tipo
referenciadas con un mismo nombre.
….
a(1)
a(2)
a(3)
a(4)
a(5)
a(6)
…..
arreglo
Cada valor individual se llama elemento
 El subíndice indica la posición particular dentro del arreglo.
El subíndice es un ENTERO.
Es útil para aplicar un algoritmo a un gran número de datos a través de
ciclos
Ej
DO i=1,100
a(i)=sqrt(a(i))
END DO
Declaración de los Arreglos
Los arreglos tienen que ser declarados antes de ser utilizados para que el
compilador guarde lugar en la memoria según el tipo y número de elementos
que contiene.
Ej
REAL, DIMENSION (100) : : a
Cuando se define la variable CHARACTER se tiene que tener en cuenta la
longitud de caracteres y elemento:s
Ej
CHARACTER(10), DIMENSION (12) : : mes
Los arreglos pueden ser declarados con más de un subíndice , por lo tanto
pueden tener 2 o más dimensiones.
El número de dimensiones se llama rango (rank).
El número de elementos de cada dimensión se llama extensión (extent).
La combinación del rango y la dimensión se llama forma (sharp) .
 El número de elementos declarados en el arreglo tamaño (size)
Arreglos constantes: sus elementos son ctes.
Pueden definirse entre /
Ej:
(/1, 2, 3, 4, 5/)
Inicialización de los arreglos
Los elementos de los arreglos son variables ordinarias y tienen que ser inicializadas
antes de ser usadas. Si no se la inicializa su valor es indefinido.
Pueden ser inicializados:
1. Sentencias de asignación elemento por elemento
Ej de esta forma de inicialización:

REAL, DIMENSION(10) : : arreglo
DO i=1,10
arreglo(i) = REAL(i)
END DO

REAL, DIMENSION(10) : : arreglo
arreglo=(/1., 2., 3., 4., 5., 6., 7., 8., 9., 10./)

REAL, DIMENSION(10) : : arreglo
arreglo=0.
! todos los elementos iguales

INTEGER, DIMENSION(10) : : num, cuad
DO i=1,10
num(i)=i+i
cuad(i)= num(i)**2
END DO
2. Inicialización por sentencias de declaración
Ej de esta forma de inicialización:

INTEGER, DIMENSION (5) : : arreglo = (/1, 2, 3, 4, 5 /)

INTEGER, DIMENSION (5) : : arreglo = (/(i, i=1,5)/)

INTEGER, DIMENSION (25) : : arreglo = (/((0, i=1,4), 5*j, j=1,5) /)

0, 0, 0, 0, 5, 0, 0, 0, 0, 10, 0, 0, 0, 0, 15, 0, 0, 0, 0, 20, 0, 0, 0, 0, 25
REAL, DIMENSION (100) : : arreglo =1.0
3. Inicialización de arreglos con READ
Valores de borde de los arreglos
Normalmente se usan valores de 1 a N
Ej:
REAL, DIMENSION (3) : : arr ⇒ arr(1), arr(2), arr(3)
pero muchas veces resulta útil que los subíndices tomen otros valores. Para definir
los:
REAL, DIMENSION (imin, imax) : : arr
Ej:
REAL, DIMENSION (5) aa
REAL, DIMENSION (-2 : 2) : : bb
REAL, DIMENSION ( 7:11) : : cc
Los 3 arreglos tienen la misma forma (igual dimensión e igual número de elementos
!
Controlar que el índice se encuentre dentro de los límites del arreglo
A(1) A(2) A(3) A(4) A(5) B(1)
Arreglo A
B(2)
B(3)
B(4)
……
Arreglo B
Si se utiliza el A(6) puede conducir a errores. Los compiladores FORTRAN
tienen opción bounds cheking para controlar los valores que toma el índice
Las constantes con nombre y la declaración de arreglos
Se utiliza para cambiar de manera simple el tamaño de los arreglos.
Ej:
INTEGER, PARAMETER : : tama=1000
REAL : : arre1(tama)
REAL : : arre2(2*tama)
REAL : : arre3(tama,tama)
Buena costumbre: declarar el tamaño de los arreglos usando
PARAMETER y realizar cambios rápidamente.
Usando arreglos completos o un subconjunto
a
VALOR
b
VALOR
c
VALOR
a(1)
1.
b(1)
5.
c(1)
6.
a(2)
2.
b(2)
6.
c(2)
8.
a(3)
3.
b(3)
7.
c(3)
10.
a(4)
4.
b(4)
8.
c(4)
12.
a
+
PROGRAM suma_arreglos
IMPLICIT NONE
!
INTEGER : : i
b
=
c
REAL, DIMENSION (4) : : a=(/ 1., 2., 3., 4./)
REAL, DIMENSION (4) : : b=(/ 5., 6., 7., 8./)
REAL, DIMENSION (4) : : c, d
!
! Elemento por elemento
DO i=1,4
c(i)= a(i)+b(i)
END DO
!
! Suma en forma conjunta todos los elementos de los arreglos
d= a+b
!
! Escribo los resultados
WRITE(*,*) “c”
DO i=1,4
WRITE(*,*) c(i)
END DO
WRITE(*,*) “d”, d
!
END PROGRAM suma_arreglos
Impresión
c
6.0
d
6.0
8.0
8.0
10.0
10.0
12.0
12.0
! La operación puede hacerse si y solo si ambos arreglos tienen la misma forma
(igual número de dimensiones y el mismo número de elementos en cada
dimensión, (igual rango e igual extensión))⇒ conforme
Los escalares son conformes con los arreglos:
REAL, DIMENSION (4) : : a=(/1., 2., 3., 4./), c
REAL : : b=10
c=b*a
El arreglo c será 10., 20., 30., 40.
También se puede realizar estas operaciones con funciones intrínsecas
elementales. Las más comunes:
ABS, SIN, COS, EXP y LOG
REAL, DIMENSION (4) : : a=(/-1., 2., -3., 4./), c
c= ABS(a)
El arreglo c será 1., 2., 3., 4.
Subconjunto de un arreglo
Para utilizar una sección del arreglo se especifican los índices :
inicio:fin:incremento
subíndice triple
Ej :
INTEGER, DIMENSION : : arre(/1, 2, 3, 4, 5, 6, 7, 8, 9, 10/)
El subconjunto arre( 1:10: 2)
arre(1), arre(3), arre(5), arre(7) y arre(9)
1, 3, 5, 7 y 9
inicio
valor del índice inicial del subconjunto
fin
valor del índice final del subconjunto
Incremento
incremento a través de los índices del arreglo.
Si falta:
inicio → 1
fin → fin del arreglo
incremento → 1
Ej:
INTEGER :: i=3, j=7
REAL, DIMENSION (10) :: a (/1., -2., 3., -4., 5., -6., 7., -8., 9., -10./)
a(:) → todos los elementos
a( i: j) → del tercer elemento al séptimo ( 3., -4., 5., -6., 7)
a(i: j: i) → del tercer elemento al séptimo saltando de a 3 (3., -6.)
a(i: j: j) → del tercer elemento al séptimo saltando de a 7 (3.)
a(i:) → del tercer elemento al final (3., -4., 5., -6., 7., -8., 9., -10)
a(j:) → del séptimo elemento al final (7., -8., 9., -10)
a(: : i) → todos los elementos saltando 3 (1., -4., 7., -10.)
Subindice vector especifica uno a uno los elementos del arreglo a ser usados
en el cálculo.
Ej:
INTEGER, DIMENSION (5): : vec =(/1, 6, 4, 1, 9/)
REAL, DIMENSION (10) : : a (/1., -2., 3., -4., 5., -6., 7., -8., 9., -10./)
a(vec ) → es el arreglo [1., -6., -4., 1., 9.]
Entradas y salidas
WRITE( *, *) a(1), a(2), a(3), a(4)
Con DO implícito
WRITE( *, *) (a(i), i=1,4)
Imprime los valores de a(1), a(2), a(3) y a(4)
En general:
WRITE( unidad , format) (var1, var2, …. Indice= icomienzo, ifin. incre)
READ ( unidad , format) (var1, var2, …. Indice= icomienzo, ifin. incre)
Dentro del write se pueden incluir tareas
Ej:
WRITE( *, * ) (i, 2*i, 3*i, i= 1,3)
Imprime 1 2 3 2 4 6 3 6 9
Ciclos anidados
WRITE(*,*) ((i, j, j= 1, 3), i= 1, 3)
Primero varia j y luego i
1
1
1
2
1
3
2
1
2
2
2
3
3
1
3
2
3
3
Los DO implícitos son muy importantes cuando se trabaja con arreglos que
tienen dos o mas dimensiones.
Descargar

Color