{Assignment Four: Control Structures}

<strong>Assigned</strong>: Wednesday, March 4, 1998 <br>
<strong>Due</strong>: 11am, Friday, March 13, 1998

<strong>1. Parameter Passing</strong>

Devise a function, <code>callby()</code> in a generic imperative language
that determines which calling strategy the language uses and returns a
string corresponding to the calling strategy.  You should feel free to use
variables and helper functions.

It is likely that your function will have a structure like the following
(which determines whether something is call-by-value).
<pre>
function callby returns String
begin
  // Variable declarations
  int x = 3;
  // Call a function, affecting some but not all of the variables
  helper(x);
  // Determine the type of calling strategy by the effect on the
  // variable.
  if (x == 4) then
    return "call-by-value";
  else if ... then
    ...
  else
    return "call-by-???";
  end if
end callby
function helper(int param) returns nothing
begin
  param = 4;
end
</pre>

<strong>2. Guarded Control</strong>

Often, we learn of a structure in one language that we'd like to use in
another language.  Some of us find the nondeterminism of guarded conditionals
interesting, and might want to use it in our favorite languages.

Show how one might simulate guarded conditionals in a language of your choice.
That is, come up with generic code that has the same effect as a guarded
conditional.  The structure should permit a number of guard/statement pairs
(represented as you deem best) and execute some statement (not always the
first) with a true guard.

You may make reasonable modifications to the semantics of guarded conditionals.
For example, you don't need to have the program crash and burn if none of
the guards hold.  You may also choose whether or not all guards are evaluated.
In all cases, you should make it clear what you decide.

<strong>3. <code>GOTO</code> Considered Essential</code></strong>

[This problem is modified from problem 12 on pp. 240-241 of Louden's
<em>Programming Languages: Principles and Practice</em>.]

Dan has suggested that "all these control structures are a way for
mathematicians to restrict what we programmers know how to do" 
(paraphrased and made somewhat more extreme).  Others clearly feel
the same way.

In responding to the original "<code>GOTO</code> considered harmful</code>"
article, a researcher named Rubin suggested the following code as a
motivation for using <code>GOTO</code>.

<pre>
  for i := 1 to n do begin
    for j := 1 to n do
      if x[i,j] <> 0 then goto REJECT;
    write("First all-zero row is: ',i);
    break;
REJECT:
  end;
</pre>

* What do you think this code is supposed to do? 
* Rewrite this code using Pascal while loops. 
* Compare your code to Rubin's. What are the advantages of each? 
* Are there other modern control structures we could use to provide a 
  similar or better solution? 

<strong>4. Confusing Assignments</strong>

Substitute expressions for <code>alpha</code> and <code>beta</code> in the
following so that the code will print <code>Aagh</code>.  Neither of
your expressions should have side-effects (except for the standard
assignment statement side-effect of assigning to the l-value of the 
left-hand-side).

<pre>
alpha = beta;
if (alpha != beta) then
  print "Aagh";
end
</pre>

<strong>5. Iterative Merge Sort</strong>

The traditional merge sort algorithm has the following form:
<pre>
function mergeSort(Vector v) returns Vector
begin
  // The empty vector is sorted
  if (v.length == 0) then return v;
  // A vector of size 1 is sorted
  if (v.length == 1) then return v;
  // Split the vector in half
  mid = v.length / 2;
  // Sort the two halves
  first = sort(v.subVector(0,mid));
  second = sort(v.subVector(mid+1,last));
  // And merge them together
  return merge(first,second);
end
</pre>

An opponent of recursive algorithms might complain that this is a
doubly-inefficient use of memory, as we're using extra memory for the
merges and for the recursive calls.  

In the language of your choice, rewrite this function so that it does no
recursive calls, but still follows the same basic method of sorting
(merging sorted subvectors to produce larger sorted subvectors).  Turn in
an appropriate example to demonstrate that it works correctly.

<strong>6. Initializations and Declarations</strong>

[Taken from the notes of John Stone.]

Some programming languages require initializations to accompany variable
declarations. Summarize the principal arguments for and against such a
requirement.

<strong>Extra Credit: Iterative Quicksort</strong>

For many algorithms that involve repetition, there is a straightforward
translation between the imperative and recursive versions of the algorithm.
However, this is not always the case.  Consider the famous quicksort
algorithm, which is traditionally expressed as:
* Pick a pivot.
* Divide your list into two halves, one less than or equal to the pivot,
  the other greater than the pivot.
* Sort both halves separately.
* Concatenate the two lists.

Rewrite this algorithm in the language of your choice so that it has no 
recursive calls.  You will, of course, need to fill in more details.