[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

3. Example Programs

Following are several examples designed to show off Algae's capabilities as well as to give you a feel for how it is used. The `examples' directory in the source distribution of Algae contains some additional code for perusal.

3.1 Temperature Conversion  Fahrenheit to Celsius conversions
3.2 Reading and Summing Numbers  Reading and summing numbers
3.3 Integer Powers  Integer powers

3.1 Temperature Conversion

This Algae program prints a table of Fahrenheit temperatures and their Celsius equivalents:

# Print temperature conversions
fahr = sort (0:300:20, 32, 212);
celsius = (5/9)*(fahr-32);

Its output looks like this:

[         0.000       -17.78 ]
[         20.00       -6.667 ]
[         32.00        0.000 ]
[         40.00        4.444 ]
[         60.00        15.56 ]
[         80.00        26.67 ]
[         100.0        37.78 ]
[         120.0        48.89 ]
[         140.0        60.00 ]
[         160.0        71.11 ]
[         180.0        82.22 ]
[         200.0        93.33 ]
[         212.0        100.0 ]
[         220.0        104.4 ]
[         240.0        115.6 ]
[         260.0        126.7 ]
[         280.0        137.8 ]
[         300.0        148.9 ]

This program does quite a bit in only four lines. The entire first line is a comment (because it starts with #) and is ignored by Algae.

In the second line we define the Fahrenheit temperatures for our table. The expression 0:300:20 gives a vector that goes from 0 to 300 in steps of 20. We add two more elements, 32 and 212, to that vector by using the comma operator. Then we use the sort function to sort it in increasing order. Finally, our vector of Fahrenheit temperatures is assigned to the variable fahr. Nothing is printed by this statement, since it ends with a semicolon.

The third line computes the Celsius equivalents using the familiar conversion formula. First 32 is subtracted from each element of fahr. Then each element is multiplied by 5/9. The result is assigned to the variable celsius. Here, again, nothing is printed.

Even though all of the terms so far have been integers, celsius is a real-valued vector. Unlike some programming languages, integer division in Algae does not result in truncation--the expression 5/9 returns a real value that is approximately 0.556.

The last line prints the temperatures out as a matrix, with the Fahrenheit temperatures in the first column and their Celsius equivalents in the second column. We do that by using brackets to form a matrix with fahr in the first row and celsius in the second row and then transposing the matrix with the ' operator. The question mark on the end is not necessary, since the matrix would also be printed without it, but it does call attention to the line as one that prints.

3.2 Reading and Summing Numbers

This Algae program reads a bunch of numbers, adds them up, and prints the result:

# Read and sum some numbers
sum = 0;
$read = 1;
while ($read) { sum += readnum(); }

The program reads numbers one at a time and adds them to sum, so in the first line sum is initialized to zero. The readnum function is used to read the numbers. This function is one of the few standard functions that has a side effect: it assigns to the variable $read the number of values that it read. It will be less than the number you asked for if readnum runs out of data.

The while loop executes its statements repeatedly until its condition tests true. We set $read to 1 (true) first, so we know that the while loop will execute at least once. After that, the while loop continues until $read is eventually set to 0 by the readnum function. When the while loop is done, the last line prints sum.

Usually, we give the readnum function two arguments: a "shape" vector and a file name. The "shape" vector describes the number of values to read and in what form (vector, matrix, etc.) they should be returned. The values are read from the named file. Since the program above gives neither argument, readnum simply reads one value from the standard input device.

The += operator adds the value on the right to the variable on the left; the expression sum+=readnum() does the same thing as sum=sum+readnum(). Every time the while loop repeats, sum is increased by the value returned by readnum. When readnum runs out of data, it returns 0 (so sum isn't changed) and sets $read to 0 (so the while loop quits looping).

Unless you redirect standard input, this program will quietly read what you type until you signal an end-of-file (C-d on UNIX systems and C-z on VMS).

3.3 Integer Powers

This program illustrates the use of a function. In it, we define the function power that computes integer powers of its argument. We also show some Algae code that calls power.

# power:  raise `x' to the `n'-th power
power = function (x; n)
  local (y);
  y = x;
  while (n > 1)
    y = y * x;
    n -= 1;
  return y;

power (2; 8)?
power ([ 1, 2; 2, 3 ]; 4)?

The first line of this program is an ordinary assignment statement, which assigns the function on its right side to the variable power. The function's arguments are defined in the parentheses that follow the function keyword. In this case, there are two arguments: x and n.

In Algae, all function arguments are called "by value". When a function is called, it gets copies of what the calling program gave as arguments and can modify them without changing the values retained by the calling program. In the power function we decrement n each time through the while loop, but this has no effect on the calling program.

The local statement defines its argument, the variable y, as having local scope. This means that power has its own temporary variable called y that is defined only within that function. This y is first given the value of x and then, inside the while loop, repeatedly multiplied by x until n is no longer greater than 1.

The value that power computes is returned to its caller by the return statement. Any expression may follow return, and any number of return statements may appear in a function. If the function has no return statement, it returns NULL to its caller.

The first time we call power, it returns (and the calling program prints) the value 256. In this case power is really not very useful, since we could have obtained the same result with the expression 2^8 using Algae's exponentiation operator.

The power function does have a use, though, as the second call to it shows. Algae's exponentiation operator performs in an element-by-element sense, so [1,2;2,3]^4 returns

[           1         16 ]
[          16         81 ]

In contrast, power performs in a matrix sense. In the program above, it returns

[          89        144 ]
[         144        233 ]

The algorithm used in the power function above can be improved upon by using successive squaring:

power = function (x; n)
  if (n == 1)
    return x;
  elseif (n%2)
    return x * self (x; n-1);
    x = self (x; n/2);
    return x * x;

This power function might be useful, but it's certainly not ready for prime-time. Notice that it gives wrong answers if n is 0 or a negative integer. What happens for the expression power(4;1/2), in which n is not an integer? To make power more robust you'd probably want to add some if statements to check for illegal arguments.

[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by K. Scott Hunziker on February, 22 2004 using texi2html