Re: Efficiency of code generated by Ada compilers

["Elias Salomão Helou Neto" <eshneto@gmail.com>]

> Well, maybe, but it is already done in Ada.

Really? This is great. Also, Ada compile-time checking features are
(seem to be) truly impressive, but I did not feel compelled to learn a
whole new language only because of them. Furthermore, C++ can use so
many numeric libraries which I am not sure would be available in Ada
that I tend to stay here in my comfort zone.

> I don't see any gain, because this is trivial compared to the real
> challenges of modeling linear algebraic types. Consider description of the
> types on which the matrix multiplication is defined. E.g.: NxMxK * KxM = N.
> Here NxM denotes matrix with dimensions N and M. Is it one type or many
> types or many subtypes? Templates give no choice but many different
> unrelated types, when dimensionality is a parameter. Not my choice. Now you
> have a combinatorial explosion of overloaded variants. Generate them, all
> possible multiplication operation profiles for 4D, 3D, 2D, 1D matrices.
> Make the constraint on matrix size in given dimension statically enforced
> with an appropriate (understandable!) error messages when sizes are
> statically known.

Not quite, because you could possibly write a templated operator* that
could make use of inhomogeneous operands (by that I mean different
types on each side of the operator call). To be honest, I am not sure
about how I would fill in the details, nor this is my concern now. But
I tend to believe it could be possibly done with compiler generated
code in C++0x (thanks to specialization, templates are also Turing
complete in that language!).

> Allow unconstrained matrices as well. Generate aggregates
> for each matrix type. Provide matrix slicing operations for all types of
> matrices (e.g. column from matrix, row from matrix, submatrix from matrix
> etc). Have fun!

I guess I will have! Really, this is fun. Just kidding, but I do not
actually see that amount of trouble if you could write a "slice
indexing" class that could be passed to some slicing operator (this
may not even be needed at all). It would be the proverbial "extra
layer of indirection" required to make the job easier, but let us not
delve in such details.

I really appreciate your interest and would be pleased to go on with
our conversation, even though it has gone off-topic.

Elias Salomão Helou Neto