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