Conditional
Control Flow Constructs
Sequential Control Flow
•
Execution order follows the textual
order
•
straight line flow
•
Many simple problems can not be solved
only with such sequential flow
•
Here is an example
•
Problem: Computation of a maximum of two numbers
Solution
Program
max2
Implicit
none
integer
num1,num2, max
read
*, num1,num2
if
(num1 > num2) then
!control
comes here if num1 > num2
max = num1
!control
jumps to the end of the if statement (endif)
else !control comes here if num1 < = num2
max = num2
endif
print
*, max
end
program max2
Another Problem
•
Input
two numbers
•
Compute
the quotient and remainder of the bigger
number divided by the smaller number
•
The
numbers are input in unknown order
Solution
Program
Quo_Rem1
Implicit
none
integer
num1,num2, quotient, remainder
read
*, num1,num2
if
(num1 > num2) then
quotient = num1/num2 ! / is integer division
remainder = num1 – (quotient * num2)
else
quotient = num2/num1
remainder = num2 – (quotient * num1)
endif
print
*, quotient, remainder
end
program Quo_Rem1
Problems with the solution
What
happens if num1 or num2 is negative?
–
Problem Specification needs to be
clarified
What
if one of the numbers is 0?
–
Divide by zero leads to overflow
–
Should be avoided
–
need to test it before dividing
Program Quo_Rem2
integer:: num1,num2, temp, quotient, reminder
read *, num1,num2
if (abs(num1) < abs(num2)) then
! abs function returns the absolute value
temp = num2
num2 = num1 ! swapping the contents
num1 = temp ! of num1 and num2
end if
if (.not.(num2 == 0)) then
!num2 contains a nonzero value
quotient = num1/num2
remainder = num1 - quotient * num2
print *, quotient, remainder
else
print *,"cannot divide! one of
the numbers is zero"
end if
The program Quo_Rem2
•
The body of if-then-else is simpler
•
The else clause is missing
•
Complex conditions can appear in the
if-condition
•
Successive if-statements allowed
Another Problem
•
%Nesting of ifs
Problem: Compute Maximum of three numbers
Solution: ?
A Strategy
Let
num1,num2,num3 store the three numbers.
•
Compute the maximum of num1 and num2.
Name it max12
•
Compute the maximum of num2 and num3.
Name it max23
•
Compute the maximum of max12 and max23,
which is the maximum of num1.num2,num3
Another Strategy
•
Compute the maximum of num1 and num2,
say max12
•
Compute the maximum of max12 and num3,
which is the required maximum?
Which
is the better strategy?
The latter - less number of steps
Now we are ready to write the program
Program max3
integer num1,num2,num3,max
read *, num1,num2,num3
if (num1 > num2) then
if (num1 > num3) then !num1 >
num2,num1 > num3
max = num1
else ! num1 > num2 and num1 <=
num3
max = num3
endif
elseif (num2 > num3) then !num1 <=num2 > num3
max = num2
else ! num1 <=num2<=num3
max = num3
endif
print *, max
end program max2
Nested If statements
•
If statements in the then clause or
else clause
•
elseif construct
•
Arbitrary series of nesting permitted
•
elseif and else corresponds to the
innermost if for which the endif is yet to come
•
if
and endif are like left and right brackets.
Further Observations
•
else clause can be missing
•
endif can be dropped if there is only
one statement
•
long series of ifs can be confusing
(at most 20 levels allowed)
•
indentation improves readability
•
use indentation and comments
If conditions
•
Control flow branches in conditional
statements
•
Branching decided by evaluating the
conditions
•
conditions are expressions of a new
type called LOGICAL
•
Examples:
(x
> 0), (z == 1), .NOT. (num == 2)
•
All these involve relational
operators: >,==
•
Relational operators are defined over
many data types to compare values
Relations over Arithmetic
•
Given e1,e2 expressions over integer
(or real),
–
e1 == e2 ( equality )
–
e1
< e2 ( less than )
–
e1 <= e2 ( less than or equal )
–
e1
> e2 ( greater than )
–
e1 >= e2 ( greater than or equal )
–
e1
/= e2 ( not equal )
LOGICAL VARIABLES
•
Fortran 90 has a built in LOGICAL DATA TYPE
•
Expressions involving relational operators are of type
LOGICAL
•
Variables can be declared to have type LOGICAL
•
Declarations:
LOGICAL :: found, goodness
•
Logical variables assume just two values
–
.TRUE., .FALSE.
•
They can be used in if conditions, eg.
–
if
(found) then stop
–
if (goodness) then x = 0
LOGICAL OPERATORS
•
Operators over logical type values
•
They are
.not., .and., .or., .eqv., .neqv.
•
.not. p is .true.
iff p is .false.
•
p .and. q is
.true. iff both p and q are .false.
•
p .or. q is .true.
iff one of (or both) p,q .true.
•
p .eqv. q is .true.
iff both p and q has the same
truth
value
•
p .neqv. q is .true. iff
both p and q have different
truth
values
Operator precedence
•
A general logical expression may include arithmetic,
relational and logical operators
•
operator precedence defined to specify order of evaluation
•
arithmetic operators are evaluated first followed by
relational operators
•
logical operators are evaluated last
•
precedence amongst logical operators
.not. , .and. , .or. ,
.eqv. and .neqv.
If condition
•
The condition in an `if' statement is
a logical expressions, eg.
1.
if ((a>=b) .eqv. x) then ...
-
a,b arithmetic variables, x logical variable
2. if (((rate*prin)> 100) .AND. .NOT.
(closed)) then ...
Quadratic Equation Solving
•
Roots of quadratic equation:
ax2 + bx + c = 0
•
Can have
–
exactly one root
–
two real roots
–
two complex conjugate roots
•
Type of roots depends upon the
discriminant
(b2 - 4ac)
A Program to solve the equation
program quadratic
implicit none
real :: a, b, c, disc, x_r, x_r1, x_r2, x_im1, x_im2
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 nearly zero
print *, "double real
root", x_r
elseif ( disc > 0 ) then ! two distinct real roots
disc = sqrt(disc)/(2.0*a)
x_r1 = x_r + disc ! disc temporary variable
x_r2 = x_r - disc
print *, “two real roots”, x_r1, “ and”,
x_r2
else ! disc is negative, complex
conjugate roots
x_im1 = sqrt(-disc)/(2.0*a)
x_im2 = - x_im1
print *, "complex conjugate
roots", x_r, "+", &
x_im1, "i and", x_r, "-", x_im2,
"i"
endif
endif
end
program quadratic
Comparison of Real Numbers
•
instead of disc == 0.0 we have checked
abs(disc) < eps
as condition for double root
•
misleading results occur
otherwise, eg.
0.1x2 - 0.3 x + 0.225 = 0
•
has 1.5 as double root
•
errors in representation give disc
> 0.0
•
roots obtained are 1.5004526 and 1.4995474
Comparing Real Numbers
•
double roots undesirable in many
applications
•
two roots close to each other may be
treated as double
•
if abs(disc) is small, roots are close
•
a parameter eps (epsilon) is usually
used for comparing reals
•
two reals are treated as equal if
absolute value of difference is < eps
Quadratic Equations
•
numerical problems in solving quadratic equations by this
method
•
if two roots differ by orders of magnitude, smaller root
cannot be found accurately
x2 – 1000.001x + 1.0 = 0
•
two real roots 1.0000000e+03, 1.0070801e-03
•
what happens if actual roots are 1.0e+4 and 1.0 e-4
?
Strategies
•
Strategies are
high level descriptions of computations
•
They are
intuitive and understandable to humans
•
Easier to write,
analyze, explore and change compared to programs
•
Develop
strategies first
•
Only when a
strategy is finalized, write the programs
•
Precise
statement of strategies is called Algorithm
Algorithm
•
Is a sequence of steps
•
Each step is precise and unambiguous to people
•
Each step is a high level instruction, that can be carried
out by mechanically
•
Each step can be
translated into `low level' programs
•
Is at a much higher level than HLL itself
Analyzing algorithms
•
Before writing the program, analyze and choose the efficient
algorithm
•
Metrics for algorithm
–
Number of steps
–
Complexity of steps
•
number of primitive operations
(like addition, multiplication, comparison)