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