Structures or Derived Types

Real Life Objects

• Often structured

– Students, Employees, Cars, Accounts, Cricket matches, flats etc

• contain heterogeneous sub-objects

– Students

• Name (string),

• Age (integer in [15, 65],)

• Height (real),

• CPI (real number in [1,10])

– Car

• Weight (Real), Volume (Real),

• Make (String), Seating capacity(Integer) ,

• Year of make (integer)

Arrays

• Two Structured Data Types

• Arrays and Character strings

– Both are homogeneous:

• components are of identical type

– Accessing a component through indices

• not very natural

• More natural data types desirable

Derived Data Types

• Fortran's solution to representing general structured data

• Heterogeneous collection of data values

• Components identified directly by names rather than indices

• Generalized random access

• Derived data type objects called structures (in C ) and Records (Pascal)

Example

Type :: Cricketer

Character(len=25) :: Name
Integer :: Age
Real :: Height
Character(len=10) :: Country
logical :: in_action
Real :: ave_score

logical :: bowler

end type Cricketer

Structure variables

• Variables declared to be of a derived type

• Similar syntax used, eg.

– Type (Cricketer):: indian_top_scorer_01,

england_captain_99,

aussie_keeper_74

– Type (Cricketer), Dimension(15):: Indian_Team_02

• The latter is an array of structures or records

Initialization

Indian_top_scorer_01 = Cricketer("Tendulkar", 29, 5.2,

"India", .true. ... )

England_captain_02 = Cricketer("Hussain", 24, 5.6,

"England", .true. , ... )

• Structure Constructor operation(inspired by C++)

Accessing the Components

• The components of a structure (a variable of derived type) can be accessed by the names

top_scorer%height

captain%ave_score

Indian_Team_02(i)%ave_score

• Each of these is like a variable of appropriate type

• can appear wherever such variables can occur

– top_scorer%height = 5.

– if (captain%ave_score > 25) then

– top_scorer%ave_score = …

– Int(captain%ave_score) + 26

– Indian_Team_02(i)%ave_score <

Eng_Team_02(i)%ave_score

Structure inside structure

• Components can be intrinsic types or even other derived types

Type:: team_pair
character(len=10):: team1
character(len=10):: team2
end type team_pair

Type:: match
type(team_pair):: teams
Integer:: date
Character(len=10):: ground
Character(len=10):: country
end type match

Type:: cricketer
...
type(match):: top_score_match
...
end type cricketer

Component Selection

• Any component can be selected using series of component selectors

Eg.

eng_captain%topscore_match%ground = “Lords”

• Recursive Structures

– One of the component can be of the parent type itself!

• More on this later

Program structure

Type:: cricketer
Character(len=15):: name,country
real:: average
integer:: top_score
end type

type(cricketer), dimension(15):: natwest_series_team
character(len=15):: player
real:: average
integer:: i
read *, natwest_series_team
read *, player
do i = 1, 15
if (trim(natwest_series_team(i)%name) == player) then
average = natwest_series_team(i)%average
print *, average
exit
endif

end do

Complex Data Types

• Complex data types can be defined as structured data types

type :: Compx
real:: re_part
real:: im_part
end type Compx

type(Compx):: xyz

• But direct support is available in Fortran 90

• Complex data type is an intrinsic type

Complex:: a1 = (3.1410, - 2.3456)

• declares a1 to be of type complex with given real and imaginary parts

Accessing components

• Complex numbers can be read or written component-wise
complex:: a1
read*, a1

• requires input to be (2.345, 6.7890)

• Print command also outputs in the same way

• To assign a variable, use

a1 = complex(a,b)

• a1 will get the value (a,b)

• Kind parameter is an optional parameter

Intrinsic Functions

• Real(), Int() - throws the imaginary part and converts the real part to real or integer data types

• Aimag() - converts the imaginary part to a real number

• Cabs(c) - absolute value of c

= sqrt(a^2 + b^2)

Example

program quadratic
implicit none
real :: a, b, c, disc, x_r
complex:: x_c1,x_c2 = (0.0, 0.0)
real, parameter :: eps = 1.0e-6
read *, a, b, c

if (a == 0.0) then
! a is 0, not a quadratic equation
print *, "equation is not quadratic"
else
disc = b*b - 4.0*a*c
x_r = -b/(2.0*a)
if ( abs(disc) < eps ) then
! discriminant is nearly zero
print *, "double real root", x_r
else
x_c1 = (x_r + Sqrt( Cmplx(disc,0.0))/(2.0*a))
x_c2 = (x_r - Sqrt( Cmplx(disc,0.0))/(2.0*a))
print *, Real(x_c1),"+ i", Aimag(x_c1)
print *, Real(x_c2),"- i", Aimag(x_c2)
endif
endif
end program quadratic