Vector Decomposition: Finding Components w/ Vector Math

[_Nate_]

I'm doing some work with vectors, and essentially, I have two vectors: a large vector and a unit vector pointing in a different direction. I would like to decompose the large vector into the components that are in the direction of and perpendicular to the unit vector.

This is in three dimensions, and shouldn't be too hard using cos and acos. However, this is for some computer work, where cos and acos are expensive -- is there any better way to do this using purely vector math (such as cross product, etc) or some other method not quite so expensive?

 

[arildno]

Let your vector be called $\vec{V}$ Let [itex]\vec{u}[/tex] be your given unit vector, U being the projection of $\vec{V}$ on $\vec{u}$.
Let $\vec{W}$ be the component vector of V orthogonal to $\vec{u}$

Thus, we have:
$$\vec{V}=U\vec{u}+\vec{W}$$
Taking the dot product here with $\vec{u}$, we gain:
$$\vec{V}\cdot\vec{u}=U$$
since u was orthogonal to W and of magnitude 1.

Hence, going back, the orthogonal component of V thereby obeys:
$$\vec{W}=\vec{V}-(\vec{V}\cdot\vec{u})\vec{u}$$

This is called the Gram-Schmidt orthogonalization process of vectors (or something like that)

 

[D H]

Before I give you the answer, is this homework, and what have you done? This is much easier with vector math than trig functions; in fact you will have to pretty much solve the problem using vector math before you can even start using trig functions.

EDIT:
Never mind. Arildno already gave the answer.

 

[_Nate_]

No, it's not homework -- I'm working on a physics simulator just for fun. I had already had it implemented, as I said, but my implementation was using lots of trig functions, which are expensive. I was pretty sure that there was a better way, though.

 

[HallsofIvy]

Then I would suggest writing Taylor polynomials to approximate the trig functions. If you really want it fast you might write them in assembly language (although I believe with modern compilers you don't really save much by going to assembly language).

 

[kkrizka]

I have a small suggestion. Store the vectors in the form of the three x,y,z components, as you will have to decompose them anyways to do most of the math. Only convert them into the magnitude when needed (energy calculations, status display...) using Pythogeran Theorem.

That is what I do in my homebrew vector library.

 

[_Nate_]

To HallsofIvy: This is quite a good idea, although it does suffer some accuracy loss. A far better way to do it is in the first reply to this topic. This can be done via other math (namely, the dot product) without ever touching trig functions.

To kkrizka: I do store my vectors as x, y, and z components. However, my decomposition is about an arbitrary vector, not about the x, y, or z axes.