Bob: Okay, here is the next step. We first have to tell our Body class that the positions and velocities are no longer arrays, but vectors. Let me create a new file vbody1.rb for this modified class. I will call the modified class Body as well. If we are happy with it, we can discard the previous Body class definition.

Bob: But now we're getting close. Let me rename the old file euler1.rb, and then add vectors to euler2.rb. No, let me be more careful. Let me call it euler2a.rb, for alpha version of euler2.rb. If and when it works, we can rename it euler2.rb.

Alice: You're getting cautious! Can you remind me what euler1.rb looked like?

Bob: Here it is, or was; or will be -- but not for much longer:

Alice: One of these days you'll shorten it so much that you can hand me a one-line integrator, just like you produced one-line read and write functions, earlier!

Bob: Don't count on it; I think a five-line integrator is good enough already. What a difference with euler1.rb! Instead of asking b.pos to add the square of each of its components to r2, after setting r2 to zero, we simply order r2 to be the inner product of b.pos with itself, in the first line of the do loop.

The next line is unchanged. But then the fun really starts: the acceleration vector is now directly given as the product of the velocity vector with the terms mass over distance cubed.

Alice: Just as we saw it in formula form earlier:

Bob: So you see, now we can translate our formulas directly into computer code!

Alice: Perhaps Ruby should be called FORmula TRANslator.

Bob: I'm afraid that name has already been taken, quite a few decades ago . . .

Alice: And the next two lines clearly mean:

also just like we wrote it before. What a relief, to write a computer code as if you write equations directly down into the software!

Bob: Indeed. I've seen C++ doing that, what they call overloading operators, and you can get a similar notation, but with far more work.

Alice: And with a complex class definition and declaration structure that is very hard to play with and to change at will. In contrast, here with Ruby we can really do what they always advertise as rapid prototyping.

Bob: But before congratulating ourselves too much, let us first see whether this now runs. I've grown a bit more cautious after those surprises we got earlier. Ruby is certainly powerful, but as we have seen, we'd better know what we are doing, in order to use all that power wisely.

Alice: Well said, Bob! Let's run the new version of the integrator with the same values we had before, which I see you have still there in the file euler2a.rb: a hundred time steps of 0.01 time units each.

Bob: Here goes:

 |gravity> ruby euler2a.rb < euler.in
 euler2a.rb:12:in `*': can't convert Array into Integer (TypeError)
        from euler2a.rb:12
        from euler2a.rb:11:in `times'
        from euler2a.rb:11

8.4. An Old Friend

Alice: Where did we see that error message before?

Bob: I know, it is an old friend, isn't it? I had hoped we had banned it forever. But at least we have an idea now where it could come from. I bet that there is still a vector somewhere that somehow thinks it is an array . . .

Alice: Which line is line 12 in euler2a.rb

Bob: it's the very first line in our do loop. Just a few lines above, b is freshly minted, so perhaps b.simple_read is the bad influence that turns some vector into an array? Could be. But before jumping to conclusions, let me sprinkle in a few class statements.

Alice: You are getting cautious!

Bob: Yeah, but I don't want to waste more time, this time around. Let me do it in irb directly, so that we can get everything echoed.

    |gravity> irb --prompt short_prompt -r vbody1.rb
    001:0> include Math
    Object
    002:0> dt = 0.01
    0.01
    003:0> ns = 100
    100
    004:0> b = Body.new
    #<Body:0x400cda40 @vel=[0, 0, 0], @pos=[0, 0, 0], @mass=0>
    005:0> b.class
    Body
    006:0> b.pos.class
    Vector
    007:0> b.simple_read

Alice: You haven't given it the euler.in input file.

Bob: Ah, of course. I can see that there are drawbacks of using an interactive interpreter if you're testing something that has dependencies with other things. Well, the file is short enough to type in by hand. Here goes:

    007:0> b.simple_read
    1
    1 0
    0 0.5
    [0.0, 0.5]
    008:0> b.pos.class
    Array

Bob: What do you mean `after all'? I was almost certain, but now I know for sure.

Alice: Right you are! Now what is wrong with simple_read?

Bob: Let's inspect. Here is the definition:

Bob: Thanks. So now we have a FORmula TRANslation device that actually works!

Alice: But it is ugly.

Bob: I beg your pardon?

Alice: It is ugly.

Bob: How so?

Alice: I don't like that [*...] notation. Looks like a hack.

Bob: I like hacks.

Alice: I know you do. But can't we come up with something cleaner?

Bob: Like what?

Alice: Well, we have seen that to_s will happily turn something into a string; we even gave our Body class its own to_s method, so that it could show its face in public. I bet there is a method called to_a that turns objects into arrays.

Bob: There is. And it does just that.

Alice: Can't we then write our own to_v method which turns something into a vector?

Bob: Now that's a thought. Sure. That would be fun! And I just know how to do that! I only have to add a few lines to the vector3.rb file. I think this is really what we want. To celebrate, let me call the file vector.rb now.

Here, it is short, let me show the whole file:

Alice: That's much better. I don't mind the [*...] per se, it is only that the line with gets.split.map followed by a block of code just got too crowded for comfort. But your definition of to_v is clean and simple. So let me check: by writing class Array and so on, you are just extending the Ruby-defined standard array definition, right?

Bob: Right. Not only can you extend your own classes by giving new bits and pieces like this, as we have seen before, you can do the same thing to the predefined classes. In general, almost nothing in Ruby is off limits; you can typically treat the built-in stuff as if you had just written it all yourself.

Alice: That's really neat. So now can we get rid of the clutter at the bottom of the vbody2.rb file?

Bob: Sure thing. Here is our simple_read, no clutter, and with the new to_v at the end. And let me call this one vbody.rb, to celebrate that now we know what we are doing: