Search                        Top                                  Index
TEACH SIMPLEMATHS                                        Aaron Sloman Oct 2011
                                                    Based on older teach files

               Familiar Simple Mathematical Operations in Pop11
                  An Introduction for experienced programmers

CONTENTS - (Use <ENTER> g to access required sections)

 -- Introduction
 -- Pop11 as a stack-based desk calculator
 -- Division can sometimes produce surprises
 -- There are also complex (imaginary) numbers with their own format
 -- Looping over numbers
 -- Adding tracing information to a numerical procedure
 -- More things to do

-- Introduction -------------------------------------------------------

Pop11/Pop-11/pop11 is an AI language whose origins go back to work by
Robin Popplestone around 1969. There is information about its origins in

    POP-11 Comes of Age: The Advancement of an AI Programming Language,
    Editor James A.D.W. Anderson, Ellis Horwood, Chichester, 1989,

That book is now out of print. The online Pop11 primer (version 4
October 2011) gives a more detailed overview for readers with
programming experience. If are are reading this in the Poplog editor Ved
or XVed, you can access the primer with the command

    ENTER teach primer RETURN

It is also available on the internet

    Printable PDF
        (About 287 printed pages -- may vary with edits)

    Printable PDF 2 pages per sheet
        (About 144 printed pages -- may vary with edits)

Like Common Lisp and several other AI languages, Pop11 provides
considerable support for numerical entities and operations on them. The
entities include small integers, big integers (size limit depends on
available memory), short and long floating point numbers (referred to as
"reals" in Pop11), indefinite precision ratios, and complex (imaginary)
numbers. There is also a Pop11 interface to the BLAS and LAPACK linear
algebra packages produced by David Young at Sussex University, and
included with Poplog as part of the Popvision library. This supplies
many of the features of packages like MATLAB, easily combined with other
AI tools.

This teach file introduces a tiny subset of those mathematical
capabilities for new users looking for some familiar constructs. The
ideas will be presented mainly in the form of examples that can be
compiled and run in the editor, then modified, then re-run, etc. More
detailed information is available in TEACH files, HELP files and REF
files, some of which are referred to at the end, and in the Primer.

If you have not yet looked at you may find this short introduction
to the editor useful:
    ENTER teach minived RETURN

(or put the editor cursor after "teach" and type ESC h).

-- Pop11 as a stack-based desk calculator -----------------------------

Add some numbers, using '=>' to print out the result:

(use ESC d on this line):

    10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25 =>

Your output.p file should show this:

    ** 280

Try a numerical expression using different operators:

    10+11*12 =>
    ** 142

spaces between numerals and operator symbols  make no difference:

    10 + 11 * 12 =>
    ** 142

What should this do. Try it?
    (10+11)*12 =>

You can include decimals (reals, floats) instead of only integers:

    10+11*12.0 =>
    ** 142.0

    3.6 + 4.2 =>
    ** 7.8

If a non-integer is involved, its type takes over.

Or this
    (10 + 11)*12.0 =>

-- Division can sometimes produce surprises ---------------------------

    12/4 =>
    ** 3

This one is not exact, so it produces a 'ratio' 12 5ths:

    12/5 =>
    ** 12_/5

So does this

    24/10 =>
    ** 12_/5

Ratios are automatically reduced by dividing numerator and denominator
by highest common factor. In that case 2.

    3 + 4/5 =>
    ** 19_/5

Try some others.

If a decimal is involved, it dominates:

    3.0 + 4/5 =>
    ** 3.8

or the other way round:

    4/5 + 3.0 =>
    ** 3.8

-- There are also complex (imaginary) numbers with their own format ---

The sqrt (square root) function may produce some surprises:

    sqrt(100) =>
    ** 10.0

    sqrt(-100) =>
    ** 0.0_+:10.0

That's a complex number with real part 0.0 and 'imaginary part' 10.

The square root of -1 is generally represented is "i" in maths, but
pop11 represents as (in effect) 0.0 + i*1.0

    sqrt(-1) =>
    ** 0.0_+:1.0

-- Looping over numbers -----------------------------------------------

Our original expression

    10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25 =>

can be expressed as a loop, using a variable e.g. num, to take the
successive values and then repeatedly add them to another
variable, total, which starts from 0:

    vars num, total;
    0 -> total;
    for num from 10 by 1 to 25 do total + num -> total endfor;
    total =>

Mark those four lines using
    Mark first: F1 (or ESC m) and
    Mark Last:  F2 (or esc M)

Then compile the range (CTRL-d).

We can create a pop11 procedure (sometimes called a function) that will
do that sort of thing for any start number and any increment, added
repeatedly until some target is reached or passed:

    define add_range(start, increment, target) -> total;

        0 -> total;

        for start from start by increment to target do
            total + start -> total


Mark that range (F1, and F2) then compile it (CTRL-d).

Now test it, first with our original sum:

    add_range(10, 1, 25) =>
    ** 280

same result as before.

Will this give a bigger or a smaller total?

    add_range(10, 2, 25) =>

Try other values. Try defining a procedure

    multiply_range(start, increment, target)

that repeatedly increments a multiplier and produces a result.

You can test it on things like

multiply_range(5, 1 8):

    5*6*7*8 =>
    ** 1680

Does it give the right answer for this:

    10*11*12*13*14*15*16*17*18*19*20*21*22*23*24*25 =>


    ** 42744736671436800000

-- Adding tracing information to a numerical procedure ----------------

If you wish to know what add_range is doing each time round the loop you
can easily make it print its values, by constructing a list of
information to be printed out after the addition is done.

Use the fact that a list like this

    [start ^start, total ^total] =>

Will print out in the format

    [start <value of start> , total <value of total>]

So try compiling and testing this:

    define add_range(start, increment, target) -> total;

        0 -> total;

        for start from start by increment to target do

            total + start -> total;

            [start ^start, total ^total] =>



What should these print?

    add_range(2, 2, 10) =>

    add_range(-2, 2, 10) =>

This may surprise you:
    add_range(-10, 0.5, 10) =>

Try some others. If you wish you can add another print instruction
before the addition is done in the loop.

The tracing instructions can be commented out by putting three
semi-colons before the instructions. E.g.

    ;;; [start ^start, total ^total] =>

In pop11 anything after ';;;' to the end of the line is ignored.

Like several other programming languages Pop11 also allows /* ... */
as comments, stretching over several lines, e.g.

    ;;; This can be enabled for tracing purposes
    [start ^start, total ^total] =>


You can mark (F1, F2) and compile (ESC -d) that but nothing will happen.

-- More things to do --------------------------------------------------

Now try
        Put the cursor on the asterisk, and type ESC h,
        or do ENTER teach arith RETURN

For revision on using the editor try

        file gives you the following contents:


      -- Types of numbers available in POP-11
      -- Recogniser procedures
      -- Arithmetical operators
      -- Comparison procedures (predicates)
      -- Operations on Ratios
      -- Operations on Complex numbers
      -- Bitwise operations
      -- Floating point utilities
      -- Trigonometric and other utilities
      -- Representation and efficiency
      -- Fast integer procedures
      -- Global variables and constants

There's lots more.

If you are either using a linux machine locally, or using XMing from a
windows machine to connect to this, you can try out some of Pop-11's
graphical facilities, as demonstrated here, using numerical
coordinates to control what is drawn:

        Some standard graphical stuff, e.g. drawing lines.
        How to make faces out of coloured blobs.

See also

--- $usepop/pop/teach/simplemaths
--- Copyright University of Birmingham 2011. All rights reserved.