An interactive guide to sensor fusion with quaternions(quaternion.cafe)
quaternion.cafe
An interactive guide to sensor fusion with quaternions
https://quaternion.cafe/
28 comments
> quotient of two vectors
How does it make sense to divide a vector by another? Can we at least multiply two vectors as well? (So that if the quaternion q is the vector a divided by the vector b, then q times b is a)
How does it make sense to divide a vector by another? Can we at least multiply two vectors as well? (So that if the quaternion q is the vector a divided by the vector b, then q times b is a)
In a particular sense, division and subtraction are more general than their supposedly more primitive inverse operations.
For example, we can take the "difference" of two points to get a vector, i.e. the grocery store is in that direction, while it doesn't make much sense to add two points---this location plus the grocery store? Similarly with temperature (of a given scale), today can be 5 degrees hotter than yesterday, but saying "the total temperature between yesterday and today is 57 degrees" doesn't have a clear meaning.
So, in that vein, what operation transforms one 3D vector into another?
Well a combination of rotation and scaling, of course! There is some freedom in how you want to represent this scaling+rotation operation; we could use 3x3 matrices, meaning that the quotient of 3D vectors is reasonably described by a matrix. However, 3x3 matrices have 9 degrees of freedom, which is way overkill, since we just need 4 numbers: an axis (2 params), an angle, and a scale factor. For this reason, quaternions are a particularly natural representation of 3D vector division.
The general concept of division that we're getting at here has the terrible name "g-torsor". If you're not familiar with abstract algebra, though, the definition is not very enlightening. However, John Baez has a really accessible article[0] that comes to the rescue!
Side note: notice that in general, the results of division are different objects than the things doing the division. As such, it's somewhat unfortunate that we use the same units for both in many cases, e.g. temperature and temperature differences are really different things. Talking about units quickly turns into type theory, though, so I'll stop there.
[0]:https://math.ucr.edu/home/baez/torsors.html
For example, we can take the "difference" of two points to get a vector, i.e. the grocery store is in that direction, while it doesn't make much sense to add two points---this location plus the grocery store? Similarly with temperature (of a given scale), today can be 5 degrees hotter than yesterday, but saying "the total temperature between yesterday and today is 57 degrees" doesn't have a clear meaning.
So, in that vein, what operation transforms one 3D vector into another?
Well a combination of rotation and scaling, of course! There is some freedom in how you want to represent this scaling+rotation operation; we could use 3x3 matrices, meaning that the quotient of 3D vectors is reasonably described by a matrix. However, 3x3 matrices have 9 degrees of freedom, which is way overkill, since we just need 4 numbers: an axis (2 params), an angle, and a scale factor. For this reason, quaternions are a particularly natural representation of 3D vector division.
The general concept of division that we're getting at here has the terrible name "g-torsor". If you're not familiar with abstract algebra, though, the definition is not very enlightening. However, John Baez has a really accessible article[0] that comes to the rescue!
Side note: notice that in general, the results of division are different objects than the things doing the division. As such, it's somewhat unfortunate that we use the same units for both in many cases, e.g. temperature and temperature differences are really different things. Talking about units quickly turns into type theory, though, so I'll stop there.
[0]:https://math.ucr.edu/home/baez/torsors.html
It doesn't make sense in and of itself. We usually think
of division as a closed operation: we divide two things (like real numbers) and we get the same kind of thing out (another real number).
In Hamilton's original view of quaternions, he defined a "geometric quotient" of two 3d directed lines (one kind of object) as being a quaternion (another kind of object), and gave all sorts of complicated geometric formulas for how to calculate it.
In Hamilton's original view of quaternions, he defined a "geometric quotient" of two 3d directed lines (one kind of object) as being a quaternion (another kind of object), and gave all sorts of complicated geometric formulas for how to calculate it.
> How does it make sense to divide a vector by another? Can we at least multiply two vectors as well?
This is all about how you abstractly define things like addition and multiplication. We'll call these actions an "operator". So you got these basic algebraic structures:
Group: a set (some numbers) and an operator (like + or *. I'll use ∘ to be general) that has associativity ( (a∘b)∘c = a∘(b∘c) ), an identity ( a∘=a ), and an inverse ( a∘ā=0 ). There's also closure which just means we don't create something that's outside the set ( ∀ a,b ∊ S, a∘b ∊ S )
Abelian Group: We also have commutativity ( a∘b=b∘a )
Ring: Think of as 2 groups. So we now have 2 operators ( ∘,▪ )[1]. This time ∘ is an Abelian Group and ▪ has closure, associativity ( (a▪b)▪c = a▪(b▪c) ), and is distributive with ∘ ( a∘(b▪c) = (a∘b)▪(a∘c) )
Field: Extend that ring so now ∘,▪ are both Abelian Groups (▪ got an identity element, an inverse, and commutativity), but we give an exception for the inverse on identity of ∘[2]
Now we extend this to 3D. Ops, we get a problem. Really no way to make ▪ () consistent here, especially around division. Bummer. We have a Ring.
But going up to 4D we can use a similar rule as to what we did in 2D and get a Field again! Now we can do consistent math. And this is actually why quaternions become useful for 3D rotation. But they can do a lot more, though come with some limitations as well.
This is super high level and just scratches the surface of all of this stuff but I hope it at least makes some sense here. Please ask questions and I'm also sure someone else will add some useful comments. But your question is completely normal and actually gets to the motivation of why kids these days are learning the difference between 39 and 93, despite having the same answer they do mean different things and understanding that earlier helps you when you get to abstract nonsense.
[0] It is taught later because this is when you first start getting into math as being about abstractions. You basically learn that you only ever learned one very specific kind of math and that all that breaks down. Your question is absolutely on point due to this. Like how you probably learned matrix multiplication and learned that AB ≠ BA
[1] Whatever ∘,▪ these will usually be referred to as "addition" and "multiplication" but just note that they aren't the same thing you're probably thinking of
[2] Let's return to less abstraction for a second. We have + and for (standard) addition and multiplication, right? 0 is the identity element for + and note that 0 doesn't have an inverse for multiplication. That is: we can't do a * (0^-1) = a/0. Note here that / is a shorthand for * with an inverse operator.
in other words, dilation + rotation
Also, "double" rotations, which have no analogue in 3D space. The extra degree of freedom in 4D lets you perform 2 orthogonal rotations. This means that you can rotate around in 4D space, leaving only the origin fixed. In 3D rotations always fix some axis.
Trying to think about this stuff can be mind-bending, since it's natural to try to visualize things. So to give a little intuition, consider the coordinates of a 4D vector (x,y,z,w) and notice that we can spin around in both the x-y and z-w planes at the same time without interfering with each other!
Trying to think about this stuff can be mind-bending, since it's natural to try to visualize things. So to give a little intuition, consider the coordinates of a 4D vector (x,y,z,w) and notice that we can spin around in both the x-y and z-w planes at the same time without interfering with each other!
That’s nice. I’m interested in why you went for a complementary filter specifically, if it was enough for your purpose or just the first one you tried out. (I see you reference the ahrs package where there are also implementations for other attitude estimators.)
Indeed there is a whole world of observers over Lie groups. Examples:
https://en.wikipedia.org/wiki/Invariant_extended_Kalman_filt...
https://trumpf.id.au/pubs/Hua_Zamani_Trumpf_Mahony_Hamel_CDC...
https://en.wikipedia.org/wiki/Invariant_extended_Kalman_filt...
https://trumpf.id.au/pubs/Hua_Zamani_Trumpf_Mahony_Hamel_CDC...
I don't why people get so excited about quaternions, like they are some mystical concept.
Personally, I think one is better off learning some Differential Geometry and Abstract Algebra to really appreciate the broader context in which these exist.
Personally, I think one is better off learning some Differential Geometry and Abstract Algebra to really appreciate the broader context in which these exist.
/* Produce a quaternion from an axis-angle representation.*/
function quat_from_axis(theta: number, x: number, y: number, z: number) {
const halfcos = Math.cos(theta * 0.5);
const halfsin = Math.sin(theta * 0.5);
return new Quaternion(
halfcos,
axis[0] * halfsin,
axis[1] * halfsin,
axis[2] * halfsin,
);
}
Hi! Author here. I hand wrote this website and the source code of the examples mostly comes from my own debugging tools. That method in particular is just a very minimal implementation of section 8.5.2 of this textbook (but I tried to make it friendly for the blog post).
https://gamemath.com/book/orient.html#quaternion_geometry
https://gamemath.com/book/orient.html#quaternion_geometry
Sorry, but x,y and z are not even being used in that function...
LOL ok yeah, that's a copy-paste issue. I'll fix it up here shortly.
imo it's better to express the conversion relation as exp-log pairs:
fn exp(q: Quat) -> Quat {
let ijk = sqrt(q.i*q.i + q.j*q.j + q.k*q.k);
Quat {
i: exp(q.l) * sin(ijk) * q.i / ijk,
j: exp(q.l) * sin(ijk) * q.j / ijk,
k: exp(q.l) * sin(ijk) * q.k / ijk,
l: exp(q.l) * cos(ijk),
}
}
fn log(q: Quat) -> Quat {
let ijk = sqrt(q.i*q.i + q.j*q.j + q.k*q.k);
Quat {
i: atan2(ijk, q.l) * q.i / ijk,
j: atan2(ijk, q.l) * q.j / ijk,
k: atan2(ijk, q.l) * q.k / ijk,
l: 0.5 * log(q.i*q.i + q.j*q.j + q.k*q.k + q.l*q.l),
}
}I've been seeing "that's vibe coded" comments a lot lately on posts. Comments that call out code that may or may not be vibe-coded. At what point should these types of posts start getting down-voted? It's not constructive, and IMO imparts a negative connotation.
HN: Show HN Awesome New LLM can Code!! Also HN: TFA is vibe coded angry pitchfork or ugh
HN: Show HN Awesome New LLM can Code!! Also HN: TFA is vibe coded angry pitchfork or ugh
I agree, this is becoming HN's new favourite way to detail a conversation unproductively. It's up there with doxxing and ad hominems in my opinion - unverifiable and usually antagonistic.
Yes, and low effort backhanded comments about "AI slop" are also getting tiresome.
What makes you so confident that you can tell that a 3-line function is AI? Especially given that the author denies it, with evidence.
It cannot work, because x,y,z are not used at all.
This looks more like a copy paste error, where the function signature requests xyz, but the function itself uses an undefined array "axis" of which xyz correspond to indexes 0-2.
The code is correct aside from the obvious bug.
Bugs predate the existence of AI by decades. This particular bug doesn't look like one an AI would write.
The code is correct aside from the obvious bug.
Bugs predate the existence of AI by decades. This particular bug doesn't look like one an AI would write.
unused variables is typical LLM.
Also it's a short function. It's impossible to miss unused parame if you read your own code at all. And if you somehow don't... then it's deserved anyway.
Also it's a short function. It's impossible to miss unused parame if you read your own code at all. And if you somehow don't... then it's deserved anyway.
Maybe typical LLM of a year ago. If a function was one-shot written by an LLM today, it would not make that mistake.
It could make that mistake if it writes the header at one point, and the body separately. Though that's unlikely.
But I suspect this is a genuine human error.
It could make that mistake if it writes the header at one point, and the body separately. Though that's unlikely.
But I suspect this is a genuine human error.
Then again, that's just the AI would say...
I love vibe coding. Even the variables don't match (x, y, x vs axis[3]) and the coder is left with no knowledge what's they doing. You'll probably either prompt for fixing it or fix it yourself, but will still not get substantial amount of the domain knowledge -- and let's be honest, this is example just the simplest term there, that's why the code is so easy to correct even without thinking...
I just figured out from subcomments it's an excerpt from article, so my comment just doesn't fit here (thought author of the comment I replied to just braged they can vibe code something ad hoc and don't need to read about domain). Apologies for the mistake (still keeping my opinion about vibe coding).
A unit quaternion represents a rotation in R³.
A quaternion represents the quotient of two vectors in R³. That's what Hamilton had in mind.