Essay/Term paper: Conditional and iterative data types

Essay, term paper, research paper:  Technology

Conditional and Iterative

A programming language cannot be a programming language with out its conditional and iterative structures. Programming languages are built to accomplish the task of controlling computer input and output. A programmer must use every tool available to complete his/her given tasks, and conditional as well as iterative statements are the most basic items of programming which must be mastered. Many different programming languages can demonstrate conditional and iterative statements including C++, Java, Pascal, Qbasic, COBOL, and Scheme. Most of these languages implement conditional and iterative statements in a similar fashion; however, there are a few differences.
The conditional structure is easy to understand and self-defining. The whole statement is base on a condition and its veracity. When the statement or "test" is found to be true, a statement is executed, and if it is false, another test is given or the program continues to the next block. Conditional structures include the simple, two-alternative, multi-alternative, and non-deterministic conditional. The simple conditional is the easiest to understand being the IF-THEN statement.
if <Boolean expression> then <block of statements>
IF a condition is met THEN execute a statement. The two-alternative conditional or IF-ELSE is also easy to understand.
if <Boolean expression> then
<block of statements>
else
<block of statements>
IF a condition is met execute a statement; ELSE the condition was not met so execute a different statement. The multi-alternative conditional is very close to the two-alternative conditional.
if <condition-1> then
<statement-block-1>
elseif <condition-2> then
<statement-block-2>
…
elseif <condition-n> then
<statement-block-n>
[else <statement-block-(n+1)>]
end if
The IF question is asked about a statement, and if it is not true, the next statement is examined. If statement number two is not true, the next statement is examined; then the next statement is examined and so forth until a condition is met, and the control is carried out of the multi-alternative conditional. The non-deterministic conditional is similar to the multi-alternative conditional, because it has multiple conditionals.
if <condition-1> &#61614; <statement-sequence-1>
when <condition-2> &#61614; <statement-sequence-2>
…
when <condition-n> &#61614; <statement-sequence-n>
end if
The reason multi-alternative and non-deterministic conditionals are different, stems from the release of program's control or flow. The non-deterministic conditional tests each statement to see if its condition is met; whereas the multi-alternative conditional only tests statements until one of the conditions is met. After one of the conditions is met, the multi-alternative conditional releases the program control and fails to check anymore statements.
The iterative structure is a bit more complicated than the conditional structure, but it is easy to understand. An iterative structure consists of a block of statements that are executed repetitively. They might be executed once or a hundred times depending on the controls placed on the structure. Iterative structures include non-terminating, pretest, posttest, in-test, fixed-count, and non-deterministic iteration. The non-terminating iterative structure is not very common, because once it has program control, it does not release its control until the whole program is terminated.
loop
<sequence-of-statements>
end loop
Once a non-terminating iterative structure is activated it continues to run forever. The pretest iterative structure tests a condition first, then if it is true, the following statements are executed repeatedly - testing the statement each loop - until the statement is false.
while <condition> loop
<sequence-of-statements>
end loop
Once the statement is found to be false, control is returned to the program ending the pretest iterative statement. The posttest iterative statement is the same as the pretest statement except the condition is tested after the sequence of statements. With the posttest iterative statement, the programmer is guaranteed to have the sequence of statements executed at least once. The statements are executed before the conditional statement has a chance to be tested. With the in-test iterative statement, the conditional statement is tested in the middle of the sequence of statements. It can be useful when it is necessary to run a portion of the statement at least once regardless of the outcome of the conditional. Fixed-count iteration is very popular, because it allows a sequence of statements to be executed a finite number of times instead of relying on a condition to be true or false. The fixed-count iteration is simply do <sequence-of-statements> x number of times. The non-deterministic iterative statement is similar to the non-deterministic conditional statement.
do
when <condition-1> &#61614; <statement-sequence-1>
when <condition-1> &#61614; <statement-sequence-1>
…
when <condition-n> &#61614; <statement-sequence-n>
end do
The iterative statement executes until none of the conditions are found to be true. At that time, control is release back to the program from the non-deterministic iterative statement.
C++ has every type of control structure a programmer could ever need, and they are all easy to implement. The three types of condition statements include the if, if/else, and the switch. The simple conditional is implemented through the if statement. The two-alternative conditional can be shown in C++ by using the if/else statements, and the multi-alternative can be demonstrated by using the switch statement. When it come to iterative structures C++ uses the while, do while, and for statements. Pretest works closely with the while statement. Posttest uses C++'s do while statement, and the for statement is used in fixed count iteration. The code below gives an example of each structure.

if (x < y) while (x < y) {
cout << x; cout << x;
}
------------------------------------------------------------
if (x < y) ------------------------------------------------------------
cout << x; do {
else cout << x;
if (y < x) } while (x < y);
cout << y;
------------------------------------------------------------
------------------------------------------------------------ for (int i=0; i < 10; i++)
switch (fruit) i = i + 1;
case 'orange':
cout << "yum";
case 'banana':
cout << "yummy";
case 'apple':
cout << "ooh yes";


The simple conditional or "if" statement simply asks if x is less than y and if it less than y x is printed to the screen. The two-alternative/multi-alternative conditional using if/else asks if x is less than y and if true prints x. If it is not less than y then it asks if y is less than x. If this is true y is printed to the screen. More statements can be added to this conditional to lengthen the multiple alternatives. Another multi-alternative conditional involves the case statement. The variable "fruit" is measured against 'orange'. If fruit is orange the "yum" is printed. Next "fruit" is checked to see if it is 'banana'. If so "yummy" is printed. Last 'apple' is compared.
Iterative statements start with the while on the right. The pretest is initiated with the comparison of x to y. If the statement is true the loop is started and lasts until x is greater than y. Post test is exemplified by the do while. It say print x then check to see if x is less than y. Next continue the loop until x is greater than y. The for loop continues to add one to i until is not less than ten; the for loop demonstrates fixed count iteration.
Java is very similar to C++. As a matter of fact, Java control structures are almost exactly the same as C++. When it comes to conditional statements, Java uses the if and if/else statements. The else if statements can substituted for the case statement, but case is permitted. Iterative structures are seen throughout Java in the form of while, do while, and for statements. Examples of each statement are in the examples below .

if (distance < r) return true; while(i-- > 0) {
------------------------------------------------------------- Object o = get_object();
if (a == 2) if (o != null) {
System.out.println("My exception"); do {…
else } while(j != 0);
if (a < 25) }
System.out.println("Handled at fault pt"); }
------------------------------------------------------------ ----------------------------------------------------
switch ( i ) { for (int i = 0; i < shapes.length; i++){
case 0: c = a + 3;
throw new MyException("too low"); }
case 1:
throw new MySubException("still too low");
default:
return i*i;
}


After viewing the C++ code on the previous page, it is easy to see the similarities between C++ and Java. The first simple conditional or if statement compares distance to r returning true if the condition is true. If distance is not less than r nothing happens. The second if statement is part of a two-alternative conditional. If the condition a == 2 is met statement one is executed. If the condition is not met then the second alternative is asked and if found true the second statement is executed. The switch statement or non-deterministic conditional is just like the C++ implementation. The variable i is compared with the first case (0) and if true then the too low exception is executed. If not true the next case is examined and if true the still too low exception is sent back to the calling block. If none of the cases match then i * i is returned. The pretest iterative statement while is seen on the right side. It simply states if i minus one is greater than 0 perform all statements within its loop. And while i minus one is still greater than 0 keep on looping. The for loop or fixed count iterative statement allows all statements below it to be performed while i is less than the shapes length. The integer i is incremented every time the loop is performed as indicated by the i++ located in the actual for statement. Looking at the different aspects of conditional and iterative structures C++ and Java are almost one in the same. They both use the same statements to provide examples of the different types of structures. It is easy to see that Java was based on the syntax of the C and C++ programming languages.
Pascal is a versatile language with control structures that almost match C and Java. The key difference between Pascal and C++ is not the actual conditional or iterative structure, but the difference is the syntax and key words. The key words used by Pascal for conditional structures include if, if/else, and case. Iterative structures use the key words repeat/until, while/do, and for. The following examples display the usage of the key words.
repeat case Ch of
i := 1; 'a' .. 'z': writeln('small');
x := round(r) + 12; 'A' .. 'Z': writeln('big');
while i < x do begin end;
write(' '); -----------------------------------------
inc(i); if Ch = 'Y' then begin
end; goodmood := true;
writeln('*'); end else begin
y := y+1; goodmood := false;
until keypressed; end;
----------------------------------------
for i := 0 to 9 do
read(f, numbers[i]);
readln(F);
end;
The repeat block is a perfect example of the iterative control structure and it contains the while/do block. The repeat block executes all the statements at least once then test to see if a key has been pressed; this is the posttest operation of the iterative control structure. The while/do in the middle of the repeat block shows the pretest of the iterative control structures. It tests to see if i is less than x before performing the statements that follow. Fixed count iteration is pointed out by the for loop. The statements under the for loop are executed ten times. Non-deterministic conditional structure is found with the case block. The variable 'Ch' is examined against lowercase letters then against uppercase letters. The simple conditional and two-alternative conditional is cover in the one if/else block of code. If 'Ch' equals 'Y' then 'goodmood' gets the value of true. With the else statement on the end, the simple conditional becomes the two-alternative conditional. 'Goodmood' gets the value of false when 'Ch' does not equal 'Y'. Pascal structures are very similar to other languages but keywords and syntax are a little different.
Qbasic is a simple language, but it still contains a wonderful assortment of conditional and iterative structures. As for conditional structures, if, else/if, and case are the most popular choices. When it comes to iterative structures, Qbasic is packed full of them. Qbasic has for, do/while, while, do/until, and do/loop. All of the previous control structures are the basic type found in C++, Java, and Pascal. Again, Qbasic is similar to the previous languages, but the key words are different. Qbasic contains and relies upon the heavy use of conditional and iterative control structures such as the if and do structures. To further illustrate the Qbasic control structures, the following examples are referenced and explained.
if (yrs > 20) then for ctr = 100 to 200
print "give a gold watch" total = total + ctr
elseif ((yrs > 10) and (yrs < 20) then next ctr
print "give a paperweight" -------------------------------
end if while (A > 5)
------------------------------------------- print A, B
select case num B = B - 1
case 1 wend
beep -------------------------------
case 2 do while (ans$ <> "Y")
beep : beep print "you must type Y"
case 3 input "hello"; ans$
beep : beep : beep loop
end select --------------------------------
------------------------------------------- do until (ans$ = "Y")
do beep
print "type Y" print "type Y"
input "answer"; ans$ input "answer"; ans$
loop while (ans$ <> "Y") loop

There are many examples above, but most of the examples are of iterative control structures. The simple conditional and two-alternative conditional are shown with the if and else/if structures. If yrs is greater than 20 then print the message. The else if added to the end checks to see if the years are in-between 10 and 20. If the years meet the criteria the next message is printed. The case block demonstrates non-deterministic conditional structures just like C++, Java, and Pascal. Based on the variable 'num' one to three beeps are heard. The do/while loop is one of many iterative control structures. The do/while is a posttest operation that checks the users input after the loop runs once. The for loop indicates a fixed count structure; it loops while the variable 'ctr' is incremented. The while loop is a pretest iterative structure testing 'A' before the loop even begins. The do/while loop is also a pretest iterative structure that checks the users input before the loop starts. The do/until block is like a in-test iterative structure. It tests each line as it is processed to see if 'ans$' is equal to 'Y'. When 'ans$' is equal to 'Y', the loop releases control back to the main program. Qbasic can be compared to the previous three languages, but Qbasic seems to be less streamlined because it has so many possible iterative structures. The same programs can be written in Java using only for or while loops.
Now for the mighty programming language COBOL. COBOL is the older language with the ability to keep up with today's fast paced programming tasks. COBOL is not very comparable to the previous four languages. Its is capable of performing the same tasks with its conditional and iterative structures as C++, Java or any of the other languages, but COBOL has its own special way of performing. The syntax is quite different, but some of the key words are the same. Also, COBOL has considerably less iterative structures compared to Qbasic. COBOL has such conditional structures as if, if/else and evaluate/when. Iterative structures are best described in one word "perform"; the perform/until is COBOL's definite solution to iteration. Exemplified by the following code , COBOL's conditional and iterative structures are easily understood.
if operation = '-'
subtract field-1 from field-2 giving result
-------------------------------------------------------------------------------
if operation = '+'
add field-1 field-2 giving result
else
if operation = '/'
divide field-1 by field-2 giving result
-------------------------------------------------------------------------------
evaluate taxable-wages
when zero thru 200
multiply taxable-wages by .15 giving federal-taxes
when 200 thru 300
multiply taxable-wages by .22 giving federal-taxes
end-evaluate.
--------------------------------------------------------------------------------
perform
varying power-value from 1 by 1
until power-value > field-2
end-perform

The example above lengthy for demonstrating only four structures by COBOL is not designed to be easy to write; it is designed to crunch numbers. The if statement shows a simple conditional. If the question is evaluated to be true the subtraction is performed on the two fields. The second block of code shows the use of if/else or the two-alternative conditional. If the first condition is not met the second condition is evaluated. If the second is found true division is performed on the two fields and an answer is given. Evaluate is the last conditional block of code; this is a non-deterministic conditional structure. Each case is evaluated line by line, and "when" (just like in the code) a condition is met the applicable statements are executed such as finding an employees federal taxes for a company. The iterative structures posttest, in-test, and fixed count can be performed using the "perform" keyword in COBOL. The example above displays the posttest. The loop is performed then 'power-value' is tested against 'field-2'; if power-value is greater than field-2 then the loop is broken. COBOL is a competitive language, but it is lengthy when writing. Then conditional and iterative structures are easy to use but require much time during the planning phase of writing a program.
Scheme is the last and most unusual programming language of this paper. Scheme can implement both conditional and iterative structures, but the syntax of scheme is totally different from C++, Java, Pascal, Qbasic, or COBOL. The Scheme programming language is designed in a recursive manner. All Scheme programs are recursive and are actually iterative because the program iterates over and over again. The recursive nature of Scheme is not however an iterative structure. The conditional structures of Scheme us such keywords as if, else, case, and cond. The iterative structure of Scheme seems to only be seen with the keywords loop or do. Scheme conditional and iterative structures are seen below .
(if (< n 0) (case (+ x y)
(- 1 n)) ((1 3 5 7 9) 'odd)
((0 2 4 6 8) 'even)
--------------------------------- -------------------------------------------
(cond (loop
(eqv? msg 'empty?) (if (= n 0) (break ls))
(eqv? msg 'push!) (set! ls (cons 'a ls))
(else "oops")) (set! n (- n 1)))
---------------------------------- --------------------------------------------
(cond (do (( i 2 (+ i 1)))
(< x 0) ((>= i n))
(> x 0)

The syntax of the if block looks very different from any other languages in this paper, but it behaves in a similar fashion to other simple conditional structures. The if statement states that if 'n' is less than zero then subtract one from 'n'. The cond with the else is a multi-alternative conditional structure. The first line asks if the variable 'msg' contains the string 'empty?'. The second line asks if the variable 'msg' contains the string 'push!', and the else line says if neither of the previous two lines are true print 'oops'. The cond block on the bottom is a two-alternative conditional structure. The first condition is if x is less than zero, and the second condition is if x is greater than zero. The case block is another multi-alternative conditional structure. If x plus y is equal to and odd number then 'odd' is printed, and if x plus y is equal to an even number then 'even' is printed. The loop code is a pretest iterative structure. 'n' is tested against zero for equality. If they are equal then the loop is stopped. The do block corresponds to the posttest iterative structure. The first line is executed until 'i' is greater than or equal to 'n', but the condition is not tested until the first line is executed at least once. Scheme is an odd language, but once it is mastered is can accomplish any programming task set forth.
Comparatively, the conditional and iterative structures in all the languages previously mentioned are very similar to one another. All of the simple conditional structures even use the same key word 'if'. The conditionals in the languages all accomplish the same tasks only some languages use different methods. The iterative structures allow similar tasks to be completed by all languages as well. For the most part the iterative structures of all the languages use at least the keyword 'do' or perhaps 'while'. The key words may vary but the function is all the same. The structures are used for iteration. The blocks of statements in the iterative loop must be performed time and time again. C++ and Java are the most similar languages when the conditional and iterative structures are compared. The two languages that are the most dissimilar are COBOL and Scheme. COBOL is lengthy with a few control structures. Scheme is compact with many control structures. When comparing the control structures of C++, Java, Pascal, Qbasic, COBOL, and Scheme, no one language can be said to be better than any of the others.