Errata

This is a 'code snippet' but it contains a syntax error in the last statement.

The erroneous line is:
p => temp # => ["Quarter", "Arabian"]

The first => should not be there, that is:
p temp # => ["Quarter", "Arabian"]

"It adds a character when it reaches a boundary, *or adds a digit or decimal place* when appropriate, as shown in these lines:"

next (and succ) do not add a decimal place. They keep as many decimal places as the number already had, incrementing the rightmost digit by 1 (e.g. '999.09'.next! =>
999.10, and '123.99'.next! =>
124.00, '123.04'.next! => 123.05)

In all of the phone.grep examples (starting on p75, and continuing to p76), the area code is
incorrectly enclosed in square brackets, rather than parentheses. That example should read:

phone.grep(/((ddd))?ddd-dddd/) # => ["(555)123-4567"]

The examples will produce the output shown, because the area code segment is made optional with "?".
The remainder of the expression matches the remainder of the phone number ("123-4567"), and so an array
consisting of the phone string is returned, as shown. But the text implies that the regular expressions
shown match the ENTIRE number, which is not true.

<< Let?s figure out how to match a phone number in the form
(555)123-4567.Supposing
that the string phone contains a phone number like this, the following
pattern will
find it:
phone.grep(/*[\(\d\d\d\)]?*\d\d\d-\d\d\d\d/) # => ["(555)123-4567"]
The backslash precedes the parentheses (\(...\)) to let the regexp engine
know that
these are literal characters.Otherwise, the engine will see the parentheses
as enclosing
a subexpression.The three \ds in the parentheses represent three digits.The
hyphen (-) is just an unambiguous character, so you can use it in the
pattern as is. >>

Given regexp will match '(123-4567' as well. The subpattern in black is
equivalent to [\(\d\)],
as a matter of fact. Repeating \d inside square brackets has no
consequences. The right
regexp would be (\(\d\d\d\))? [or, if we could use {} at this point:
(\(\d{3}\))?], if I got the idea
right.

The diagram has quite a few errors:
- Rational is a child of Object, not Integer
- Complex is a child of Numeric, not Integer
- Float is a child of Numeric, and missing from the diagram

||= should read |= .

Two problems:
1. The array years was never created in the text
2. If array year, which was created as an array of integers, is used it gives an error.

The statement in the book:
print "The event is scheduled for " + months[3] + " " + years[8] + "."

If run in irb, after entering the arrays in the chapter, the following error message is displayed:
NameError: undefined local variable or method `years' for main:Object
from (irb):8

If years is changed to year and the command is run, the following occurs:
NameError: undefined local variable or method `years' for main:Object
from (irb):8

To correct, make the change shown in the next statement and rerun - see following:
>> print "The event is scheduled for " + months[3] + " " + year[8].to_s + "."
The event is scheduled for March 2008.

In page 101:

----------------------------------------------------------------------
bob = [ "full", 40, "yes" ]

[...]

What?s the difference between == and eql?. eql? checks to
see if the values are equal (as in ==), but also checks if the values are of
the same type.

bob == schlomo # => true
bob.eql?( "full, 40, yes" ) # => false, bob is not a string
----------------------------------------------------------------------

The example is wrong. bob == "full, 40, yes" also returns false. That's not how eql? and == are different at all. The difference is eql compares the type of /each/ member of the array (not of the
array itself, that's mandatory for both). A good example would be

bob == ["full, 40.0, "yes"] # => true
bob.eql? ["full, 40.0, "yes"] # => false, 40.0 is an instance of Float
class, 40 is a Fixnum

It'd be good to add, also, that == won't return true if we use "40" instead of 40 (at least in Ruby 1.9.2)

months.insert(0, nil) does not replace "nil," insert() adds nil so the array looks like this:

[nil, "nil", "January", "February", "March", "April", "May", "June", "July", "August", "September",
"October", "November", "December"]

The statement months.insert(0, nil), according to the example in the text should replace the string "nil" and replace it with the nil value.
What actually happens is that the string "nil" remains and become array index item 1 and nil is added as array index 0.

This is correct, that is, both values should be in the array - see following:
Inserts the given values before the element with the given index (which may be negative).

a = %w{ a b c d }
a.insert(2, 99) #=> ["a", "b", 99, "c", "d"]

I ran the code in irb, as shown in the book, and the result was [note: both nil, "nil" appear]:

>>months
=> ["nil", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
>> months.insert(0,nil)
=> [nil, "nil", "January", "February",...]

------------------------------------------------------------------------
zip = { 82442 => "Ten Sleep", 83025 => "Teton Village", 83127 => "Thayne",
82443 =>
"Thermopolis", 82084 => "Tie Siding", 82336 => "Tipton", 82240 =>
"Torrington", 83110
=> "Turnerville", 83112 => "Turnerville" }

[...]

Now *return a value for a given key* (one key only) with the index method:
zip.index "Thayne" # => 83127
----------------------------------------------------------------------

It actually does the opposite: it returns a key given a value. If value is present for more than one key, it returns just the first occurrence (Hash#index has been
deprecated in
favor of Hash#key as of Ruby 1.9).

In order for the following statement to work it is necessary to "Restoring the Rhode Island hash", otherwise a result different from that shown in the book will be produced -- see following:

>> rhode_island = {1=>"Bristol",2=>"Kent",3=>"Newport",4=>"Providence",5=>"Washington"}
=> {5=>"Washington", 1=>"Bristol", 2=>"Kent", 3=>"Newport", 4=>"Providence"}
>> rhode_island.delete_if{|key, value|key < 3 }
=> {5=>"Washington", 3=>"Newport", 4=>"Providence"}
>> rhode_island.delete_if{|key, value|value == "Kent" }
=> {5=>"Washington", 3=>"Newport", 4=>"Providence"}

now, if "Restoring the Rhode Island hash" is performed, the result shown in the book will be displayed - see following:

>> rhode_island = {1=>"Bristol",2=>"Kent",3=>"Newport",4=>"Providence",5=>"Washington"}
=> {5=>"Washington", 1=>"Bristol", 2=>"Kent", 3=>"Newport", 4=>"Providence"}
>> rhode_island.delete_if{|key, value|key < 3 }
=> {5=>"Washington", 3=>"Newport", 4=>"Providence"}
>> rhode_island = {1=>"Bristol",2=>"Kent",3=>"Newport",4=>"Providence",5=>"Washington"}
=> {5=>"Washington", 1=>"Bristol", 2=>"Kent", 3=>"Newport", 4=>"Providence"}
>> rhode_island.delete_if{|key, value|value == "Kent" }
=> {5=>"Washington", 1=>"Bristol", 3=>"Newport", 4=>"Providence"}

One of the ternaries in the dice roll method of the Dice module, r1 = r_1>0?r_1:1; r2 = r_2>0?r_2:6, is
incorrect in that in over one million rolls a 12 is never obtained. While such results are not impossible,
statistically they qre highly unlikely. Re-writing the statements as r1 = r_1>0?r_1:6; r2 = r_2>0?r_2:6,
that is setting both r1 and r2 to 6 in the negative case solves the problem. Data follows:

with r1 = r_1>0?r_1:6 1000000 rolls
Frequencies
Actual Expected
two = 27909 0.028 0.028
three = 55540 0.055 0.056
four = 83132 0.083 0.083
five = 111112 0.111 0.111
six = 139029 0.139 0.139
seven = 166741 0.168 0.167
eight = 139193 0.139 0.139
nine = 110788 0.111 0.111
ten = 83264 0.083 0.083
eleven = 55388 0.054 0.056
twelve = 27904 0.028 0.028

with r1 = r_1>0?r_1:1 1000000 rolls
Frequencies
Actual Expected
two = 55501 0.056 0.028
three = 83259 0.083 0.056
four = 111443 0.111 0.083
five = 139386 0.139 0.111
six = 166769 0.167 0.139
seven = 166207 0.166 0.167
eight = 110925 0.111 0.139
nine = 83170 0.083 0.111
ten = 55552 0.056 0.083
eleven = 27788 0.028 0.056
twelve = 0 0.000 0.028