Chapter 2. Numbers - Perl Cd Bookshelf [Electronic resources] نسخه متنی

Chapter 2. Numbers

Contents:

Introduction

Checking Whether a String Is a Valid Number

Rounding Floating-Point Numbers

Comparing Floating-Point Numbers

Operating on a Series of Integers

Working with Roman Numerals

Generating Random Numbers

Generating Repeatable Random Number Sequences

Making Numbers Even More Random

Generating Biased Random Numbers

Doing Trigonometry in Degrees, Not Radians

Calculating More Trigonometric Functions

Taking Logarithms

Multiplying Matrices

Using Complex Numbers

Converting Binary, Octal, and Hexadecimal Numbers

Putting Commas in Numbers

Printing Correct Plurals

Program: Calculating Prime Factors

John von Neumann (1951)

Anyone who considers arithmetical methods of producing random digits
is, of course, in a state of sin.

2.0. Introduction

Numbers,
the most basic data type of almost any programming language, can be
surprisingly tricky. Random numbers, numbers with decimal points,
series of numbers, and conversion between strings and numbers all
pose trouble.

Perl works hard to make life easy for you,
and the facilities it provides for manipulating numbers are no
exception to that rule. If you treat a scalar value as a number, Perl
converts it to one. This means that when you read ages from a file,
extract digits from a string, or acquire numbers from any of the
other myriad textual sources that Real Life pushes your way, you
don't need to jump through the hoops created by other languages'
cumbersome requirements to turn an ASCII string into a number.

Perl
tries its best to interpret a string as a number when you use it as
one (such as in a mathematical expression), but it has no direct way
of reporting that a string doesn't represent a valid number. Perl
quietly converts non-numeric strings to zero, and it will stop
converting the string once it reaches a non-numeric
character—so "A7" is still
0, and "7A" is just
7. (Note, however, that the -w flag will warn of such improper
conversions.) Sometimes, such as when validating input, you need to
know whether a string represents a valid number. We show you how in
Recipe 2.1.

Recipe 2.15 shows how to get a number from
strings containing hexadecimal, octal, or binary representations of
numbers such as "0xff", "0377",
and "0b10110". Perl automatically converts numeric
literals of these non-decimal bases that occur in your program code
(so $a = 3
+ 0xff will set
$a to 258) but not data read by that program (you
can't read "ff" or even "0xff"
into $b and then say $a
= 3 +
$b to make $a become 258).

As
if integers weren't giving us enough grief, floating-point numbers
can cause even more headaches. Internally, a computer represents
numbers with decimal points as floating-point numbers in binary
format. Floating-point numbers are not the same as real numbers; they
are an approximation of real numbers, with limited precision.
Although infinitely many real numbers exist, you only have finite
space to represent them, usually about 64 bits or so. You have to cut
corners to fit them all in.

When numbers are read from a file or appear as literals in your
program, they are converted from their textual
representation—which is always in base 10 for numbers with
decimal points in them—into an internal, base-2 representation.
The only fractional numbers that can be exactly represented using a
finite number of digits in a particular numeric base are those that
can be written as the sum of a finite number of fractions whose
denominators are integral powers of that base.

For example, 0.13 is one tenth plus three one-hundredths. But that's
in base-10 notation. In binary, something like 0.75 is exactly
representable because it's the sum of one half plus one quarter, and
2 and 4 are both powers of two. But even so simple a number as one
tenth, written as 0.1 in base-10 notation, cannot be rewritten as the
sum of some set of halves, quarters, eighths, sixteenths, etc. That
means that, just as one third can't be exactly represented as a
non-repeating decimal number, one tenth can't be exactly represented
as a non-repeating binary number. Your computer's internal binary
representation of 0.1 isn't exactly 0.1; it's just an approximation!

$ perl -e 'printf "%.60f\n", 0.1'
0.100000000000000005551115123125782702118158340454101562500000

Recipe 2.2 and Recipe 2.3
demonstrate how to make your computer's floating-point
representations behave more like real numbers.

Recipe 2.4 gives three ways to perform one
operation on each element of a set of consecutive integers. We show
how to convert to and from Roman numerals in Recipe 2.5.

Random
numbers are the topic of several recipes. Perl's
rand function returns a floating-point value
between 0 and 1, or between 0 and its argument. We show how to get
random numbers in a given range, how to make random numbers more
random, and how to make rand give a different
sequence of random numbers each time you run your program.

We round out the chapter with recipes on trigonometry, logarithms,
matrix multiplication, complex numbers, and the often-asked question:
"How do you put commas in numbers?"