COAET" • r

here is: Don't always expect books to tell you what the
computer is going to do.
2) Real Number Input
It's a frustrating thing to be forced to write your own
routine to accomplish a certain task when you know.that
such a routine already exists, but is inaccessible to you. One
such example in the Pascal system is the conversion of a
string of characters into a number. The system "knows"
how to do the translation - it happens every time a value is
typed in at the keyboard or read from a text file. But if you
want your program to do the same thing, you'll have to write
your own procedure to do it, because the system hides the
procedure from you.
Let's assume you want to write a routine to translate a
string of characters into a real number. One of the things
you should know while writing such a module is the smallest
and largest positive real numbers the system can represent,
so your routine can avoid over- and underflows. To determine
these values, you might write a program like this:
program readreal;
var
x: real
begin
while TROE do
begin
write('Enter x':);
readln(x);
writeln('x = ',x)
end
end.
This program will blow up with a floating point execution
error if you type in a number too large or too close to zero.
With experimentation, you'll find that the largest real
number Pascal can represent is approximately 3.40E38,
and the smallest positive real number is approximately
l.18E-38. Or, more accurately, these are the limits on the
numbers one can enter using the READ procedure.
A problem arises when you try to incorporate the smaller
number into a program. If you use the lines:
const
TINY = 1.18E-38
or even:
IF X >+ l.18e-38 THEN ...
. .. the Pascal compiler will ·(Kaboom!) self-destruct on
attempting to translate the number. To be more precise, the
compiler program itself will halt with a floating point execution
error.
What does this mean? Apparently, there are actually two
different routines in the Pascal system for translating strings
of characters into real numbers: one used by the READ
statement, and one used by the compiler. And the routine
the compiler uses will not translate some numbers which
offer no problem to the other one.
Here's an example of another symptom of having two
different real number conversion routines:
program realtest;
var
x: real;
56 Apple Orchard
begin
repeat
write('Enter x':);
readln(x);
writeln('x = ',x)
until x = 2. 718281828
end.
Most programmers know better than to compare two
floating point numbers for exact equality. But in this example
we might reasonably expect such a comparison to work
If you enter "2.718281828" the program should react normally,
shouldn't it? Well, in Apple Pascal, it doesn't. The two
different conversion routines translate the strings (in the
program and in the READ statement) into two ever so
slightly different floating point representations. The comparison
fails, and the program continues on.
There's no good reason why there should be more than
one such routine in the Apple Pascal system. (The one you
may have to write will be at least the third!) A major benefit of
using a modular programming language like Pascal is that
one can write a single reliable procedure to accomplish a
given task, and use it in a variety of applications. The moral:
Duplicated programming effort is not only wasteful, but it
can lead to -er, "features"-
in your programs.
3)Real Number Output .
We just discussed the frustration one feels when a routine
must be written to do something the system already knows
how to do. Another kind of pain results when the language
texts and system documentation spell out in detail what. a
given funtion does in different circumstances -.and th~n m
practice the function actually does something entirely
different.
Such is the case with the standard procedures WRITE or
WRITELN when they are used to output real numbers. Most
texts, as well as Apple's own documentation, (see the Apple
Pascal Language Reference Manual, Pages 36-37) describe
the procedure as follows: The statement:
WRITELN(X: W: D)
... will cause the real number X to be written, after it is
converted to a string. The optional variables W and D control
the output format; Wis the minimum number of characters
that will be printed, and D is the number of digits to be
printed after the decimal point. .
So far, so good. Consider the program m Listing 2:
LISTING 2
program testwrite;
var
w, d, i: integer;
x: real;
begin
x := 0.123456;
w:=20;
d := 8;
for i := 1 to 10 do
begin
writeln(x: w: d);
x*·(lO*x)
end
end.
'
,