TEACH ARITH A. Sloman, Jan 1983
Using POP11 for Arithmetic
==========================
POP11 enables you to refer to different kinds of objects: including
words, lists, procedures, and numbers. What follows is an introduction
to some of the things you can do with numbers in POP11. You can use
POP-11 as a simple calculator, and we'll start by showing you how. Later
you can define procedures to do more complex things, like finding
averages of lists of numbers.
CONTENTS - (Use <ENTER> g to access required sections)
-- The 'PRINT ARROW'
-- Multiplication
-- Defining a procedure- PERIMETER
-- Carpeting the room
-- Wallpaper required
-- The volume of a room
-- A "talkative" program
-- The role of parentheses
-- Precedence
-- Using variables to remember values
-- "Undef" objects
-- Adding a number to an undef object
-- Warning messages
-- Arithmetical expressions
-- Incrementing a variable
-- Decrementing a variable
-- An UNTIL loop
-- FOR Loops
-- Arithmetic operators
-- Division of two integers sometimes produces ratios
-- Making ratios print like decimals
-- POP-11 doesn't use algebraic syntax
-- Decimal Numbers in POP11
This file assumes you are familiar with the use of VED to develop and
test POP-11 programs. (See TEACH VEDPOP).
You should also be familiar with variables (TEACH * VARS) and procedure
definitions (TEACH * DEFINE).
It will be helpful, though not essential, to know how to mark a range in
the editor and "load" the marked range. ( HELP * MARK, HELP * LMR)
-- The 'PRINT ARROW' --------------------------------------------------
The print arrow "=>" says to POP11, roughly,
"print out your results so far"
Try:
1 + 3 + 5 =>
5 - 5 =>
99 + 88 - 77 =>
The print arrow makes it possible to use POP-11 as a desk-calculator.
-- Multiplication -----------------------------------------------------
Multiplication uses the "*" symbol. Try the following:
3 * 5 =>
333 * 99 =>
22.5 * 6 =>
We now show how these arithmetical operations can be used in defining
some procedures to help you sort out requirements for furnishing and
heating a room. Just try defining all the procedures as shown, and don't
worry too much if you don't understand the details. As you gain
familiarity the language will make more sense.
-- Defining a procedure- PERIMETER ------------------------------------
Suppose you know the length and the and the breadth of a rectangular
room and you want to know its perimeter. You can add up the lengths of
all the walls, thus:
define perim(long,wide) -> total;
long + wide + long + wide -> total
enddefine;
Type that into a file, then load it and test it
perim(3,4) =>
perim(10,20) =>
perim(10,10) =>
-- Carpeting the room -------------------------------------------------
In order to carpet the room you'll need to know the area of the floor.
This procedure will tell you:
define floor(long,wide) -> area;
long * wide -> area
enddefine;
Type that in then test it
floor(10,10) =>
floor(8,6) =>
-- Wallpaper required -------------------------------------------------
If you also know the height of the room you can work out the area of
wall-paper required to cover the walls. Imagine the walls all
straightened out into one long wall. Then the new wall would be as long
as the original perimeter of the room and to find its area you'd only
have to multiply that by the height. So you can do
define wallarea(long,wide,high) -> total;
perim(long,wide) * high -> total
enddefine;
Put that in a file and test it:
wallarea(10,10,10) =>
wallarea(10,20,8) =>
-- The volume of a room -----------------------------------------------
If you need to buy an extractor fan, or heating system, you'll need to
know the volume of the room. So
define volume(long,wide,high) -> vol;
long * wide * high -> vol
enddefine;
Then test it:
volume(10,10,10) =>
volume(8,12, 8) =>
-- A "talkative" program ----------------------------------------------
You can now combine the different programs to take in the measurements
of the room, and print out all the information you need, thus:
define estimate(long,wide,high);
vars num;
perim(long,wide) -> num;
[ Your room has a perimeter of ^num feet] =>
wallarea(long,wide,high) -> num;
[ You will need ^num square feet of wallpaper] =>
floor(long,wide) -> num;
[you will need ^num square feet of carpeting ] =>
volume(long,wide,high) -> num;
[The radiator will have to cope with a volume of ^num cubic feet] =>
enddefine;
Now test your procedure:
estimate(10,10,10);
estimate(8,12,8);
Try again with all the procedures traced, so you can see when procedures
start and end:
trace estimate, perim, wallarea, floor, volume;
estimate(10,10,10);
estimate(8,6,8);
The rest of this file is concerned with some of the nitty-gritty detail
of how you use numbers in POP-11.
-- The role of parentheses --------------------------------------------
Examine the following carefully and compare the results:
3 * 5 + 4 =>
(3 * 5) + 4 =>
3 * (5 + 4) =>
Test your understanding of the "precedence" of operators "+" and "*" by
attempting to predict what the following will print out:
4 + 5 * 3 =>
3 + 5 * 4 + 2 =>
-- Precedence ---------------------------------------------------------
We say that the two 'infix operators' + and * both have a precedence,
but that + has a 'higher' precedence: i.e. it stretches over a larger
portion of the expression, when bracketing isn't present. Alternatively
you can say that * 'binds its arguments more tightly' than +. (In some
programming languages 'higher precedence' has the opposite meaning.)
Test some more examples, trying first to work out what result will be
printed out.
4 - 3 * 5 =>
(4 - 3) * 5 =>
5 * 3 - 2 =>
(5 * 3) - 2 =>
5 * (3 - 2) =>
-- Using variables to remember values ---------------------------------
You can declare a variable and use it to store a number as its value.
Try:
vars num;
66 -> num;
num =>
It is possible to declare a variable and initialise its value in one
instruction:
vars big=999;
big =>
-- "Undef" objects ----------------------------------------------------
If a variable is not initialised or assigned a value, its value is an
"undef" object:
vars xxx;
xxx =>
-- Adding a number to an undef object ---------------------------------
Now see what happens if you try adding a number to XX. Type:
1 + xxx =>
You can only add a number to a number, not to a variable with undefined
value. If you assign a number to the variable, then it can be used in an
addition.
6 -> xxx;
1 + xxx =>
-- Warning messages ---------------------------------------------------
You can use a variable without declaring it. POP11 will declare it and
print out a "warning" message. E.g. type:
yyy =>
The warning message tells you POP11 was declaring yyy as a variable for
you.
Then it obeyed the instruction "yyy =>" and printed out the value of
yyy, which so far is undefined. You can give a value to yyy thus:
2 -> yyy;
yyy =>
You can also get a warning message as a result of doing an assignment to
a variable not yet declared. Try
66 -> zzz;
-- Arithmetical expressions -------------------------------------------
Now try printing out the value of yyy, and the value of yyy + 4, thus:
yyy =>
yyy + 4 =>
So we can build complex expressions making use of variables and actual
numbers. E.g.
vars y, z;
4 -> y;
5 -> z;
y + z =>
y * z =>
4 * (y + z)
Y and Z are now variables.
"Y" is the name of the variable Y. Corresponding to it is a location in
the machine where you can store information. By using the assignment
arrow "->" you put something new in the location, e.g.
99 -> y;
By using the name of the variable without the assignment arrow you ask
what is stored in the location, and the result can be printed out, or
used in some other computation, e.g.
y =>
y + 2 =>
y + y =>
You can use the current value and change the value, in the same command.
Try:
y + 5 -> y;
y =>
'Y + 5' USES the value and '-> Y' CHANGES the value.
Now give an instruction which says add the current value of Y to itself
and make that the new value of Y. Print out the new value.
Your answer could have been:
y + y -> y;
y =>
-- Incrementing a variable --------------------------------------------
It is often useful to add a certain amount to a variable repeatedly, for
example in going through a range of numbers to perform some task. Try:
vars y;
6 -> y;
y + 2 -> y;
y=>
y + 2 -> y;
y=>
y + 2 -> y;
y=>
-- Decrementing a variable --------------------------------------------
You can gradually decrease the value of X:
vars x;
10 -> x;
x - 2 -> x;
x =>
x - 2 -> x;
x =>
x - 2 -> x;
x=>
You can use one variable to control the amount by which another changes.
E.g. use the value of Y to control the amount by which X changes. Try
the following:
4 -> x;
3 -> y;
x =>
x + y -> x;
x =>
x + y -> x;
x =>
x + y -> x;
x =>
y =>
-- An UNTIL loop ------------------------------------------------------
You can get the computer to do this sort of instruction repeatedly,
without your having to type everything over and over again. Can you
guess what the following will do?
vars z;
0 -> z;
until z > 20 do
z =>
z + 3 -> z;
enduntil;
Try it. You could use VED to put this in a file called UNTIL.P, so that
if you make a mistake you can correct it easily. When you load the file,
with ENTER X, the instructions will be obeyed.
Make a note of the format:
UNTIL <condition> DO <action> ENDUNTIL;
See how this format relates to the above instructions.
The command " Z=> " says print out the current value of Z, and the next
command "Z + 3 -> Z" says add three to the value of Z and make the
result the new value of Z. Read it as "Z plus three goes to Z". Those
two commands (i.e. everything between "DO" and "ENDUNTIL") will be
repeated until the "condition" Z > 20 is true, and the process then
stops.
Try a different instruction like that. E.g. try making the computer
print out the numbers
2 4 6 8 10 ... up to 20
using the format
<initialise Z>;
UNTIL <condition> DO
<actions>
ENDUNTIL;
(You supply the steps in brackets.)
A possible solution would be
0 -> z;
until z = 20 do
z + 2 -> z;
z =>
enduntil;
If the 'initialisation' had been 2 -> Z; how would the rest have had to
be different, to get the same things printed out?
-- FOR Loops ----------------------------------------------------------
Often it is more convenient to use a "for" loop than an until loop.
Try:
vars z;
for z from 1 by 3 to 25 do
z =>
endfor;
You could get POP-11 to print out the square roots of the first 20
integers thus:
vars z;
for z from 1 to 20 do
[the square root of ^z is ^(sqrt(z)) ]=>
endfor;
-- Arithmetic operators -----------------------------------------------
Various "operations" are provided for arithmetic:
+ addition
* multiplication
/ division
- subtraction
Now try the following commands:
6 -> x;
3 * x =>
(3 + 5) * 10 =>
3 + 5 * 10 =>
9 / 3 =>
-- Division of two integers sometimes produces ratios -----------------
Try the following:
true -> pop_pr_ratios; ;;; in case the default has been changed
9 / 5 =>
** 9_/5
That will print out a 'ratio' (i.e. a rational number) in a form that
shows the numerator 9 and denominator 5.
POP-11 will remove common factors in the numerator and denominator of a
ratio:
44 / 24 =>
** 11_/6
You can force it to produce a decimal number instead of a ratio if you
replace one of the integers by a decimal number:
9 / 5.0 =>
** 1.8
9.0 / 5 =>
** 1.8
-- Making ratios print like decimals ----------------------------------
Try the following to make ratios print like decimals:
false -> pop_pr_ratios;
then
9 / 5 =>
** 1.8
44 / 24 =>
** 1.83333
If you want ratios always to print as decimals then you can put the
above assignment into your 'init.p' file, and it will automatically be
done whenever you run POP-11. (See HELP * INITIAL).
To make ratios print as ratios, do
true -> pop_pr_ratios;
9 / 5 =>
** 9_/5
-- POP-11 doesn't use algebraic syntax --------------------------------
The following will produce a mishap message.
(3 + 5)(2 + 2) =>
In POP11 you cant usually have ")" followed immediately by "(", though
the following is permitted:
(3 + 5) * (2 + 2) =>
Try it.
Here's another crop of "missing separator" examples. Try them:
3 3
3x
x 3
(x+5) 2 =>
But contrast
x3 =>
"x3" is accepted as one word, since words can begin with letters. But
"3x" is not treated as one word, since a word cannot (in POP11) begin
with a numeral.
-- Decimal Numbers in POP11 -------------------------------------------
Whole numbers in POP11, like 3, 5, 976, -2, -359, are called integers.
Decimal numbers, like 0.5, 66.66, -22.45 are called reals, or decimals.
Try the following:
isinteger(3) =>
isinteger(3.0) =>
isdecimal(3.0) =>
isdecimal(3) =>
Adding a decimal to an integer gives a decimal:
3 + 5.2 =>
3 + 0 =>
0.0 =>
isinteger(0.0) =>
3 + 0.0 =>
Similarly with subtraction:
3 - 2 =>
3 - 2.0 =>
isinteger(3 - 0.0) =>
isinteger(-2) =>
isinteger(-2.5) =>
See TEACH * DECIMALS for more on decimals.
See HELP * MATH for a summary of available arithmetic facilities.
See HELP * LOOPS for more on loops.
See REF * NUMBERS for a full account of numbers in POP-11.
(For advanced readers only)
--- C.all/teach/arith --------------------------------------------------
--- Copyright University of Sussex 1987. All rights reserved. ----------