Erica: Well, Carol, you've pulled a really neat trick. What a difference, being able to add vectors by writing

  v = v1 + v2

  v = []
  v1.each_index{|k| v[k] = v1[k] + v2[k]}

Carol: Not quite yet; I'll have to do the same thing for subtraction, multiplication and addition as well. And I'm sure there are a few more things to consider, before we can claim to have a complete Vector class. But I, too, am encouraged with the good start we've made!

Carol: Let me consult the Ruby manual. Just a moment . . . aha, I see! Well, this is perhaps an exception to Ruby's principle of least surprise. The manual tells me that -@ is the Ruby notation for a unary minus, and similarly, +@ is the Ruby notation for a unary plus.

Dan: A unary minus?

Carol: Yes, and the word `un' in unary here means `one,' like in `unit.' A unary minus is an operation that has only one operand.

Erica: As opposed to what?

Carol: As opposed to a binary minus. Most normal operations, such as addition and subtraction, as well as multiplication and division, are binary operation. Binary here means two operands. When you use a single plus sign, you add two numbers. Similarly, a minus allows you to subtract two numbers. So when you write 5 - 3 = 2 you are using a binary minus. However, when you first write x = 5 and then y = -x, to give y the value -5, you are using not a binary minus, but a unary minus. The construction -x returns a value that has the value of the variable x, but with an additional minus sign.

Dan: So you are effectively multiplying x with the number -1.

Erica: Or you could say that you are subtracting x from 0.

Carol: Yes, both statements are correct. But rather than introducing multiplication, it is simpler to think only about subtraction. So writing -x uses a unary minus, while writing 0-x uses a binary minus, while both are denoting the same result.

Dan: But why does Ruby use such a complicated symbol, -@, for unary minus?

Carol: That symbol is only used when you redefine the symbol.

Carol: What about it?

Dan: My first guess would be to let the method return -self but that's too simple, I'm sure . . .

Carol: Yes, that would beg the question! By writing -self you are trying to invoke the very method you are trying to define. That certainly won't work. But, hey, remember our friend map, which maps an operation on all elements of an array? Well, because the Vector class inherits the Array class, any method working for an array will work for a vector as well, so here we go:

14.4. An Unexpected Result

Dan: So much for normal arithmetic.

Carol: That is very unexpected, I must say. What does the error message say? It talks about a very long array, with six components. Wait a minute, it should only talk about vectors. It seems that not all of our vectors are really members of the Vector class. Could it be that some of them are still Array members?

Erica: Easy to test:

 |gravity> irb
 require "vector_try_unary.rb"
 true
 v1 = Vector[1, 2, 3]
 [1, 2, 3]
 v2 = Vector[5, 6, 7]
 [5, 6, 7]
 v1.class
 Vector
 v2.class
 Vector
 (+v2).class
 Vector
 (-v1).class
 Array
 quit

Carol: Well, I may have a lead here. In Ruby, you will often see something like to_s as a method to write something as a string. Or more precisely, to convert it into a string.

Dan: What does it mean to convert something? Can you give a really simple example?

Carol: The simplest example I can think of is the way that integers are being converted into floating point numbers. I'm sure you're familiar with it. If you specify a multiplication like 3.14 * 2 to get an approximate result for , the floating point number 3.14 will try to make the fixed point number 2, in integer, into a floating point number first.

In other words, 3.14, an object that is an instance of the class Float, will try to convert the number 2, an object that is an instance of the class Fixnum, into an instance of the class Float. To say it in simple terms: 3.14 will convert 2 into 2.0 and since it knows how to multiply two floating point numbers, it can then happily go ahead and apply its multiplication method.

Dan: I see. I guess I never worried about what happened when I write something like 3.14 * 2; I just expect 5.28 to come out.

Carol: 6.28.

Dan: Oops, yes, of course. But you see what I mean.

Carol: I agree, normally there is no reason to think about those things, as long as we are using predefined features that hopefully have been tested extensively. But now we are going to define our own objects, vectors, and we'd better make sure that we're doing the right thing.

Erica: You mentioned the to_s method.

Carol: Yes, for each class XXX that has a method to_s defined, as XXX#to_s, we can use to_s to convert an object of class XXX into an object of class String.

Here, let me show you:

 |gravity> irb
 3
 3
 3.class
 Fixnum
 3.to_s
 "3"
 3.to_s.class
 String
 3.14
 3.14
 3.14.class
 Float
 3.14.to_s
 "3.14"
 3.14.to_s.class
 String
 quit

So you want to do something similar with vectors, starting with an array and then converting it into a vector, with a method like to_v.

Carol: Exactly! And I like the name you just suggested. So we have to define a method Array.to_v. Then, once we have such a method, we can use it to create a vector by writing

  v = [1, 2, 3].to_v

14.6. Augmenting the Array Class

Erica: But how can we define to_v? Somebody else already has defined the Array class for us. I guess we'll have to dig into wherever Ruby is defined, and change the Array class definition?

Carol: No digging needed! The neat thing about Ruby, one of the neat things, is that it allows you to augment a class. Even if someone else had defined a class, we can always add a few lines to the class definition, for example, when we want to add a method. The different bits and pieces of the class definition can live in different places. Nothing to worry about!

14.7. Fixing the Bug

Erica: So now we can go back and fix the bug in our unary minus.