| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
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); [fahr;celsius]'? |
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.
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(); }
sum?
|
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).
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);
else
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] | [ ? ] |