Structured Data Types

Date Types

• We have seen various data types

– Integer, Real, Character, Logical

• All these types define data values of different kinds

– 128, 4500, 1, 0 (Integer)

– 0.5E19, 28.0, 0.214141E2 (Real)

– hari,maithoo,cs101, fortran (character strings)

– .True., .False. (logical)

• The Data types define, besides values,

– operations, relations and intrinsic functions

• A summary given here - refer to books/manuals for details

Numerical Data Types

Constants: 127, - 456, 12.76, 56.7 E 10, - 0.12E-23

Note: decimal points in mantissa but not in exponent

no commas allowed 12,23,600

Operations: +,*,/,-

Relations: >,<,>=,<=,==,/=

Intrinsic Functions:

Real, Nint,Int, Abs, Mod, Exp,Log, Sign, Sin, Cos, Sinh,Cosh, …

Character Data Types

Constants: ABabDf, Fortran, CS101

Note: capital and small letters distinguished

Operations: //, (n:m)

Relations: equality operators, ==, /=

Other comparison operators: < , <=, >, >=

ASCII encoding: 8 bit encoding of characters

A is 65, B is 66, etc

a is 97, b is 98 etc

Lexicographic Ordering

Collating Sequence: order in which characters occur in

ASCII set

Relation over individual characters based upon the collating sequence order

eg. A < E, Z < a, d < s

How to compare strings?

– Dictionary ordering (Lexicographic ordering)

– eg. AAA < AAB, AAA < AAAA,

AAAA < AB

Intrinsic Functions: Trim, Len,

Logical Data Types

Constants: .true., .false.

Operations: .not., .and.,.or.,.equiv,

.nequiv.

Structured Data

• All these data types (except character) are atomic

– values are simple and non composite

– scalar data types

• Many real life entities are organized (or structured) collections of simpler data values:

– students, accounts, employees (records with constituent items)

– pack of cards, tables, vectors, matrices

– queues, stacks, graphs

• Referring to the constituent data values rather than the whole

– results in loss of abstraction and clarity

– cumbersome

Structured Data Types

• Modern PL enable design of rich set of structured data types to represent structured data

• They provide constructs using which complex and structured data types can be built from scalar types

• A PL provides

– fixed primitive types for representation of simple data value

– constructs for building organized collection from primitive types

• hence called user defined data types

Single Dimensional Arrays

• Array is one of the simplest and most often used structure

• Examples: Vectors, list of students ordered by roll

numbers, array of cars in a parking lot

• Array data type is provided to represent such data

• Typical array values are:

– (32, 45, 67, 100, 780) - integer array

– (4.50, 345.0E10, 28.25E-12) - real array

– (Fortran, Pascal, C, C++, ADA) - character array

– (.true., .false., .true., .false., .false., .true., .true.) –

logical array

Properties of Arrays

• All entries in an array are values of identical types

• The data values are of some type, called the base type

• An array can contain one or more number of entries

• Every entry is associated with an index

• By default, the index of the first entry is 1, that of second 2, etc

• The number of entries is called the size or length of the array

• Any entry can be accessed directly by indicating its index – hence called random access data structure

• Arrays are called single dimensional

Example

• Let MARKS be an array (32,24,49,20,0)

– base type of MARKS is integer

– size or length of the array is 5

– MARKS(5) is 0 while MARKS(2) is 24

• Let Planets = (Venus, Earth, Mars, Saturn, Uranus, Neptune, Pluto)

– base type is character

– length is 7

– Planets(4) is Saturn

Array Declarations

• Program Variables can store array values like any other basic values

• Typical declarations:

– Integer, Dimension(5) :: Marks

– Character(len=8), Dimension(7):: Planets

• base type and length mentioned in declarations

• The index of these arrays, also called as subscripts, start from 1 and end in the number specified

• The subscripts can start anywhere and end anywhere; they should be specified then

– Integer, Dimension(-8:10):: Students

– specifies the subscripts of Students to range from -8 to 10

Array References

• Arrays can be referred in statements either as a whole or individually

• Individual array elements are like any other variable of the base type

• They can appear anywhere where the variables can appear, eg.

– Students(2) = 5

– Marks(5) = Students(2) * 10

– Students(i) = Student(i+1)

– Passed(j) = .TRUE.

– Planets(k) = Jupiter

– if (Students(i) > 0) then

• Type matching same as variables of the base type

Whole array references

• The whole array variable can also appear on both rhs and lhs, eg.

– Planets = (/ Mars,Earth,Pluto,Neptune,Venus,Jupiter /)

– Marks = Students

• These are whole array assignments; the types of both lhs and rhs should match

• Types of two array valued expressions match provided

– they evaluate to arrays

– of the same size and base type

– subscript ranges may be different

• The same constant value can be assigned to all elements of an array

– Passed = .FALSE.

– All the array entries are assigned the value false; useful for initialization

Array Initialization

• Arrays can be initialized at declarations, eg.

– integer, dimension(10) :: a = (/ 0,1,2,3,4,5,6,7,8,9 /)

– initializes array a to (0,1,2,3,4,5,6,7,8,9)

• Implied do loop (Shorthand notation for loops) can be used for initialization, eg.

– a = (/ (2*i, i=1,10) /) ! i must be declared before use

– a= (/ (i,i, i = 1,10,2) /)

• a is 1,1,3,3,5,5,7,7,9,9

Reading/Writing of Arrays

• Arrays may be read or printed as a whole, eg.

– read *, a

– print *, a

• Values input/output on a single line

• Implied do loops may also be used, eg.

– read *, (a(i), i = 1,n)

– values of a(1) to a(n), read on one line

Array Sections

• Arrays can be referred as a whole, per entry or even in parts

• Parts of the arrays can be referred using sections, eg

– Given an array Ex declared as follows

integer dimension(100), Ex

– Ex(8:89:2) - part of the array

Ex(8),Ex(10),...,Ex(88)

– Ex(10:50) - references Ex(10),Ex(11),...,Ex(50)

– Ex(28::5) - refer to Ex(28),Ex(33),...,Ex(98)

– Ex(28:2) - null array

– Ex(1:100) - whole section, referred directly as Ex itself

Array Bounds

• Every array has bounds - lower and upper bounds

• The above array Ex has 1 as lower bound and 100 as upper bound

• Ex(i) is defined provided 1 <= i <= 100

• Any reference to Ex(-25) or Ex(111) is illegal and may produce unknown results

• A reference is illegal or not can be detected,in general, at run-time only

• Ex(j) exceeds bound or not depends on value of j - not known at compile time

• Fortran compiler provides the option of detecting (at run-time) of array index exceeding bounds

• If this option is on, it inserts code, which can produce run-time errors

• If off, you have the responsibility for illegal references

Operations on Arrays

• Array assignments involve expressions involving whole arrays

• Operations are defined over arrays depending upon the base type

• Operations are `lifted' from the base type

– arithmetic operations over real and integer arrays

– logical operations over logical arrays

• Operations apply `point wise' to the array entries

• Arrays involved should be of the same size

Example

integer, dimension(50) :: A, B

integer, dimension(51:100) :: C

read *, A, B ! reads 100 values (A followed by B)

C = 2*A + B + 5 ! C(i) = 2*A(i) + B(50+i) + 5

• operation is applied to corresponding elements in “parallel”

• similar to component wise vector addition

• other arithmetic operations (except **) applied similarly

• scalar operation performed on each element

Relational Operators

• whole array or array sections can be compared using relational operator

• As usual, type and size constraints need to respected

• Comparison to scalars also possible

• Example:

integer, dimension(50) :: a, b

logical, dimension(50) :: c

c = (a < b) .and. ( a > a(1))

! c(i) is .true. iff a(i) < b(i) and a(i) > a(1), 1<=i <=50

• similarly for other relational operators

Intrinsic Functions

• Many intrinsic functions available for arrays

• `Lifting' of Intrinsic functions of base type to arrays

• functions of integers and reals can be applied to integer or real arrays

• functions applied pointwise - to all elements separately

– size(a): number of elements in array a

– maxval(a) and minval(a)

• maximum and minimum value in integer or real array a

Intrinsic Functions (contd.)

• sum(a), product(a)

– sum or product of elements of integer or real array a

• dot_product(a,b)

– dot product of two vectors of same size

• Array operations and intrinsic functions makes program more readable

• More efficient also, as operations can be done in parallel