FLOATING POINT PACKAGE
Locations 55296 through 57343 hold the floating point package, a series of routines to do floating point math. For an explanation of how the Atari stores floating point numbers, see VVTP at locations 134 and 135. For information on the floating point registers, see locations 212 through 255. Finally, for information on the input and output buffers see INBUFF at 243 and 244, and LBUFF at 1408 through 1535.
The following is a list of some of the more useful routines in the package. The trigonometric functions are in the BASIC cartridge starting at location 48551.
Note that in routines that use the carry bit (as indicated), if the carry is set at the end of the routine, then an error occurred. If it's clear, then everything is OK.
This routine takes an ATASCII representation of a number (i.e., "12345") and converts it to floating point (with carry). INBUFF points to the ATASCII number, floating point register zero (FR0) will hold the result.
You may be wondering why such a routine would be needed, and that's a very good thing to wonder. Suppose you had the following line in BASIC:
250 X =3.14159*37.5
When you type in such a line, BASIC sees the numbers as nothing more than a bunch of ATASCII characters. Before it can do the math, it must convert those characters into numbers it can understand. That's what AFP is for. BASIC will use AFP on both numbers (moving one of them to FR1), do the multiplication, and then store the result in X. AFP is also needed for BASIC's STR$ function.
FASC does just the opposite of AFP. It takes a floating point number from FR0 and stores the ATASCII representation in LBUFF. This is necessary when a number needs to be printed on the screen, and also for BASIC's VAL function.
IFP is used to convert integers to floating point. It expects to see the integer in the first two bytes of FR0 (locations 212 and 213) and will store the result in FR0.
This does the exact opposite of IFP (with carry).
ZFR0 sets all the bytes in FR0 to zero.
ZFI or AFI
Sets FRx to zero, where x is the value in the X register.
FSUB subtracts FR1 from FR0 (with carry) and stores the result in FR0.
Adds FR1 to FR0 (with carry) and stores the result in FR0 (notice that FADD is actually a part of FSUB).
Multiplies FR0 by FR1 (with carry) and stores the result in FR0.
Divides FR0 by FR1 (with carry) and stores the result in FR0.
This one is a little complicated, so bear with me. PLYEVL evaluates a polynomial, such as 5*Z^4+10*Z^2+2*Z+1 (read "five Z to the fourth plus ten Z squared plus two Z plus one"). For the sake of this routine, we'll write such a polynomial as
SUM (I=N to 0) (A(I)*Z^I)
So in the preceding example, N=4, A(0)=1, A(1)=2, A(2)=10, A(3)=0 (since there is no Z cubed), and A(4)=5.
Why are we doing all of this? When you call PLYEVL, it expects you to provide the following information:
Somewhere in memory: a list of the A( ) values, in floating point format (BCD), starting with A(0).
X register: low byte of the starting address of the preceding list.
Y register: high byte of the starting address of the preceding list.
PLYEVL will take all of this and use it to evaluate the polynomial (with carry). The result will be stored in FR0.
FLD0R will load FR0 with the floating point number pointed to by the X and Y registers. X should hold the low byte of the address of this number, Y the high.
FLD0P will load FR0 with the floating point number pointed to by FLPTR (252).
FLD1R will load FR1 with the floating point number pointed to by the X and Y registers. X should hold the low byte of the address of this number, Y the high.
FLD1P will load FR1 with the floating point number pointed to by FLPTR (252).
FST0R will store FR0 in memory, starting at the address pointed to by the X and Y registers. X should hold the low byte of this address, Y the high.
FST0P will store FR0 in memory, starting at the address pointed to by FLPTR (252).
FMOVE moves the floating point number in FR0 to FR1.
EXP raises "e" to the FR0 power and stores the result in FR0 (FR0 = e^FR0).
EXP10, as you may have guessed, raises 10 to the FR0 power and stores the result in FR0 (FR0= 10^ FR0). Notice that it is actually part of the EXP routine.
LOG figures out the natural logarithm (base e) of FR0 and stores it back in FR0.
LOG10 figures out the base 10 logarithm of FR0 and stores it back in FR0. Notice that it is part of the LOG routine.
Return to Table of Contents | Previous Chapter | Next Chapter