Arrays

Introduction

Introduction
In scientific and engineering computing, it is very common to
need to manipulate ordered sets of values, such as vectors and
matrices.
There is a common requirement in many applications to repeat
the same sequence of operations on successive sets of data.

In order to handle both of these requirements, F provides

extensive facilities for grouping a set of items of the same type
into an array which can be operated on

either as an object in its own right

or by reference to each of its individual elements.

The array concept

1
A

The array concept

A set with n (=6) object, named A

In mathematical terms, we can call A, a
vector
And we refer to its elements as
A1, A2, A3,

The array concept

In F, we call such an ordered set of

related variables an array
Individual items within an array
array elements
A(1), A(2), A(3), , A(n)

Array Concept
In all the programs we have used one name to refer to one
location in the computers memory.
It is possible to refer a complete set of data obtained for example
from repeating statements, etc.

To do this is to define a group called array with locations in the

memory so that its all elements are identified by an index or
subscript of integer type.
An array element is designated by the name of the array along
with a parenthesized list of subscript expressions.

The array concept

Subscripts can be:

x(10)
y(i+4)
z(3*i+max(i, j, k))
x(int(y(i)*z(j)+x(k)))
x(1)=x(2)+x(4)+1
print*,x(5)

The array concept

-1

2
3

A31

A20
2

Array declarations
type, dimension(subscript bounds) ::
list_of_array_names
type, dimension(n:m) :: variable_name_list

real, dimension(0:4) :: gravity, pressure

integer, dimension(1:100) :: scores
logical, dimension(-1, 3) :: table

Examples for Shape Arrays

real, dimension ( 0 : 49 ) : : z
! the array z has 50 elements
real, dimension ( 11 : 60 ) : : a, b, c
! a,b,c has 50 elements
real, dimension ( -20 : -1 ) : : x
! the array x has 20 elements
real, dimension ( -9 : 10 ) : : y
! the array y has 20 elements

Array declarations

Up to 7 dimensions
Number of permissible subscripts:
rank
Number of elements in a particular
dimension:
extent
Total number of elements of an array:
size
Shape of an array is determined by its rank
and the extent of each dimension

Array constants and initial values

Since an array consists of a number of array elements,
it is necessary to provide values for each of these elements by
means of an array constructor .
In its simplest form, an array constructor consists of a list of values
enclosed between special delimiters :

the first of which consists of the 2 characters : ( /

the second of the 2 characters : / )

( / value_1, value_2, ., value_n /)

Examples
integer, dimension ( 10 ) : : arr

arr = (/ 3, 5, 7, 3, 27, 8, 12, 31, 4, 22 /)

arr ( 1 )

arr ( 5 )

= 27

! the value 27 is storen in the 5th location of the array arr

arr ( 7 )

= 12

arr ( 10 ) = 22

Array constructors

(/ value_1, value_2, /)

arr = (/ 123, 234, 567, 987 /)

Regular patterns are common:

implied do
(/ value_list, implied_do_control /)

arr = (/ (i, i = 1, 10) /)

arr = (/ -1, (0, i = 1, 48), 1 /)

Initialization

You can declare and initialize an array

at the same time:

integer, dimension(50) :: my_array = (/ (0, i = 1, 50) /)

Input and output

Array elements treated as scalar

variables
Array name may appear: whole array
Subarrays can be referred too

EXAMPLE :
integer, dimension ( 5 ) : :
read *, value
read *, value(3)

value

Examples
real, dimension(5) :: p, q
integer, dimension(4) :: r
print *, p, q(3), r
read *, p(3), r(1), q
print *, p, q (3), q (4), r
print *,
q (2)
! displays the value in the 2nd location of the array q

print *,

! displays all the values storen in the array p

Using arrays and array elements...

The use of array variables within a loop , therefore,
greatly increases the power and flexibility of a program.
F enables an array to be treated as a single object in
its own right, in much the same way as a scalar object.
Assignment of an array constant to an array variable will
be performed as is seen below :
array_name = (/ list_of_values /)
array_name = (/ value_1, value_2, .., value_n /)
An array element can be used anywhere that a scalar
variable can be used
a(2) = t(5) - t(3)*q(2)

a(i) = t(j) - f(k)

Using arrays and array elements...

An array can be treated as a single

object
Two arrays are conformable if they have
the same shape
A scalar, including a constant, is
conformable with any array
All intrinsic operations are defined between
two conformable objects

Using arrays and array elements...

Arrays having the same number of elements may be
applied to arrays and simple expressions. In this case,
operation applied toan array are carried out
elementwise.

real, dimension(20) :: a, b, c
.
.
a = b*c
do i = 1, 20
a(i) = b(i)*c(i)
end do

Example
integer, dimension ( 4 ) : :

a, b

integer, dimension ( 0 : 3 ) : :

integer, dimension ( 6 : 9 ) : :

a = (/ 1, 2, 3, 4 /)

b = (/ 5, 6, 7, 8 /)
c = (/ -1, 3, -5, 7 /)

c(0) c(1) c(2) c(3)

a = a + b !

will result

d = 2 * abs ( c ) + 1 !

a = (/ 6, 8, 10, 12 /)
will result

d = (/ 3, 7, 11, 15 /)
d(6) d(7) d(8) d(9)

Intrinsic procedures with arrays

Elemental intrinsic procedures with

arrays
array_1 = sin(array_2)
arr_max = max(100.0, a, b, c, d, e)

Some special intrinsic functions:

maxval(arr)
maxloc(arr)
minval(arr)
minloc(arr)
size(arr)
sum(arr)

Sub-arrays

Array sections can be extracted from a parent

array in a rectangular grid usinf subscript
triplet notation or using vector subscript
notation
Subscript triplet:
subscript_1 : subscript_2 : stride

Similar to the do loops, a subscript triplet defines an ordered

set of subscripts
beginning with subscript_1,

ending with subscript_2 and

considering a seperation of stride between the

subscripts. The value of stride must not be zero.

consecutive

Sub-arrays

Subscript triplet:
subscript_1 : subscript_2 : stride
Simpler forms:
subscript_1 : subscript_2
subscript_1 :
subscript_1 : : stride
: subscript_2
: subscript_2 : stride
: : stride
:

Example
real, dimension ( 10 ) : :

arr

arr ( 1 : 10 )
! rank-one array containing all the elements of arr.

arr ( : )
! rank-one array containing all the elements of arr.

arr ( 3 : 5 )
! rank-one array containing the elements arr (3), arr(4), arr(5).

arr ( : 9 )
! rank-one array containing the elements arr (1), arr(2),., arr(9).

arr ( : : 4 )
! rank-one array containing the elements arr (1), arr(5),arr(9).

Example
integer, dimension ( 10 ) : :

integer, dimension ( 5 ) : :

b, i

integer : :

a = (/ 11, 22, 33, 44, 55, 66, 77, 88, 99, 110 /)
i = (/ 6, 5, 3, 9, 1 /)
b = a ( i ) ! will result

b = ( 66, 55, 33, 99, 11 /)

a ( 2 : 10 : 2 ) ! will result

a = ( 22, 44, 66, 88, 110 /)

a ( 1 : 10 : 2 ) = (/ j ** 2, ( j = 1, 5 ) /)
! will result

a = ( 1, 4, 9, 16, 25 /)

a(1) a(3) a(5) a(7) a(9)

Type of printing sub-arrays

work = ( / 3, 7, 2 /)
print *, work (1), work (2), work (3)
! or
print *, work ( 1 : 3 )
! or
print *, work ( : : 1 )
! or
integer
do

: :

i = 1, 3, 1

print *, work (i)

end do
! or another example
print *, sum ( work (1: 3) )
! or another example
print *, sum ( work (1: 3 : 2) )

Type of INPUT of sub-arrays

integer, dimension ( 10 ) : :

integer, dimension ( 3 ) : :

.
b = a(4:6)

! b (1 ) = a (4)
! b (2 ) = a (5)
! b (3 ) = a (6)

.
a(1:3) =0

! a(1) = a(2) = a(3) = 0

a(1::2)=1

! a(1) = a(3) =.= a(9) = 1

a(1::2)=a(2::2) + 1

! a(1) = a(2) +1
! a(3) = a(4) +1
! a(5) = a(6) +1

! etc.

PROBLEM : Write a function that takes 2 real arrays as its arguments

returns an array in which each element is the maximum of the 2
corresponding elements in the input array
function max_array ( array_1, array_2 )

result (maximum_array)

! this function returns the maximum of 2 arrays on an element-by- element basis

! dummy arguments

real, dimension ( : ) , intent (in) : : array_1, array_2

! result variable

real, dimension ( size (array_1) ) : : maximum_array

! use the intrinsic function max to compare elements

maximum_array = max ( array_1, array_2)

! or use a do-loop instead of the intrinsic function max to compare elements

! do i = 1, size (array_2)
! maximum_array ( i ) = max ( array_1 ( i ), array_2 ( i ) )
! end do
end function

max_array

Do following problems for practice;

7.8
7.10