 # Boost :

Subject: Re: [boost] different matrix library?
From: Edward Grace (ej.grace_at_[hidden])
Date: 2009-08-14 17:28:49

>> for 3d rotation one should consider quaterninons - not a matrix
>>
> We're speaking of users land here. They have the right to choose w/e
> structure they want.
> Some API requires you to work with matrix to buidl rotations and
> except
> some kind of float** later.

Again - back with my oar. As an aside, quaternions can be
*represented* [*] as matrices. In the simpler case, consider a
complex number:

Z = r*ONE + i*IMAG;

where r and i are the scalar real and imaginary components, ONE is
the identity 2x2 matrix,

1 0
0 1

and IMAG is the anti-symmetric 2x2 matrix

0 -1
1 0

Conjugating a complex number is identically the same as transposing
its matrix representation. Quaternions have a similar isomorphism
with 4x4 real matrices.

So - and I appreciate this is flirting with absurdity, nothing like
making a tricky subject more abstract I guess....

Would it be possible to have entirely abstracted matrices, ones that
do not contain any numbers, just rules for their combination
(multiplication etc)?

For example, if we were to do:

abstract_matrix<2> Z;

// First template argument is number of dims, second the locations
of the +1 elements.
Z = 3.0*abstract_symmetric_matrix<2,0>() +
4.0*abstract_antisymmetric_matrix<2,1>();

we would end up with a matrix Z that contains just two independent
values (3,4) as before but crucially also contains all the rules for
its multiplication so that:

double length_squared = Z*transpose(Z);

is, for example, an entirely valid operation that reduces to
length_squared = 3^2+4^2 and has the type of an
abstract_symmetric_matrix<2,0> which is identically castable to a
scalar.

As another example, the previously quoted:

transpose(a)*b

outer product when applied to a pair of vectors of length 3 will
always result in a matrix with 6 independent components (the same
number of degrees of freedom that we started with). The resulting
matrix (representing a 2 form) is therefore not a general matrix at
all. Therefore when using that resulting matrix why should we use up
9 chunks of memory and repeat calculations when we only need to store
6 and can subsequently reduce the number of calculations. Obviously
this is a trivial example, but when the matrix is NxN it can be
significant.

The parting shot is that if one can see through the layers of
abstraction there is a real possibility for building a phenomenally
efficient linear algebra library that is practically self aware!

-ed

[*] Emphasis since I'm trying to invoke the concept of representation
theory.