# Looping Constructs

The while and for statements provide looping control in ALADDIN's problem solving procedures. The break statement forces an early exit from a looping construct.

### THE while LOOPING CONSTRUCT

Syntax : The while statement has the syntax :

```    while ( boolean expression ) {
statement 1 ;
statement 2 ;
......
statement N ;
}
```

The statements 1 through N will be executed repeatedly while the boolean expression evaluates to "true."

Example 1 : The script

```    while ( 1 ) {
print " x = ", x ,"\n";
}
```

contains an infinite loop that generates the output

```    x =      1 ksi
x =      1 ksi
x =      1 ksi

.... and on forever ....
```

Example 2 : Looping constructs are essential for the efficient generation of finite element meshes. Suppose, for example, that we need to generate a line of nodal coordinates. The script

```    x = 0 ft;
while( x <= 10 ft ) {
print " x coord = ", x , "\n";
x = x + 2 ft;
}
```

generates the output

```    x coord =          0 ft
x coord =          2 ft
x coord =          4 ft
x coord =          6 ft
x coord =          8 ft
x coord =         10 ft
```

Example 3 : The coordinates in a two-dimensional finite element mesh can be generated with nested while loops. For example, the script:

```    node = 0; y = 0 ft;
while( y <= 9 ft ) {
x = 0 ft;
while( x <= 6 ft ) {
print " coord ", node, "[x,y] = [", x, y, "]\n";
node = node + 1;
x = x + 2 ft;
}
y = y + 3 ft;
}
```

generates 15 lines of output. An abbreviated summary is:

``` coord          0 [x,y] = [         0 ft          0 ft ]
coord          1 [x,y] = [         2 ft          0 ft ]
coord          2 [x,y] = [         4 ft          0 ft ]
coord          3 [x,y] = [         6 ft          0 ft ]
coord          4 [x,y] = [         0 ft          3 ft ]

..... lines of output removed .....

coord         14 [x,y] = [         4 ft          9 ft ]
coord         15 [x,y] = [         6 ft          9 ft ]
```

### THE for LOOPING CONSTRUCT

Syntax : The for statement has the syntax :

```    for ( initial statements; boolean expression; increment statements ) {
statement 1 ;
statement 2 ;
......
statement N ;
}
```

The four steps of for-loop operation are:

• Step 1 : Zero or more initial statements are executed.
• Step 2 : The boolean expression is evaluated. Statements 1 through N will be executed when the boolean expression evaluates to true. Otherwise, "exit from" the for looping construct.
• Step 3 : Zero or more increment statements are executed.
• Step 4 : Return to Step 2.

Example 4 : The script of code

```    for( x = 0 ft; x <= 9 ft; x = x + 3 ft ) {
print "x = ", x, "\n";
}
```
generates the output
```    x =          0 ft
x =          3 ft
x =          6 ft
x =          9 ft
```
and demonstrates behavior in a basic for loop construct.

Example 5 : The initial and increment statement blocks may contain multiple statements, separated by commas. In the script

```    for( x = 0 ft, y = 0 ft; x <= 9 ft && y <= 4 ft;
x = x + 3 ft, y = y + 2ft) {
print "x = ", x, ": y = ", y, "\n";
}
```
the initialization statements are
```    x = 0 ft, y = 0 ft;
```
and the increment statement are
```    x = x + 3 ft, y = y + 2ft;
```
The generated output is
```   x =          0 ft : y =          0 ft
x =          3 ft : y =          2 ft
x =          6 ft : y =          4 ft
```
The looping construct terminates when y is incremented to 6 ft and the relational operation to y <= 6 ft evaluates to false.

Example 6 : The initialization and increment statement blocks may be empty. For example, the script of code

```    x = 0 ft; y = 0 ft;
for( ; x <= 9 ft && y <= 4 ft; ) {
print "x = ", x, ": y = ", y, "\n";
x = x + 3 ft;
y = y + 2 ft;
}
```
generates the same block of output as in Example 5.

### THE break STATEMENT

The break statement forces an early exit from one layer of looping constructs. We will demonstrates its behavior via a series of examples.

Example 6 : The script of statements:

```    for( x = 0 ft ; x <= 9 ft ; x = x + 3 ft ) {
print "x = ", x, "\n";
if (x == 6 ft)
break;

}
print "breaking from loop \n";
print "x = ", x, "\n";
```
generates the same block of output
```    x =          0 ft
x =          3 ft
x =          6 ft
breaking from loop
x =          6 ft
```
and shows how the program execution exits the looping construct before the boolean expression has an opportunity to evaluate to false

Example 7 : What about 2 levels of looping construct ? In the script of statements:

```    for( x = 0 ft ; x <= 6 ft ; x = x + 3 ft ) {
for( y = 0 ft ; y <= 9 ft ; y = y + 3 ft ) {
print "x = ", x, "y = ", y, "\n";
if (y == 6 ft)
break;
}
}
print "finished looping construct\n";
print "x = ", x, "\n";
```
the output is
```    x =          0 ft y =          0 ft
x =          0 ft y =          3 ft
x =          0 ft y =          6 ft
x =          3 ft y =          0 ft
x =          3 ft y =          3 ft
x =          3 ft y =          6 ft
x =          6 ft y =          0 ft
x =          6 ft y =          3 ft
x =          6 ft y =          6 ft
finished looping construct
x =          9 ft
```
You should notice how the values of y in the inner for loop never reach 9 ft because the relational operation
```    y == 6 ft
```
always evaluates to "true" beforehand. The break statement forces the program execution to exit one level of looing constructs.

Developed in April 1996 by Mark Austin