# [PYTHON MATRIX-SIG] Let's get going

James Hugunin jjh@mama-bear.lcs.mit.edu
Wed, 13 Sep 95 12:39:13 -0400

```In my previous post I comment on what appears to be the primary source of
controversy for the matrix object, whether it should be treated as a table
of numbers, or as a true mathematical matrix.  I'm afraid that that issue is
likely to be the source of substantial more discussion before anything is
decided.

I would also like to comment on some of the less controversial points
raised by Jim Fulton in his first post regarding basic methods for matrix
objects.

>> transpose - The transpose of the matrix (not needed if "~" is used for
>> transpose)
> I'm thinking that this (or ~) should return by reference.

I agree completely.  In fact, when I went about implementing matrix slices
(so that m[((1,3),)] can be properly returned by reference, I noticed that
transposing a matrix was trivially implemented by converting it to a matrix
slice.  This of course raises the issue of how to properly deal with these
matrix slices.

For example, the way my code is written now, if I try to add a slice to a
matrix, I can perform the operation quickly without needing to convert the
slice to a matrix, as long as the slice meets a fairly obscure list of
requirements.  Basically these can be summarized as the fact that there must
be a constant offset between the indices for each dimensions.  ie.

M[((1,3,5),)] would be easy to deal with (as fast as a matrix) whereas:
M[((1,3,6),)] would not be

automatic coercion as being a possible source of errors (which I've come
around to agreeing with in general).  On the other hand, conceptually, it
would be nice to be able to treat a slice exactly the same as a matrix
whenever possible.

I see three options, none of which seems perfect, but I am inclined towards
the third.

1) Don't allow slices to be passed to functions which require a matrix
argument, and don't allow numeric operations on slices

2) Treat a slice just like any other non-matrix sequence, and allow numeric
operations, and allow it to be passed to matrix functions using the generic
sequence to matrix functions (there is an interesting issue here having to
do with copying data back from the matrix to the input sequence if it turns
out that the function modifies it's input data.  I'm curious as to how you
deal with this, or whether you just don't allow this to happen).

3) Whenever a slice is passed to a function requiring a matrix argument,
automatically copy the data from the slice to a contiguous block of memory.
Allow slices to be used in numeric operations, doing this efficiently where
possible, and copying the slice to a contiguous block of memeory where not
possible.  This would be the most efficient solution.

>> byteswap - Useful for reading data from a file written on a machine with a
>> different byte order

> Hm. Does this operate in-place or return a value?

In-place.  In fact, I am tempted to try and make all of the methods on
matrices operate "in-place" in order to be in line with list objects.

>> typecast(t) - Returns a new matrix of the same dimensions where each item
>> is cast (using C typecasting rules) from the matrix's type to the new type
>> t.

>Our constructor already gives you this:

>  new_matrix=Matrix(old_matrix,new_type)

True.  My problem is that I am frequently having to cast between types (I
deal with samples of sound that usually have to come in and go out as
shorts, but which I usually want to operate on as floats in the meantime).

So, I agree that this should be done using the matrix constructor, and all
that I'd add is that the matrix constructor should be written so that this
typecasting is done efficiently.

-Jim Hugunin   hugunin@mit.edu

=================
MATRIX-SIG  - SIG on Matrix Math for Python

send messages to: matrix-sig@python.org