Arrays

Introduction

IntroductionIn 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 2 3 4 5 6

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 arrayarray 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 computer’s 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)+1print*,x(5)

The array concept

A

1

2

3

4

-1 0 1 2 3

A20

A31

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 ) = 3

 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 ) : : value

read *, value

read *, value(3)

real, dimension(5) :: p, qinteger, dimension(4) :: rprint *, p, q(3), rread *, p(3), r(1), qprint *, p, q (3), q (4), rprint *, q (2)

! displays the value in the 2nd location of the array “q”

print *, p! displays all the values storen in the array “p”

Examples

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 useda(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...

.real, dimension(20) :: a, b, c..a = b*c

do i = 1, 20 a(i) = b(i)*c(i)end do

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.

Exampleinteger, dimension ( 4 ) : : a, b

integer, dimension ( 0 : 3 ) : : c

integer, dimension ( 6 : 9 ) : : d

 

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 a = (/ 6, 8, 10, 12 /)

d = 2 * abs ( c ) + 1 ! will result d = (/ 3, 7, 11, 15 /)

d(6) d(7) d(8) d(9)

Intrinsic procedures with arrays

Elemental intrinsic procedures with arraysarray_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 consecutive subscripts. The value of stride must not be “zero”.

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

:

Examplereal, 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).

Exampleinteger, dimension ( 10 ) : : a

integer, dimension ( 5 ) : : b, i

integer : : j

 

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-arrayswork = ( / 3, 7, 2 /)

print *, work (1), work (2), work (3)

! or

print *, work ( 1 : 3 )

! or

print *, work ( : : 1 )

! or

integer : : i

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 ) : : a

integer, dimension ( 3 ) : : b

.

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

If we wish to use an array as an argument to a procedure, it is needed to know the size or shape of the actual arguments used. 

On the other hand, as mentioned before 

• a procedure does not need to know the details of the calling program unit

• the program unit called, in turn, also does not need to know anything about the procedure except the information about its arguments which form part of the procedure’s interface.

In fact, if an array is a procedure dummy argument, it must be declared in the procedure as an assumed-shape array. 

An assumed-shape array is a dummy argument array wose shape, as its mame implies, is not known but which assumes the shape as that of any actual argument that becomes associated with it. 

The array specification for an “assumed-shape array” can take 2 forms as can be seen below , where the 2nd form is equivalent to the 1st with a “lower bound = 1” and on the other hand, the upper bound in both cases will only be established on entry to the procedure and will be whatever value is necessary to ensure that the extent of dummy array is the same as that of the actual array argument :

* ( lower bound : )

Arrays and procedures

Explicit-shape array: no freedom! Assumed-shape array

– If an array is a procedure dummy argument, it must be declared in the procedure as an assumed-shape array!

Arrays and procedures

Calling program

Procedure

Assumed-shape

Explicit-shape

Arrays and procedures

Example

main program unit: real, dimension ( b : 40 ) : : a

subprogram: real, dimension ( d : ) : : x

x ( d ) ---------------------- a ( b )

x ( d + 1 ) ---------------------- a ( b + 1 )

x ( d + 2 ) ---------------------- a ( b + 2 )

x ( d + 3 ) ---------------------- a ( b + 3 )

.

.

Examplemain program unit:

real, dimension ( 10 : 40 ) : : a, b

.

call array_example_l (a,b)

subroutine array_example_1 ( dummy_array_1, dummy_array_2)

real, intent (inout), dimension : : dummy_array_1, dummy_array_2

.

.

subprogram:

Examplemain program unit

real : : p (-5 : 5 ), q ( 100 ) . call array_example_2 ( p, q )

. .

 subprogram subroutine array_example_2 ( dummy_array_1, dummy_array_2)real, intent (inout), dimension : : dummy_array_1, dummy_array_2)

Exampleinteger , dimension ( 4 ) : : section = (/ 5, 1, 2, 3 /)

real , dimension ( 9 ) : : a

call array_example_3 ( a ( 4 : 8 : 2 ), a ( section ) )

dummy_array_1 = (/ a (4), a (6), a (8) /) 

dummy_array_2 = (/ a (5), a (1), a (2), a (3) /) 

dummy_argument_2 (4) dummy_argument_2 (3)

dummy_argument_2 (2)

dummy_argument_2 (1)

ExamplePROBLEM : Write a subroutine that will sort a set of names into alphabetic order.

İnitial order 7 1 8 4 6 3 5 2

After 1st exc. 1 7 8 4 6 3 5 2

After 2nd exc. 1 2 8 4 6 3 5 7

After 3rd exc. 1 2 3 4 6 8 5 7

After 4th exc. 1 2 3 4 6 8 5 7

After 5th exc. 1 2 3 4 5 8 6 7

After 6th exc. 1 2 3 4 5 6 8 7

After 7th exc. 1 2 3 4 5 6 7 8

 

Array-valued functionsAs is well known, arrays can be passed to procedures as arguments and a subroutine can return information by means of an array.

 

It is convenient for a function to return its result in the form of an array of values rather than as a single scalar value ------------ array-valued function, as can be seen below :

 

  function name ( ……………………..) result (arr)

real, dimension ( dim ) : : arr

.

.

end function name

Array-valued functions

A function can return an array Such a function is called an

array-valued function

function name(…..) result(arr)real, dimension(dim) :: arr...

end function nameExplicit-shape

ExampleConsider a trivial subroutine that simply adds 2 arrays together, returning the result through a third dummy argument array.

subroutine trivial_fun ( x, y ) result (sumxy)

 

real, dimension ( : ) , intent (in) : : x, y

real, dimension ( size (x) ) : : sumxy

 

end subroutine trivial_fun

Example

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