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 OrderingCollating Sequence: order in which characters occur in ASCII setRelation 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