**UPDATE**: since writing this, Sylvester continues to be tweaked for performance. Some of the below may no longer apply, and you should always do your own testing for performance to find out what works for you. I’m leaving this article up to illustrate the broader points it has to make.

Now that Sylvester allows you to use plain old arrays pretty much anywhere you can use a vector as an argument, how do you decide which one to use? The trick is to know what the the method you’re passing the array/vector to is going to do with it. In the vast majority of cases where vectors are used as arguments, the method is only interested in the vector’s elements. In fact, what often happens is something like this:

```
someVectorMethod: function(vector) {
var elements = vector.elements || vector;
// ...
}
```

So `elements` ends up being an array, whether you pass an array or a vector. You’ll find passing a vector is slightly faster due to the nature of the `||` operator, and that might lead you to do the following:

```
// Bad bad code:
var foo = myVector.add($V([2,9,4]));
```

As well as being ugly, this is really inefficient. You’re calling `$V` for no reason at all, and the time that takes to run far outweighs the time saving of passing a vector. In this situation,

```
// Much nicer:
var bar = myVector.add([2,9,4]);
```

is both cleaner and faster.

It’s only sensible to pass a vector if you’ve already got one in memory as the result of another calculation:

```
var somePoint = lineA.intersectionWith(PlaneB);
// This is faster...
var foo = myVector.add(somePoint);
// than this...
var bar = myVector.add(somePoint.elements);
```

For matrices, the reverse is true. Because the `Matrix` class is written to be able to cope with accepting vectors and matrices as arguments, and to treat vectors as column matrices for multiplication, its methods can’t just use `arg.elements || arg` to get the necessary array of elements. Matrix arrays are nested, whereas vector ones aren’t. If `arg` is `[9,2,6]` (a vector), it must be converted to `[[9],[2],[6]]` to behave as a column matrix. So, most matrix methods call `Matrix.create` if they receive a non-matrix argument, and this sorts out the conversion. This means that, if you’ve got a vector you’re going to subject to lots of matrix methods, you’re better off converting it to a matrix beforehand to save all those conversion calls. Even if you’re only calling one matrix method, you’ll find that converting the argument to a matrix before passing it over will save you some time overall. Strange but true.