Chapter 3
Understanding Scalar Values
CONTENTS
ToChapter's lesson describes everything you need to know about scalar
values in Perl. ToChapter, you learn about the following:
 Scalar values
 How integers are represented
 Floatingpoint values
 The octal and hexadecimal notations
 Character strings, and using the doublequote and singlequote
characters to enclose them
 Escape sequences
 The interchangeability of character strings and numeric values
Basically, a scalar value is one unit of data. This unit
of data can be either a number or a chunk of text.
There are several types of scalar values that Perl understands.
ToChapter's lesson describes each of them in turn and shows you how
you can use them.
The most common scalar values in Perl programs are integer scalar
values, also known as integer constants or integer literals.
An integer scalar value consists of one or more digits, optionally
preceded by a plus or minus sign and optionally containing underscores.
Here are a few examples:
14
10000000000
27
1_000_000
You can use integer scalar values in expressions or assign them
to scalar variables, as follows:
$x = 12345;
if (1217 + 116 == 1333) {
# statement block goes here
}
In Perl, there is a limit on the size of integers included in
a program. To see what this limit is and how it works, take a
look at Listing 3.1, which prints out integers of various sizes.
Listing 3.1. A program that displays integers and illustrates
their size limitations.
1: #!/usr/local/bin/perl
2:
3: $value = 1234567890;
4: print ("first value is ", $value, "\n");
5: $value = 1234567890123456;
6: print ("second value is ", $value, "\n");
7: $value = 12345678901234567890;
8: print ("third value is ", $value, "\n");
$ program3_1
first value is 1234567890
second value is 1234567890123456
third value is 12345678901234567168
$
This program assigns integer scalar values
to the variable $value, and then prints $value
Lines 3 and 4 store and print the value 1234567890 without
any difficulty. Similarly, lines 5 and 6 successfully store and
print the value 1234567890123456.
Line 7 attempts to assign the value 12345678901234567890
to $value. Unfortunately, this number is too big for
Perl to understand. When line 8 prints out the value assigned
to $value, it prints out
12345678901234567168
As you can see, the last three digits have been replaced with
different values.
Here's what has happened: Perl actually stores integers in the
floatingpoint registers on your machine. In other words, integers
are treated as if they are floatingpoint numbers (numbers containing
decimal points).
On most machines, floatingpoint registers can store approximately
16 digits before running out of space. As the output from line
8 shows, the first 17 digits of the number 12345678901234567890
are remembered and stored by the Perl interpreter, and the rest
are thrown away. This means that the value printed by line 8 is
not the same as the value assigned in line 7.
This somewhat annoying limitation on the number of digits in an
integer can be found in almost all programming languages. In fact,
many programming languages have an upper integer limit of 4294967295
(which is equal to 232 minus 1).
The number of digits that can be stored varies from machine to
machine. For a more detailed explanation, refer to the discussion
of precision in the following section, "FloatingPoint Scalar
Values."

An integer constant that starts with a 0 is a special case:
$x = 012345;
The 0 at the beginning of the constant (also known as a leading zero) tells the Perl interpreter to treat this as an octal integer constant. To find out about octal integer constants, refer to the section called "Using Octal
and Hexadecimal Notation" later toChapter

As you have just seen, integers in Perl actually are represented
as floatingpoint numbers. This means that an integer scalar value
is actually a special kind of floatingpoint scalar value.
In Perl, a floatingpoint scalar value consists of all of the
following:
 An optional minus sign ()
 A sequence of digits, optionally containing a decimal point
 An optional exponent
Here are some simple examples of floatingpoint scalar values:
11.4
275
0.3
.3
3.
The optional exponent tells the Perl interpreter to multiply or
divide the scalar value by a power of ten. An exponent consists
of all of the following:
 The letter e (E is also acceptable)
 An optional + or 
 A one, two, or threedigit number
The number in the exponent represents the value by which to multiply
or divide, represented as a power of 10. For example, the exponent
e+01 tells the Perl interpreter to multiply the scalar
value by 10 to the power of 1, or 10. This means that the scalar
value 8e+01 is equivalent to 8 multiplied by 10, or 80.
Similarly, the exponent e+02 is equivalent to multiplying
by 100, e+03 is equivalent to multiplying by 1,000, and
so on. The following scalar values are all equal:
541e+01
54.1e+02
5.41e+03
A negative exponent tells the Perl interpreter to divide by 10.
For example, the value 54e01 is equivalent to 54 divided
by 10, or 5.4. Similarly, e02 tells the Perl interpreter
to divide by 100, e03 to divide by 1,000, and so on.
The exponent e+00 is equivalent to multiplying by 1,
which does nothing. Therefore, the following values are equal:
5.12e+00
5.12
If you want, you can omit the + when you multiply by
a power of ten.
5.47e+03
5.47e03
Listing 3.2 shows how Perl works with and prints out floatingpoint
scalar values.
Listing 3.2. A program that displays various floatingpoint
scalar values.
1: #!/usr/local/bin/perl
2:
3: $value = 34.0;
4: print ("first value is ", $value, "\n");
5: $value = 114.6e01;
6: print ("second value is ", $value, "\n");
7: $value = 178.263e+19;
8: print ("third value is ", $value, "\n");
9: $value = 123456789000000000000000000000;
10: print ("fourth value is ", $value, "\n");
11: $value = 1.23e+999;
12: print ("fifth value is ", $value, "\n");
13: $value = 1.23e999;
14: print ("sixth value is ", $value, "\n");
$ program3_2
first value is 34
second value is 11.460000000000001
third value is 1.7826300000000001e+21
fourth value is 1.2345678899999999e+29
fifth value is Infinity
sixth value is 0
$
As in Listing 3.1, this program stores and
prints various scalar values. Line 3 assigns the floatingpoint
value 34.0 to $value. Line 4 then prints this
value. Note that because there are no significant digits after
the decimal point, the Perl interpreter treats 34.0 as
if it is an integer
Line 5 assigns 114.6e01 to $value, and line
6 prints this value. Whenever possible, the Perl interpreter removes
any exponents, shifting the decimal point appropriately. As a
result, line 6 prints out
11.460000000000001
which is 114.6e01 with the exponent e01 removed
and the decimal point shifted one place to the left (which is
equivalent to dividing by 10).
Note that the number printed by line 6 is not exactly equal to
the value assigned in line 5. This is a result of roundoff
error. The floatingpoint register cannot contain the exact
value 11.46, so it comes as close as it can. It comes
pretty closein fact, the first 16 digits are correct. This number
of correct digits is known as the precision, and it is
a property of the machine on which you are working; the precision
of a floatingpoint number varies from machine to machine. (The
machine on which I ran these test examples supports a floatingpoint
precision of 16 or 17 digits. This is about normal.)
NOTE 
The size of an integer is roughly equivalent to the supported floatingpoint precision. If a machine supports a floatingpoint precision of 16 digits, an integer can be approximately 16 digits long.

Line 6 shows that a floatingpoint value has its exponent removed
whenever possible. Lines 7 and 8 show what happens when a number
is too large to be conveniently displayed without the exponent.
In this case, the number is displayed in scientific notation.
In scientific notation, one digit appears before the decimal
point, and all the other significant digits (the rest of the machine's
precision) follow the decimal point. The exponent is adjusted
to reflect this. In this example, the number
178.263e+19
is converted into scientific notation and becomes
1.7826300000000001e+21
As you can see, the decimal point has been shifted two places
to the left, and the exponent has, as a consequence, been adjusted
from 19 to 21. As before, the 1 at
the end is an example of roundoff error.
If an integer is too large to be displayed conveniently, the Perl
interpreter converts it to scientific notation. Lines 9 and 10
show this. The number
123456789000000000000000000000
is converted to
1.2345678899999999e+29
Here, scientific notation becomes useful. At a glance, you can
tell approximately how large the number is. (In conventional notation,
you can't do this without counting the zeros.)
Lines 11 and 12 show what happens when the Perl interpreter is
given a number that is too large to fit into the machine's floatingpoint
register. In this case, Perl just prints the word Infinity.
The maximum size of a floatingpoint number varies from machine
to machine. Generally, the largest possible exponent that can
be stored is about e+308.
Lines 13 and 14 illustrate the case of a number having a negative
exponent that is too large (that is, it's too small to store).
In such cases, Perl either gets as close as it can or just prints
0.
The largest negative exponent that produces reliable values is
about e309. Below that, accuracy diminishes.
The arithmetic operations you saw on Chapter 2, "Basic Operators
and Control Flow," also work on floatingpoint values. On
that Chapter, you saw an example of a milestokilometers conversion
program that uses floatingpoint arithmetic.
When you perform floatingpoint arithmetic, you must remember
the problems with precision and roundoff error. Listing 3.3 illustrates
what can go wrong and shows you how to attack this problem.
Listing 3.3. A program that illustrates roundoff error problems
in floatingpoint arithmetic.
1: #!/usr/local/bin/perl
2:
3: $value = 9.01e+21 + 0.01  9.01e+21;
4: print ("first value is ", $value, "\n");
5: $value = 9.01e+21  9.01e+21 + 0.01;
6: print ("second value is ", $value, "\n");
$ program3_3
first value is 0
second value is 0.01
$
Line 3 and line 5 both subtract 9.01e+21
from itself and add 0.01. However, as you can see when
you examine the output produced by line 4 and line 6, the order
in which you perform the addition and subtraction has a significant
effect
In line 3, a very small number, 0.01, is added to a very
large number, 9.01e+21. If you work it out yourself,
you see that the result is 9.01000000000000000000001e+21.
The final 1 in the preceding number can be retained only
on machines that support 24 digits of precision in their floatingpoint
numbers. Most machines, as you've seen, handle only 16 or 17 digits.
As a result, the final 1, along with some of the zeros,
is lost, and the number instead is stored as 9.0100000000000000e+21.
This is the same as 9.01e+21, which means that subtracting
9.01e+21 yields zero. The 0.01 is lost along
the way.
Line 5, however, doesn't have this problem. The two large numbers
are operated on first, yielding 0, and then 0.01 is added.
The result is what you expect: 0.01.
The moral of the story: Floatingpoint arithmetic is accurate
only when you bunch together operations on large numbers. If the
arithmetic operations are on values stored in variables, it might
not be as easy to spot this problem.
$result = $number1 + $number2  $number3;
If $number1 and $number3 contain large numbers
and $number2 is small, $result is likely to
contain an incorrect value because of the problem demonstrated
in Listing 3.3.
So far, all the integer scalar values you've seen have been in
what normally is called base 10 or decimal notation.
Perl also enables you to use two other notations to represent
integer scalar values:
 Base 8 notation, or octal
 Base 16 notation, or hexadecimal (sometimes shortened
to hex)
To use octal notation, put a zero in front of your integer scalar
value:
$result = 047;
This assigns 47 octal, or 39 decimal, to $result.
To use hexadecimal notation, put 0x in front of your
integer scalar value, as follows:
$result = 0x1f;
This assigns 1f hexadecimal, or 31 decimal, to $result.
Perl accepts either uppercase letters or lowercase letters as
representations of the digits a through f:
$result = 0xe;
$result = 0xE;
Both of the preceding statements assign 14 (decimal) to $result.
If you are not familiar with octal and hexadecimal notations and
would like to learn more, read the following sections. These sections
explain how to convert numbers to different bases. If you are
familiar with this concept, you can skip to the section called
"Character Strings."
To understand how the octal and hexadecimal notations work, take
a closer look at what the standard decimal notation actually represents.
In decimal notation, each digit in a number has one of 10 values:
the standard numbers 0 through 9. Each digit in a number in decimal
notation corresponds to a power of 10. Mathematically, the value
of a digit x in a number is
x * 10 to the exponent n,
where n is the number of digits you have to skip before
reaching x.
This might sound complicated, but it's really straightforward.
For example, the number 243 can be expressed as follows:
 2 * 10 to the exponent 2 (which is 200), plus
 4 * 10 to the exponent 1 (which is 40), plus
 3 * 10 to the exponent 0 (which is 3 * 1, which is 3)
Adding the three numbers together yields 243.
Working through these steps might seem like a waste of time when
you are dealing with decimal notation. However, once you understand
this method, reading numbers in other notations becomes simple.
For example, in octal notation, each digit x in a number
is
x * 8 to the exponent n
where x is the value of the digit, and n is
the number of digits to skip before reaching x. This
is the same formula as in decimal notation, but with the 10 replaced
by 8.
Using this method, here's how to determine the decimal equivalent
of 243 octal:
 2 * 8 to the exponent 2, which is 2 * 64, or 128, plus
 4 * 8 to the exponent 1, which is 4 * 8, or 32, plus
 3 * 8 to the exponent 0, which is 3 * 1, or 3
Adding 128, 32 and 3 yields 163, which is the decimal notation
equivalent of 243 octal.
Hexadecimal notation works the same way, but with 16 as the base
instead of 10 or 8. For example, here's how to convert 243 hexadecimal
to decimal notation:
 2 * 16 to the exponent 2, which is 2 * 256, or 512, plus
 4 * 16 to the exponent 1, which is 4 * 16, or 64, plus
 3 * 16 to the exponent 0, which is 3 * 1, or 3
Adding these three numbers together yields 579.
Note that the letters a through f represent the numbers 10 through
15, respectively. For example, here's the hexadecimal number fe
in decimal notation:
 15 * 16 to the exponent 1, which is 15 * 16, or 240, plus
 14 * 16 to the exponent 0, which is 14 * 1, or 14
Adding 240 and 14 yields 254, which is the decimal equivalent
of fe.
You might be wondering why Perl bothers supporting octal and hexadecimal
notation. Here's the answer: Computers store numbers in memory
in binary (base 2) notation, not decimal (base 10) notation. Because
8 and 16 are multiples of 2, it is easier to represent stored
computer memory in base 8 or base 16 than in base 10. (You could
use base 2, of course; however, base 2 numbers are clumsy because
they are very long.)
NOTE 
Perl supports base2 operations on integer scalar values. These operations, called bitmanipulation operations, are discussed on Chapter 4, "More Operators.

On previous Chapters, you've seen that Perl enables you to assign
text to scalar variables. In the following statement, for instance
$var = "This is some text";
the text This is some text is an example of what is called
a character string (frequently shortened to just string).
A character string is a sequence of one or more letters, digits,
spaces, or special characters.
The following subsections show you
 How you can substitute for scalar variables in character strings
 How to add escape sequences to your character strings
 How to tell the Perl interpreter not to substitute for scalar
variables
NOTE 
C programmers should be advised that character strings in Perl do not contain a hidden null character at the end of the string. In Perl, null characters can appear anywhere in a string. (See the discussion of escape sequences later toChapter for more
details.

Perl supports scalar variable substitution in character
strings enclosed by double quotationmark characters. For example,
consider the following assignments:
$number = 11;
$text = "This text contains the number $number.";
When the Perl interpreter sees $number inside the string
in the second statement, it replaces $number with its
current value. This means that the string assigned to $text
is actually
This text contains the number 11.
The most immediate practical application of this is in the print
statement. So far, many of the print statements you have
seen contain several arguments, as in the following:
print ("The final result is ", $result, "\n");
Because Perl supports scalar variable substitution, you can combine
the three arguments to print into a single argument,
as in the following:
print ("The final result is $result\n");
NOTE 
From now on, examples and listings that call print use scalar variable substitution because it is easier to read

Character strings that are enclosed in double quotes accept escape
sequences for special characters. These escape sequences consist
of a backslash (\) followed by one or more characters.
The most common escape sequence is \n, which represents
the newline character as shown in this example:
$text = "This is a string terminated by a newline\n";
Table 3.1 lists the escape sequences recognized in doublequoted
strings.
Table 3.1. Escape sequences in strings.
Escape Sequence 
Description 
\a  Bell (beep)

\b  Backspace

\cn  The Ctrl+n character

\e  Escape

\E  Ends the effect of \L, \U or \Q

\f  Form feed

\l  Forces the next letter into lowercase

\L  All following letters are lowercase

\n  Newline

\r  Carriage return

\Q  Do not look for special pattern characters

\t  Tab

\u  Force next letter into uppercase

\U  All following letters are uppercase

\v  Vertical tab

The \Q escape sequence is useful only when the string
is used as a pattern. Patterns are described on Chapter 7, "Pattern
Matching."
The escape sequences \L, \U, and \Q
can be turned off by \E, as follows:
$a = "T\LHIS IS A \ESTRING"; # same as "This is a STRING"
To include a backslash or double quote in a doublequoted string,
precede the backslash or quote with another backslash:
$result = "A quote \" in a string";
$result = "A backslash \\ in a string";
A backslash also enables you to include a $ character
in a string. For example, the statements
$result = 14;
print("The value of \$result is $result.\n");
print the following on your screen:
The value of $result is 14.
You can specify the ASCII value for a character in base 8 or octal
notation using \nnn, where each n is an octal
digit; for example:
$result = "\377"; # this is the character 255, or EOF
You can also use hexadecimal notation to specify the ASCII value
for a character. To do this, use the sequence \xnn, where
each n is a hexadecimal digit.
$result = "\xff"; # this is also 255
Listing 3.4 is an example of a program that uses escape sequences.
This program takes a line of input and converts it to a variety
of cases.
Listing 3.4. A caseconversion program.
1: #!/usr/local/bin/perl
2:
3: print ("Enter a line of input:\n");
4: $inputline = <STDIN>;
5: print ("uppercase: \U$inputline\E\n");
6: print ("lowercase: \L$inputline\E\n");
7: print ("as a sentence: \L\u$inputline\E\n");
$ program3_4
Enter a line of input:
tHis Is My INpUT LiNE.
uppercase: THIS IS MY INPUT LINE.
lowercase: this is my input line.
as a sentence: This is my input line.
$
Line 3 of this program reads a line of input
and stores it in the scalar variable $inputline
Line 5 replaces the string $inputline with the current
value of the scalar variable $inputline. The escape character
\U tells the Perl interpreter to convert everything in
the string into uppercase until it sees a \E character;
as a result, line 4 writes the contents of $inputline
in uppercase.
Similarly, line 6 writes the input line in all lowercase characters
by specifying the escape character \L in the string.
Line 7 combines the escape characters \L and \u.
The \L specifies that everything in the string is to
be in lowercase; however, the \u special character temporarily
overrides this and tells the Perl interpreter that the next character
is to be in uppercase. When this characterthe first character
in the lineis printed, the \L escape character remains
in force, and the rest of the line is printed in lowercase. The
result is as if the input line is a single sentence in English.
The first character is capitalized, and the remainder is in lowercase.
Perl also enables you to enclose strings using the '
(single quotation mark) character:
$text = 'This is a string in single quotes';
There are two differences between doublequoted strings and singlequoted
strings. The first difference is that scalar variables are replaced
by their values in doublequoted strings but not in singlequoted
strings. The following is an example:
$string = "a string";
$text = "This is $string"; # becomes "This is a string"
$text = 'This is $string'; # remains 'This is $string'
The second difference is that the backslash character, \,
does not have a special meaning in singlequoted strings. This
means that the statement
$text = 'This is a string.\n';
assigns the following string to $text:
This is a string.\n
The \ character is special in only two instances for
singlequoted strings. The first is when you want to include a
singlequote character ' in a string.
$text = 'This string contains \', a quote character';
The preceding line of code assigns the following string to $text:
This string contains ', a quote character
The second instance is to escape the backslash itself.
$text = 'This string ends with a backslash \\';
The preceding code line assigns the following string to $text:
This string ends with a backslash \
As you can see, the double backslash makes it possible for the
backslash character (\) to be the last character in a
string.

Singlequoted strings can be spread over multiple lines. The statement
$text = 'This is two
lines of text
';
is equivalent to the statement
$text = "This is two\nlines of text\n";
This means that if you forget the closing ' for a string, the Perl interpreter is likely to get quite confused because it won't detect an error until after it starts processing the next line

As you've seen, you can use a scalar variable to store a character
string, an integer, or a floatingpoint value. In scalar variables,
a value that was assigned as a string can be used as an integer
whenever it makes sense to do so, and vice versa. In the following
example:
$string = "43";
$number = 28;
$result = $string + $number;
the value of $string is converted to an integer and added
to the value of $number. The result of the addition,
71, is assigned to $result.
Another instance in which strings are converted to integers is
when you are reading a number from the standard input file. The
following is some code similar to code you've seen before:
$number = <STDIN>;
chop ($number);
$result = $number + 1;
This is what is happening: When $number is assigned a
line of standard input, it really is being assigned a string.
For instance, if you enter 22, $number is assigned the
string 22\n (the \n represents the newline character).
The chop function removes the \n, leaving the
string 22, and this string is converted to the number
22 in the arithmetic expression.

If a string contains characters that are not digits, the string is converted to 0 when used in an integer context. For example:
$result = "hello" * 5;
# this assigns 0 to $result, since "hello" becomes 0
This is true even if the string is a valid hexadecimal integer if the quotes are removed, as in the following:
$result = "0xff" + 1;
In cases like this, Perl does not tell you that anything has gone wrong, and your results might not be what you expect.
Also, strings containing misprints might not contain what you expect. For example:
$result = "12O34"; # the letter O, not the number 0
When converting from a string to an integer, Perl starts at the left and continues until it sees a letter that is not a digit. In the preceding instance, 12O34 is converted to the integer 12, not 12034

In Perl, all scalar variables have an initial value of the null
string, "". This means that you do not need
to define a value for a scalar variable.
#!/usr/local/bin/perl
$result = $undefined + 2; # $undefined is not defined
print ("The value of \$result is $result.\n");
This short program is perfectly legal Perl. The output is
The value of $result is 2.
Because $undefined is not defined, the Perl interpreter
assumes that its value is the null string. This null string is
then converted to 0, because it is being used in an addition operation.
The result of the addition, 2, is assigned to $result.
TIP 
Although you can use uninitialized variables in your Perl programs, you shouldn't. If your Perl program gets to be large (as many complicated programs do), it might be difficult to determine whether a particular variable is supposed to be appearing for
the first time or whether it is a spelling mistake that should be fixed. To avoid ambiguity and to make life easier for yourself, initialize every scalar variable before using it

Perl supports three kinds of scalar values: integers, floatingpoint
numbers, and character strings.
Integers can be in three notations: standard (decimal) notation,
octal notation, and hexadecimal notation. Octal notation is indicated
by a leading 0, and hexadecimal notation is indicated
by a leading 0x. Integers are stored as floatingpoint
values and can be as long as the machine's floatingpoint precision
(usually 16 digits or so).
Floatingpoint numbers can consist of a string of digits that
contain a decimal point and an optional exponent. The exponent's
range can be anywhere from about e309 to e+308.
(This value might be different on some machines.) When possible,
floatingpoint numbers are displayed without the exponent; failing
that, they are displayed in scientific notation (one digit before
the decimal point).
When you use floatingpoint arithmetic, be alert for roundoff
errors. Performing arithmetic operations in the proper orderoperating
on large numbers firstmight yield better results.
You can enclose character strings in either double quotes (")
or single quotes ('). If a scalar variable name appears
in a character string enclosed in double quotes, the value of
the variable is substituted for its name. Escape characters are
recognized in strings enclosed in double quotes; these characters
are indicated by a backslash (\).
Character strings in single quotes do not support escape characters,
with the exception of \\ and \'. Scalar variable
names are not replaced by their values.
Strings and integers are freely interchangeable in Perl whenever
it is logically possible to do so.
Q:  If Perl character strings are not terminated by null characters, how does the Perl interpreter know the length of a string?

A:  The Perl interpreter keeps track of the length of a string as well as its contents. In Perl, you do not need to use a null character to indicate "end of string."

Q:  Why does Perl use floatingpoint registers for floatingpoint arithmetic even though they cause roundoff errors?

A:  Basically, it's a performance issue. It's possible to write routines that store floatingpoint numbers as strings and convert parts of these strings to numbers as necessary; however, you often don't need more
than 16 or so digits of precision anyway.
Applications that need to do highspeed arithmetic calculations of great precision usually run on special computers designed for that purpose.

Q:  What happens if I forget to call chop when reading a number from the standard input file?

A:  As it happens, nothing. Perl is smart enough to ignore white space at the end of a line that consists only of a number. However, it's a good idea to get into the habit of using chop to get rid of a
trailing newline at all times, because the trailing newline becomes significant when you start doing string comparisons. (You'll learn about string comparisons on Chapter 4, "More Operators.")

The Workshop provides quiz questions to help you solidify your
understanding of the material covered and exercises to give you
experience in using what you've learned. Try and understand the
quiz and exercise answers before you go on to tomorrow's lesson.
 Define the following terms:
a roundoff error
b octal notation
c precision
d scientific notation
 Convert the following numbers from octal notation to decimal:
a 0377
b 06
c 01131
 Convert the following numbers from hexadecimal notation to
decimal notation:
a 0xff
b 0x11
c 0xbead
 What does the following line print?
print ("I am bored\b\b\b\b\bhappy!\n");
 Suppose the value of $num is 21. What string is assigned
to $text in each of the following cases?
a $text = "This string contains
$num.";
b $text = "\\$num
is my favorite number.";
c $text = 'Assign \$num to this string.';
 Convert the following numbers to scientific notation:
a 43.71
b 0.000006e02
c 3
d 1.04
 Write a program that prints every number from 0 to 1 that
has a single digit after the decimal place (that is, 0.1, 0.2,
and so on).
 Write a program that reads a line of input and prints out
the following:
 1 if the line consists of a nonzero integer
 0 if the line consists of 0 or a string
(Hint: Remember that character strings are converted to 0 when
they are converted to integers.)
 Write a program that asks for a number and keeps trying until
you enter the number 47. At that point, it prints Correct!
and rings a bell.
 BUG BUSTER: What is wrong with the following program?
#!/usr/local/bin/perl
$inputline = <STDIN>;
print ('here is the value of \$inputline\', ": $inputline");
 BUG BUSTER: What is wrong with the following code fragment?
$num1 = 6.02e+23;
$num2 = 11.4;
$num3 = 5.171e+22;
$num4 = 2.5;
$result = $num1 + $num2  $num3 + $num4;
 BUG BUSTER: What is wrong with the following statement?
$result = "26" + "0xce" + "1";
