If the group operation is denoted <>, with identity e, and the inverse of 'a' is 'inv(a)' then you would do
a = a0;
b = b0; // initial assignment
a = a <> b; // a = a0 <> b0 and b = b0.
b = a <> inv(b); // a = a0 <> b0 and b = a0 <> b0 <> inv(b0) = a0.
a = inv(b) <> a; // a = inv(a0) <> a0 <> b0 = b0 and b = a0.
It works when a and b are nonzero floats, which are a group under multiplication with identity 1.0 and inverses inv(x) = 1/x (but see ).
It works when a and b have fixed-length binary representations, because fixed-length binary strings are a group where the operation is xor (or '^') and inv(x) = x.
It works when a and b are matrices of the same dimension, which form a group in two different ways - under matrix addition, where the inverse is elementwise negation, and under matrix multiplication (if a and b are nonsingular) where the inverse is the regular matrix inverse .
Note that in my third line, the right-hand side of the assignment is inv(b) <> a, whereas all the examples in the blog post used a <> inv(b). They were implicitly assuming a commutative group (i.e. a <> b == b <> a for all a and b) whereas my procedure works even for non-commutative groups, e.g. matrices under matrix multiplication.
Edit: Obviously, if you actually use this in real code... WAT.
 this even works if one of the operations causes an integer overflow - the magic of modular arithmetic!
 floats don't really form a group, because of non-associativity of floating point multiplication.
Most people would call this group (Z/2Z)^n, i.e. n copies of Z/2Z under addition. Similarly, for "matrix addition" you could say Z^(mn) or R^(mn) for matrices with dimension mxn with elements Z or R (or whatever you are filling your matrices with). Your only non-abelian example is matrix multiplication, i.e. GL(n,R), general linear transformations of dimension n over R. It may or may not be interesting that this is mainly focused on abelian groups.
For those who haven't seen the video : http://www.youtube.com/watch?v=D0EIZa5e9q4&t=0m40s
In groupoids the binary operation isn't total, i.e. there can be pairs (a,b) for which a <> b is not defined -- so we can't use groupoids.
In quasigroups and loops the binary operation doesn't need to be associative. But we require associativity, so that we can deduce
(a <> b) <> inv b == a <> (b <> inv b) == a <> e == a
x \ (x * y) = y
x * (x \ y) = y
(x * y) / y = x
(x / y) * y = x