Search Top Index

TEACH DECIMALS A.Sloman July 1988 Decimal Numbers --------------- TEACH * ARITH should be read before this file. This file describes so-called 'decimal numbers', that is numbers with decimal points in them. CONTENTS - (Use <ENTER> g to access required sections) -- Decimals and integers -- Using -dataword- to recognise decimals -- Single and double decimals -- Using popdprecision -- Don't use = or == on decimals -- An example: computing the mean of a list of numbers -- More on coercions -- Exercises -- Floating point numbers -- Sensible calculations -- Reading in decimals -- Arithmetic operations available -- More Exercises -- Further reading -- Decimals and integers ----------------------------------------------- Numbers without decimal points are integers. The following are 'integers': 3, 1, 0, -126 whereas the following are all decimal numbers: 3.42, 1.07, 0.003, -126.237, 3.2e-3 The last is equivalent to 3.2 times 10 to the power -3, i.e. 0.0032. 3.2e-3 => ** 0.0032 3.2 * (10 ** -3) => ** 0.0032 Warning: POP-11 doesn't accept 3.2E-3, or .6 as decimals, as some languages do. You must have something before the decimal point, even if it is '0', and use lower-case "e" for the exponent, e.g.: 3.2e-3 or 0.6. Sometimes decimals are called 'reals'. -- Using -dataword- to recognise decimals ------------------------------ Try: dataword(1) => ** integer vars x = 5.3 + 2.6, y = 33; dataword(x) => ** decimal dataword(y) => ** integer I.e. if you add or multiply or divide two decimal numbers you will get a decimal number. -- Single and double decimals ------------------------------------------ POP-11 also has 'double decimal' numbers. These are more accurate numbers and have the dataword "ddecimal". These take up more space in the computer, but can be used for more accurate (and slower) calculations. A decimal number expression typed in directly is interpreted as a ddecimal, not a decimal. E.g. dataword(3.4) => ** ddecimal Whereas if it is the result of an operation like addition or multiplication it will normally be a single decimal: dataword(3.4 + 0.0) => ** decimal -- Using popdprecision ------------------------------------------------- You can change the Pop-11 operators so that instead of producing a single precision decimal result, they produce a double precision result. true -> popdprecision; dataword(3.4 * 999) => ** ddecimal false -> popdprecision; dataword(3.4 + 999) => ** decimal As the above examples show, operations combining a decimal and an integer, will produce a decimal result. (This is called "coercion" the integer is co-erced into the form of a decimal before the operation is performed.) -- Don't use = or == on decimals --------------------------------------- The most important thing to remember about decimal numbers is that they are inherently imprecise. E.g. 10.0 divided by 3.0 should be an infinite decimal, whereas the computer does not have enough memory for that, so it stores an approximation. 10.0 / 3.0 => ** 3.333333 This is partly because the computer cannot really cope with decimal numbers and tends to get its sums slightly wrong, so that 1.0 + 1.0 might work out as 1.99999 (or perhaps 2.00001). So if you write: if num == 678.325 then ... You might not get the behaviour you had expected. Instead test whether two numbers are within some "tolerance", i.e. test whether their difference is less than some specified amount. if abs(num - 678.325) < 0.00001 then ... N.B. ABS (short for absolute 'value') always returns a positive number (more precisely a non-negative number). Of course, it is up to you to decide what the "tolerance" should be. E.g. for some problems you might type: if abs(num - 678.325) < 0.1 then ... -- An example: computing the mean of a list of numbers ----------------- The following procedures compute the 'mean', (or average) of a list of numbers. First a procedure to add up the numbers in a list. Notice that the number 0.0 is used to start the addition, in order to ensure that the result is a decimal number. define sum(list) -> result; if list == [] then 0.0 -> result else hd(list) + sum(tl(list)) -> result endif enddefine; define mean(list); sum(list) / length(list) enddefine; mean([1 2 3 4]) => ** 2.5 mean([1 2 3]) => ** 2.0 -- More on coercions --------------------------------------------------- The arithmetic operations + - and * will return an integer only if both their arguments are integers. If given two integers the division operator / returns a RATIO if there would be a remainder, that is: 8 / 4 => ** 2 (an integer) 9 / 4 => ** 9_/4 (a ratio) If one of the numbers is a decimal then the result will also be a decimal: 9 / 4.0 => ** 2.25 9.0 / 4 => ** 2.25 You can make POP-11 print ratios as if they were decimals by doing: false -> pop_pr_ratios; Then: 9 / 4 => ** 2.25 (a ratio printed as a decimal) -- Exercises ---------------------------------------------------------- Write a procedure called SQUARE, which takes as argument a list of numbers, for example: square([1 2 3 4]) => and returns a list of the squares of the number, that is ** [1 4 9 16] Use this procedure to write MEANSQ, a procedure to compute the average of the squares of a set of numbers, that is meansq([1 2 3 4]) => ** 7.5 Notice, this is not the same as: mean([1 2 3 4]) * mean([1 2 3 4]) => which is: ** 6.25 -- Floating point numbers ---------------------------------------------- Decimal numbers are sometimes called 'floating point numbers', or just 'floats'. This is because their accuracy is measured in terms of 'number of significant digits' rather than absolute value. Normally POP11 will not print out a decimal showing all the significant digits, because it is limited by the value of pop_pr_places, which defaults to 6. 0.1234567890123456789 => ** 0.123457 However, you can make it print out more significant digits (if the number has any) by doing something like: 20 -> pop_pr_places; You can then see how many significant figures are stored in various situations: 0.1234567890123456789 => ** 0.1234567890123457 10 / 3.0 => ** 3.33333 true -> popdprecision; 10 / 3.0 => ** 3.333333333333333 In POP11, the first six digits of a decimal number (excluding leading zeroes) are usually significant no matter where the decimal point is. However, this will generally depend on the kind of machine that is used. -- Sensible calculations ----------------------------------------------- Because the decimal point can 'float', multiplying a decimal number by, say, ten doesn't affect its accuracy. 20 -> pop_pr_places; false -> popdprecision; vars x = 10 / 3.0; x => ** 3.33333 x * 10 => ** 33.3333 x * 100 => ** 333.333 x * 10000000 => ** 33333300.0 An implication of this is that some operations make sense and others don't. E.g.: 123456.0 + 654321.0 => ** 777777.0 is reasonable, as is: 1.23456 + 6.54321 => ** 7.77777 but the following has a second argument whose precision is spurious: 123456.0 + 6.54321 => ** 123463.0 The result is accurate to only, six significant figures. (The result may, as here, be 'rounded up'.) -- Reading in decimals ------------------------------------------------- In general numbers are read as 'double decimal' numbers (accurate to more significant figures), but results of computations will be 'single decimal numbers. e.g. try : dataword(9/4) => ** ratio dataword(2.25) => ** ddecimal The accuracy of decimals resulting from compilations can be increased by assigning TRUE to POPDPRECISION. (See REF * POPDPRECISION.) -- Arithmetic operations available ------------------------------------- The following procedures are available for manipulating decimal numbers. SQRT(X) square root. sqrt(100) => ** 10.0 If applied to a negative number, this will produce a "complex" number with a zero "real" part and a non-zero "imaginary" part. sqrt(-100) => ** 0.0_+:10.0 The symbol "_+:" joins two integers or decimal numbers to form a complex number. INTOF(X) Given a decimal number this procedure returns the integer part, for example: intof(3.6) => ** 3 N.B., if X is negative then intof(x) = -intof(-x) so intof(-3.6) => ** -3 ROUND(X) Given a decimal number this procedure returns the closest integer, for example: round(3.5) => ** 4 round( -3.5) => ** -4 REALOF(X) Given an integer this procedure returns the corresponding decimal number, for example: realof(3) => ** 3.0 If X is an integer then: x = intof(realof(x)) The above is not a complete list. See below. -- More Exercises ------------------------------------------------------ Suppose you know that a group of workers earn the following sums of money a week: [112.34 96.40 87.05 103.56 99.39] (rather a small sample!). Extrapolating from this sample how probable do you consider it that: the average worker earns, say, 92.07 a week? Write a procedure which compares this probability. Suppose, further, that the same group of workers is paid (as opposed to earns): [37.24 83.00 130.45 65.75 82.00] (People don't always get paid what they've earned. E.g. tax may be deducted!) Write a procedure to guess what someone is paid given what they earn, also compute a measure of 'confidence' in this value. Hint: Think of the problem in terms of fitting a curve to points on a graph. As a first approximation try fitting a straight line to the points. The above figures aren't too good for this, try instead a height/weight table or something similar. -- Further reading ----------------------------------------------------- TEACH * ARITH TEACH * STATS For a summary of available arithmetical facilities, try HELP * MATH For fuller information on numbers in POP-11 see HELP * NUMBERS For complete information see REF * DATA, REF* NUMBERS --- C.all/teach/decimals ----------------------------------------------- --- Copyright University of Sussex 1987. All rights reserved. ----------