Loop Construct
Control flow constructs

•	Control Flow constructs seen so far
–	sequential flow
–	two-way or multi-way branching flow

•	These constructs are not enough!

Sum of Square roots
•	Problem: Compute sum of square roots of numbers from 1 to 5
•	One solution:
           program sum_sqroot
           implicit none 
           real :: sum,sum1,sum2,sum3,sum4
           sum1 = sqrt(1.0)
           sum2 = sum1 + sqrt(2.0)
           sum3 = sum2 + sqrt(3.0)
           sum4 = sum3 + sqrt(4.0)
           sum = sum4 + sqrt(5.0)
            print *, sum
           end program
Summing Square roots
•	What are the problems with this solution?

•	No need for so many sum variables; use instead 
			
                             sum = sum + sqrt(..)

•	what if 10, 20 or 100 numbers to be added?
–	code repetition possible but undesirable

•	what if an unknown numbers (given as input) to be added?
–	code repetition not possible at all
 Looping 
•	Loop constructs are designed to solve the above problems

•	Loop constructs enable execution of same piece of code a specified number of time

•	Two kinds of loop constructs:
–	Controlled loop
–	Uncontrolled loop

•	The above problem can be solved using controlled loop
Example
     Program sum_sqrt
implicit none
    real :: x,sum

sum = 0.0
!initialization needed.  why? see the loop

!looping construct
do i = 1,5 !loop body executed five times 
          x = real(i) 
     sum = sum + sqrt(x) !each time i incremented by 1
    end do
print *, sum
end program
Controlled Loop Construct
•	General form:

     do var = init, fin, inc

                 loop_body

     end do

•	 var, called control variable, must be integer
•	 init,fin,inc are integer expressions
•	 inc must be non-zero, can be negative and default value is 1
•	 loop_body must not modify value of var
 Iteration
•	loop_body is executed repeatedly
•	each execution is called an iteration
•	initially, var = init
•	after every iteration inc is added to var
•	loop is terminated when value of var exceeds fin (or smaller than fin)
•	Loop body is executed a fixed number of times
•	number of iterations may depend on values of variables
Controlled Loop
•	number of iterations (for +ve inc)
		iter-count = (fin-init+inc)/inc
•	iter-count is computed when the do statement is first encountered

•	if  iter-count <= 0 , loop is not executed

•	if iter-count > 0, loop_body is executed, iter-count is decremented by 1 and var is incremented in every iteration

•	loop terminates finally when iter-count <= 0, i.e., the control flows to the statement immediately following the loop statement
Controlled Loop
•	iter-count is computed when the do statement is first encountered
•	Its value depends upon the values at that point
•	values of init, fin, inc should not be changed inside the loop
•	var is incremented by the value of inc in every iteration
•	It is assigned the value init when do is first encountered
Cycle and Exit statements
•	loop_body can contain two special statements

•	Cycle
–	It terminates the current iteration and the next iteration is started, if there is one

•	Exit

–	This terminates the loop moving the control to the statement following the loop
Example
•	Read a line of characters, 
•	Count the number of e occurring in the line 
•	Replace every a by #
•	Lines of length 80 or ended by $ sign
program e_count

    character(len=80) :: line
integer :: counter,index
read *, line
index=1
counter = 0
do index = 1, 80
     if (line(index:index) = = "$“) exit  !exit the loop if end of line  
          if (line(index:index) == "e“) then
         counter = counter +1
         cycle   !skip the rest of the loop
     endif
     if (line(index:index) == "a“) then
        line(index:index) = "#"
     endif
end do
print *, counter, line

Uncontrolled Loop
•	The controlled loop is a simple loop computation

•	The loop body executed for a number of times that is fixed a priori or at least prior to the execution of the do statement

•	Many times
–	repeat a computation till certain condition holds
–	No upper bound on the number of iterations exists

•	More general loops are required for describing these

•	Uncontrolled loops are meant for this
Another Example
•	Similar to the earlier problem
•	 there is no upper bound on the length of the line
•	 all lines should be terminated by $
       index =0
       do !uncontrolled loop
           index = index +1
       if (line(index:index) == "$“) exit
           if (line(index:index) == "e" ) then
           counter = counter +1
           cycle
       endif
           if (line(index:index) == "a" ) then
           line(index:index) = "#"
       endif
       end do

Uncontrolled loop
•	Controlled loop does many things implicitly
–	control variable updation, exit condition checking
•	In uncontrolled version, these have to be done explicitly
•	Termination is guaranteed in the controlled one
•	Termination need to be ensured in the uncontrolled one
•	explicit inclusion of exit statements is required
•	In e_count1, for termination of the loop, the end of line condition is required
•	In e_count, the loop terminates automatically after reading at most 80 characters
•	Controlled loop is safe but less general
General Form
         do
            loop_body
	      end do

•	Any number of exit statements can occur in the loop_body

•	At least one required

•	Possibility of non termination, in any case
Loops
•	Loop is an important construct
•	Most programs will involve loops 
•	Loops encode potentially unbounded computations
•	Mastering loops is important
•	Loops cause non termination, a most common programming error
•	Correct programs should be terminating
•	Every loop is associated with a condition called loop invariants
•	Loop invariant holds at the beginning of every iteration
Nested Loops
•	Like many other constructs loops can also be nested

       do

               statement1
           do
               statement2
           end do
           statement3

        end do

•	Note that `inner do' ends before the `outer do‘
•	Exit and cycle in statement2 refers to the inner loop 
•	Exit and cycle in statement1 and statement3 refer to the outer loop
 Labeling loops
•	For ease of understanding loops can be labeled:
  outer: do
      statement1
      inner: do
                  statement2
                end do inner
      statement3

   end do outer

•	exit and cycle statements can name the loop
   exit outer, cycle outer

•	unnamed statements refer to the innermost enclosing loops
Labeling control constructs
•	Like loops all other constructs can be labeled

•	Examples:

   cond1: if (test1) then 
                  statement
           elseif (test2) then cond1
                  statement
           else cond1
                  statement
           endif cond1

•	Similarly for select case construct