Search Top Index

/* TEACH TEACHNUMS Aaron Sloman 10 Aug 2009 This is a DRAFT teach file. Comments and suggestions welcome. It may be too difficult for some younger children, though some of the early ideas could be presented by a teacher using a computer, with pupils being asked to make suggestions about how things should work. More advanced learners (especially potential mathematical high fliers) could work through this file themselves, trying out the suggested procedure definitions then exploring alternatives, and finally trying to meet the challenges presented at the end, e.g. extending these ideas to negative numbers, and other extensions. Regarding negative numbers, teachers may find it useful to read: Pamela Liebeck, Scores and Forfeits: An Intuitive Model for Integer Arithmetic, Educational Studies in Mathematics, Vol 21, No 3, June, 1990, pp. 221--239, [Available via JSTOR to subscribing institutions] CONTENTS - (Use <ENTER> g to access required sections) -- Introduction -- A myth about computers -- Using bit-patterns in two-element links chained to form lists -- Doing arithmetic on lists of x's. -- First procedure: a number recognizer -- A procedure for adding two nums -- A procedure to subtract a number from another -- Another version, subnums2 using the pattern matcher -- Multiplication as repeated addition -- Some predicates for comparing numbers -- -- samenum checks whether two numbers are the same -- -- bigger checks whether a number is bigger than another -- -- between checks whether a number is between two others -- A procedure to divide one number into another -- A hard problem: how to represent and operate on negative numbers -- Another hard problem: how to divide 4 by 7 and produce a fraction -- Introducing 'place' notation to compress number representations -- Can you use numbers for counting? -- -- Try problem (a) -- -- Try problem (b) -- Introducing numerals -- How about using place notation with number names? -- More information -- Introduction In this teach file we introduce the idea of representing numbers as lists of 'x's and operations on numbers such as addition, subtraction and multiplication as operations on lists. The file gets to the point where new puzzles arise regarding how to deal with negative numbers. Working out how to do that is left as an exercise (for teachers and learners). There is no one right answer: learners should explore different types of solution. -- A myth about computers --------------------------------------------- It is often said that computers operate primarily on numbers and that everything else computers do is built on top of those operations. This is not correct. Computers operate on 'bit-patterns', i.e. patterns made of collections of switches that can be on or off. These can be represented by strings made up of '1's and '0's, e.g. 000111000111000111 000010011000111001101111 The fact that we use '0' and '1', is misleading. We could have used 'X' and 'Y', e.g. XXXYYYXXXYYYXXXYYY XXXXYXXYYXXXYYYXXYYXYYYY Any two symbols can be used in bit-patterns. One of many things that can be done using bit patterns is representing locations in memory in the computer, and also representing printable symbols. For now the details are not important. -- Using bit-patterns in two-element links chained to form lists ------ It is very often useful to store information in structures that are all built out of elementary structures containing only two adjacent locations in memory. These are called 'pairs' in Pop-11. The first location of a pair may store some bit pattern that represents a letter for example 'x' or 'y', or a word, e.g. 'the' or 'cat', or anything else (e.g. a number 3769). The second location can store a bit pattern that specifies the location of another pair. When several pairs are 'joined up' in a series to form a chain, because each pair points to the next pair, then they are sometimes referred to as 'links', making up a chain, or list. For example the list of words [how now brown cow] could be represented as chained links, as follows, where each asterisk '*' represents a bit-pattern that specifies the location of the next link, and 'NIL' at the end means there is not another link: .---. .---.---. .---.---. .-----.---. .---.---. | *---->|how| *---->|now| *---->|brown| *---->|cow|NIL| .---. .---.---. .---.---. .-----.---. .---.---. The first asterisk represents a bit-pattern that could be stored in various places, specifying where to find this list. This diagram suggests that the links are all stored close together, and in the order shown, but that is not required for the system to work. There are many more details concerning how lists are represented in computers, but we shall ignore them as we want to explore ways of using lists to represent numbers. Anyone wanting to know more about what lists are, how they are implemented in Pop-11, and which notations and commands are available to construct and operate on them, can look at TEACH LISTS TEACH WAL TEACH MATCHES and many 'teach' files that use lists and the pattern matcher, e.g. TEACH RIVER TEACH RESPOND Below we introduce the idea of using a list of 'x's to represent a number. We then have to define arithmetical operations, like addition, multiplication, subtraction and division using operations on lists. This file assumes that you have already had some practice writing simple Pop-11 programs and know, for example, that if L is a list, then hd(L) is the first element of L (its 'head') and tl(L) is a list (the 'tail' of L) containing everything in L except the first element. So hd([how now brown cow]) is the word "how" tl([how now brown cow]) is the list [now brown cow] The operator "<>" can be used to join two lists together, or more precisely to produce a new list that starts with the elements of the first list and then has a tail containing the second list. For example: [how now] <> [brown cow] produces [how now brown cow] -- Doing arithmetic on lists of x's. ---------------------------------- In what follows we present some pop-11 procedures that can operate on lists of x's in order to perform arithmetic operations. You will find each procedure presented with some documentation preceding it, saying what its name is, what inputs it takes, what output it takes, what it is for and giving some test examples. The tests can be run after the procedures are compiled. If you change any of the procedure definitions you should run the tests again. The procedure headers are produced using a command in the poplog editor Ved, namely ENTER procheader, whose use is explained in HELP * VED_PROCHEADER the procedures defined below are define isnum(item) -> boole; check whether item is a number and return true or false define addnums(num1, num2) -> sum; check whether num1 and num2 are numbers and if so return a new number which is their sum, otherwise mishap define subnums(num1, num2) -> diff; if num1 and num2 are numbers return a number that is their difference define subnums2(num1, num2) -> diff; another way of defining subnums define mult(num1, num2) -> product; if num1 and num2 are numbers return a number that is the result of multiplying num1 by num2 The next three are predicates for testing a relation between two or three numbers. They all return a boolean value, i.e. true or false. define samenum(num1, num2) -> boole; true if the numbers are the same define bigger(num1, num2) -> boole; true if num1 is bigger than num2 define between(num1, num2, num3) -> boole; true if num1 is between num2 and num3 Returning to arithmetical operators: define divide(num1, num2) -> (remainder, quotient); divide num1 by num2 and return the remainder and the quotient (num1 is the dividend, num2 the divisor) The file ends with a challenge to extend these ideas to negative numbers and some other challenges. -- First procedure: a number recognizer ------------------------------- We need a number recognizer, which will be used in many other procedures to check that they have been given a list, and failing that to produce an error message (or MISHAP message in Pop-11). We can define a number recognizer procedure as follows. It checks that it is given a list, and that the list contains only occurrences of the word "x". It returns the boolean true or the boolean false, depending on what it finds. A first problem is whether the empty list should be used to represent a number. An obvious answer is that it should represent the number 0. We shall take that option below, but you could consider whether the program could be changed so as not to allow the empty list. */ /* PROCEDURE: isnum (item) -> boole INPUTS : item is anything OUTPUTS : boole is a truth-value (boolean) USED IN : Many procedures below. CREATED : 30 May 2009 PURPOSE : Recognize a numeral in the form of a list that is either empty, i.e. [] or contains only occurrences of the word "x", e.g. [x] [x x x] ;;; specify some tests that will be used to check that the procedure ;;; works TESTS: isnum([x x x]) => ** <true> isnum([]) => ** <true> isnum([y y y]) => ** <false> isnum([xx]) => ** <false> isnum(99) => ** <false> */ define isnum(item) -> boole; lvars L; ;;; if the list is empty if islist(item) and item matches [] ;;; or the list starts with "x" followed by a number list or (islist(item) and item matches ![x ??L:isnum]) then true else false endif -> boole; enddefine; /* -- A procedure for adding two nums ------------------------------------ */ /* PROCEDURE: addnums (num1, num2) -> sum INPUTS : num1, num2 Where : num1 is a num num2 is a num OUTPUTS : sum is a num USED IN : several procedures below CREATED : 30 May 2009 PURPOSE : add two numbers (as lists) returning the sum (as a list). It should produce a mishap if given non-numbers. TESTS: addnums([], []) => ** [] addnums([x], []) => ** [x] addnums([], [x]) => ** [x] addnums([x x], [x x x]) => ** [x x x x x] addnums([x x], [y y]) => ;;; MISHAP - Nums needed for addnums ;;; INVOLVING: [y y] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : addnums runproc ;;; this should also produce a mishap (why?) addnums([xx], [xxx]) => ;;; MISHAP - Nums needed for addnums ;;; INVOLVING: [xx] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : addnums runproc */ define addnums(num1, num2) -> sum; ;;; first check that num1 and num2 satisfy isnum unless isnum(num1) then mishap('Nums needed for addnums', [^num1]); endunless; unless isnum(num2) then mishap('Nums needed for addnums', [^num2]); endunless; ;;; now we know they are both nums, so we can add them ;;; if either num1 or num2 is empty use the other as the result if num1 matches [] then num2 -> sum elseif num2 matches [] then num1 -> sum else ;;; add an "x" to num1 and reduce one from num2 ;;; and add the two resulting lists addnums([ x ^^num1], tl(num2)) -> sum endif enddefine; ;;; exercise: try defining a version of this using the Pop-11 concatenator ;;; operator <> /* -- A procedure to subtract a number from another ---------------------- */ /* PROCEDURE: subnums (num1, num2) -> diff INPUTS : num1, num2 Where : num1 is a number num2 is a number OUTPUTS : diff is a number USED IN : ??? CREATED : 21 Jun 2009 PURPOSE : ??? if num1 is bigger than or equal to num2 then return a number which when added to num2 gives num1 TESTS: subnums( [], [] ) => ** [] subnums( [x], [] ) => ** [x] subnums( [], [x] ) => ;;; MISHAP - subnums cannot subtract from zero ;;; INVOLVING: [] [x] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : subnums runproc subnums( [x x x], [x x x x] ) => ;;; MISHAP - subnums cannot subtract from zero ;;; INVOLVING: [] [x] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : subnums(*4) runproc subnums( [x x x x], [x x x x] ) => ** [] */ define subnums(num1, num2) -> diff; if isnum(num1) and isnum(num2) then if num2 matches [] then num1 -> diff elseif num1 matches [] then mishap('subnums cannot subtract from zero', [^num1 ^num2]); else ;;; subtract an "x" from both and return the difference subnums(tl(num1), tl(num2)) -> diff endif else mishap('Nums needed for subnums', [^num1 ^num2]); endif; enddefine; /* -- Another version, subnums2 using the pattern matcher ---------------- */ /* PROCEDURE: subnums2 (num1, num2) -> diff INPUTS : num1, num2 Where : num1 is a number num2 is a number OUTPUTS : diff is a number USED IN : ??? CREATED : 21 Jun 2009 PURPOSE : ??? if num1 is bigger than or equal to num2 then return a number which when added to num2 gives num1 TESTS: subnums2( [], [] ) => ** [] subnums2( [x], [] ) => ** [x] subnums2( [], [x] ) => ;;; MISHAP - Cannot subtract bigger number from smaller ;;; INVOLVING: [] [x] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : subnums2 runproc subnums2( [x x x], [x] ) => ** [x x] subnums2( [x x x], [x x x x] ) => ;;; MISHAP - Cannot subtract bigger number from smaller ;;; INVOLVING: [x x x] [x x x x] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : subnums2 runproc subnums2( [x x x x], [x x x x] ) => ** [] subnums2( [x x x x x x x x], [x x x x] ) => ** [x x x x] */ define subnums2(num1, num2) -> diff; if isnum(num1) and isnum(num2) then if num1 matches ![??diff ^^num2] then ;;; nothing else to do else mishap('Cannot subtract bigger number from smaller', [^num1 ^num2]) endif else mishap('Nums needed for subnums', [^num1 ^num2]); endif; enddefine; /* -- Multiplication as repeated addition -------------------------------- */ /* PROCEDURE: mult (num1, num2) -> product INPUTS : num1, num2 Where : num1 is a num num2 is a num OUTPUTS : product is a num USED IN : ??? CREATED : 30 May 2009 PURPOSE : multiply two numbers (as lists) returning the product TESTS: mult([], []) => ** [] mult([], [x x x x]) => ** [] mult([x x x x], []) => ** [] mult([x x x x], [x]) => ** [x x x x] mult([x], [x x x x]) => ** [x x x x] mult([x x], [x x x x]) => ** [x x x x x x x x] */ define mult(num1, num2) -> product; if isnum(num1) and isnum(num2) then if num1 matches [] then [] -> product elseif num2 matches [] then [] -> product else [] -> product; until num2 matches [] do addnums(num1, product) -> product; tl(num2) -> num2; enduntil; endif else mishap('Nums needed for product', [^num1 ^num2]); endif; enddefine; ;;; NOTE: ;;; A substantial chunk of the code in this procedure is redundant ;;; and can be removed, because of unobvious duplication. ;;; Which lines can be removed without changing the behaviour? ;;; Explain why? /* -- Some predicates for comparing numbers ------------------------------ -- -- samenum checks whether two numbers are the same */ /* PROCEDURE: samenum (num1, num2) -> boole INPUTS : num1, num2 Where : num1 is a number num2 is a number OUTPUTS : boole is a boolean USED IN : divide CREATED : 10 Aug 2009 PURPOSE : Testing numbers for equality true if the numbers are the same TESTS: samenum([], []) => ** <true> samenum([x], [x]) => ** <true> samenum([xx], [xx]) => ;;; MISHAP - Nums needed for samenum ;;; INVOLVING: [xx] [xx] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : samenum runproc samenum([x x], [x x]) => ** <true> samenum([x x x], [x]) => ** <false> samenum([], [x x]) => ** <false> */ define samenum(num1, num2) -> boole; if isnum(num1) and isnum(num2) then num1 matches num2 -> boole else mishap('Nums needed for samenum', [^num1 ^num2]); endif enddefine; /* -- -- bigger checks whether a number is bigger than another */ /* PROCEDURE: bigger (num1, num2) -> boole INPUTS : num1, num2 Where : num1 is a num num2 is a num OUTPUTS : boole is a boolean USED IN : divide CREATED : 30 May 2009 PURPOSE : determine whether num1 is bigger than num2 TESTS: bigger([], []) => ** <false> bigger([x], []) => ** <true> bigger([], [x]) => ** <false> bigger([x x], [x x]) => ** <false> bigger([x x x], [x x]) => ** <true> bigger([x x x x x], [x x]) => ** <true> bigger([x x], [x x x x]) => ** <false> bigger([xx], [xxxx]) => ;;; MISHAP - Nums needed for samenum ;;; INVOLVING: [xx] [xxxx] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : samenum bigger runproc */ define bigger(num1, num2) -> boole; ;;; note: we don't need to test that num1 and num2 are ;;; numbers, ad samenum does that if samenum(num1, num2) then false -> boole elseif num1 matches [] then false -> boole elseif num2 matches [] then true -> boole else bigger(tl(num1), tl(num2)) -> boole endif enddefine; /* -- -- between checks whether a number is between two others */ /* PROCEDURE: between (num1, num2, num3) -> boole INPUTS : num1, num2, num3 Where : num1 is a number num2 is a number num3 is a number OUTPUTS : boole is a boolean USED IN : CREATED : 21 Jun 2009 PURPOSE : Check whether num1 is between num2 and num3 in ascending or descending order TESTS: between([x], [x], [x]) => ** <false> between([x x], [x], []) => ** <false> between([x], [x x], []) => ** <true> between([x x], [x], [x x x]) => ** <true> between([x x], [x x], [x x x]) => ** <false> */ define between(num1, num2, num3) -> boole; (bigger(num3, num1) and bigger(num1, num2)) or (bigger(num2, num1) and bigger(num1, num3)) -> boole enddefine; /* -- A procedure to divide one number into another ---------------------- */ /* PROCEDURE: divide (num1, num2) -> (remainder, quotient); INPUTS : num1, num2 Where : num1 is a number (the dividend) num2 is a number (the divisor) OUTPUTS : remainder, quotient Where : remainder is a number quotient is a number USED IN : ??? CREATED : 21 Jun 2009 PURPOSE : given two numbers num1, num2, divide num1 by num2 and return quotient and remainder quotient is the number of times num2 goes into num1 remainder is the remainder after dividing num2 into num1 (The remainder should be less than num2). TESTS: divide([], []) => ;;; MISHAP - Cannot divide [] into [] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : divide runproc ;;; do the next two give reasonable answers? divide([], [x]) => ** [] [] divide([], [x x]) => ** [] [] divide([x], []) => ;;; MISHAP - Cannot divide [] into [x] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : divide runproc divide([x], [x]) => ** [] [x] divide([x x x x], [x x x x]) => ** [] [x] divide([x x x x], [x x]) => ** [] [x x] divide([x x x x x x x], [x x x]) => ** [x] [x x] divide([x x x x x x x x x], [x x x]) => ** [] [x x x] */ define divide(num1, num2) -> (remainder, quotient); ;;; we don't need to check that they are numbers as ;;; bigger and samenum will do that if num2 == [] then mishap('Cannot divide [] into ' >< num1, []); elseif bigger(num2, num1) then [] -> quotient; num1 -> remainder elseif samenum(num1, num2) then [x] -> quotient; [] -> remainder else divide(subnums(num1, num2), num2) -> (remainder, quotient); addnums([x], quotient) -> quotient; endif; enddefine; /* -- A hard problem: how to represent and operate on negative numbers --- */ /* What should subnums do if the second number is larger than the first? subnums([x x], [x x x]) => At present it gives this mysterious error message (which could be modified of course): ;;; MISHAP - subnums cannot subtract from zero ;;; INVOLVING: [] [x] ;;; FILE : /home/axs/popd/teachnums.p ;;; DOING : subnums(*3) runproc You have been taught that the result of subtracting 3 from 2 should be a negative number. But what is a negative number? How can you represent negative numbers using lists? How should they be added, subtracted or multiplied? Why should multiplying two negative numbers give a positive number? Try to find ways of extending this package that are not totally arbitrary and give a sensible interpretation of negative numbers. If you come up with a suggestion please write to me about it (email address at end of this file). THERE IS NO UNIQUE RIGHT ANSWER If you find an answer feel free to email me about it (address at bottom of file), or post it on the comp.lang.pop forum. You may find this paper by Pamela Liebeck relevant, if you can get hold of it. Pamela Liebeck, Scores and Forfeits: An Intuitive Model for Integer Arithmetic, Educational Studies in Mathematics, Vol 21, No 3, June, 1990, pp. 221--239, Available on JSTOR here from subscribing academic institutions: http://links.jstor.org/sici?sici=0013-1954%28199006%2921%3A3%3C221%3ASAFAIM%3E2.0.CO%3B2-N */ /* -- Another hard problem: how to divide 4 by 7 and produce a fraction -- */ /* At present dividing a number by another number using the procedure divide, defined above, gives a remainder and a quotient, as in these examples: divide([x x x x x x x x], [x x x])=> ** [x x] [x x] divide([x x x x x x x x], [x x x x])=> ** [] [x x] divide([x x x x x x x x], [x x x x x])=> ** [x x x] [x] divide([x x], [x x x])=> ** [x x] [] divide([x x x], [x x x x x])=> ** [x x x] [] Can you think of a way of changing the procedure divide(num1, num2), so that instead of producing two numbers as its result it produces a single object that can be thought of as a ratio (num1/num2). The way you represent ratios should have the property that if you divide num1 by num2 to get a ratio, then if you multiply that ratio by num2 you should get back to num1. Can you make this work with negative as well as positive numbers. The key idea is to think of a good way to represent ratios so that they preserve all the required information, but have no redundant information. If you come up with a suggestion please write to me about it (email address at end of this file). THERE IS NO UNIQUE RIGHT ANSWER If you find an answer feel free to email me about it (address at bottom of file), or post it on the comp.lang.pop forum. */ /* -- Introducing 'place' notation to compress number representations ---- */ /* If you use the notation developed here to represent numbers you will soon realise that it is analogous to representing numbers by sequences of strokes: | || ||| |||| ||||| |||||| In principle any number, no matter how large, could be represented either as a sequence of strokes, or as a list of x's. However this can get very unwieldy for very large numbers. E.g. this is how the number 217 could look (with the list 'folded' to fit within a reasonable width: [x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x] And this is how it could look using the stroke notation without spaces: ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| |||||||||||||||| Compare that with the brevity of using three digits in "217". This works because the numbers are interpreted as keep the right most number add 10 times the number next left add 100 times the number next left ..... giving 7 + 10x1 + 100x2, or, if you prefer 2x100 + 10x1 + 7 Try working out a way to get a comparable compression using lists of x's so that instead of a number like 217 being represented by one long list of x's it is represented by three much shorter lists. If you can develop such a notation try designing and testing some procedures to convert between the above simple-minded list notation and a place-based notation. Also modify the procedures for adding, subtracting, multiplying and dividing so that they can handle numbers represented in the new way. THERE IS NO UNIQUE RIGHT ANSWER If you find an answer feel free to email me about it (address at bottom of file), or post it on the comp.lang.pop forum. */ /* -- Can you use numbers for counting? ---------------------------------- */ /* (a) If I give you a list of words, and ask you how many there are, you can point at them in turn as you recite number names, and when you get to the end you can announce the final name as the answer to the 'how many' question. (b) Alternatively if I give you a list of words and ask you to give me a list containing the first three words, or the first nine words, you can count along the list until you get to the number specified, and make a list of all the words you have counted. */ /* -- -- Try problem (a) */ /* Can you define a procedure how_many that performs the first task? It is useful to use the fact that in Pop-11, code run in brackets like this will create a list of the values produced in the code: [% .... %] That construct could be used in a how_many procedure: */ define how_many(list) -> number; lvars item; ;;; go through the list and create a new one representing a number ;;; of the types used above. [% for item in list do ;;;; what exactly ??? endfor %] -> number; enddefine; /* ;;; Test it thus (and define some more tests of your own) how_many([ the hat ]) => ;;; should produce ** [x x] whereas how_many([the man with a hat is blind as a bat ]) => ;;; should produce ** [x x x x x x x x x x] ;;; What should this do? how_many([ ]) => */ /* -- -- Try problem (b) */ /* Can you define a procedure count_out that performs the second task, namely to produce a specified number of elements from a list. */ define count_out(items, number) -> list; ;;; what should go in here? ;;; you need a look to generate the numbers, one at a time, ;;; and as you do that you save an item from the list items. ;;; when you generate the target number given, the program can stop ;;; counting and return the list of saved items. enddefine; /* ;;; Test it thus (and define some more tests of your own) ;;; save a list of words for re-use vars words = [the man with a hat is blind as a bat]; count_out(words, [x x]) => should produce ** [the man] count_out(words, [x x x x x]) => should produce ** [the man with a hat] What should this do ? count_out(words, []) => */ /* -- Introducing numerals ----------------------------------------------- */ /* There are many things we use numbers for which would be very clumsy if we were to use lists of 'x's as names. So it would be useful to have Pop-11 words as names, providing a short hand notation. E.g. "one" could be a name for [ x ] "two" could be a name for [ x x ] "three" could be a name for [ x x x] "four" could be a name for [ x x x x ] and so on. Can you find a way of setting up a mapping between the words and the numbers, where the numbers are represented as lists of 'x's? If you do that, how could you modify the previous two definitions so that how_many([ the hat ]) => produces ** two and count_out(words, "five") => produces ** [the man with a hat] */ /* -- How about using place notation with number names? ------------------ */ /* Could you produce a program that understands the words nought one two .... nine and then can interpret lists of those words as representing numbers in the usual decimal way, e.g. what_number([three]) => should produce [x x x] what_number([three five]) => should produce a list of 35 'x's [x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x] what_number([three five nine]) => should produce a list of 359 'x's, and so on. What should these produce what_number([three five nought]) => what_number([three nought five]) => what_number([nought three five]) => what_number([nought nought three five]) => */ /* -- More information --------------------------------------------------- For more information on poplog see http://www.cs.bham.ac.uk/research/projects/poplog/freepoplog.html There is a section on teaching using Pop-11 http://www.cs.bham.ac.uk/research/projects/poplog/freepoplog.html#teaching There is a Pop-11 primer here: http://www.cs.bham.ac.uk/research/projects/poplog/primer/ ======== Aaron Sloman Email: A.Sloman@cs.bham.ac.uk http://www.cs.bham.ac.uk/~axs --- ?????/teachnums.p --- Copyright University of Birmingham 2009. All rights reserved. --- See http://www.cs.bham.ac.uk/research/projects/poplog/copyright.html */