On Fri, 4 Nov 2022 at 14:23, Phil Williams <pwilli...@tkc.edu> wrote:
Hi Phil,
> I use sympy for matrix calculations in my Finite Math class that I teach. I
> have students working in a Jupyter Notebook. What I want is a
> student-friendly interface for in-place row operations on matrices, so that
> they can work problems step by step that require these operations (e.g.
> solving systems by row reduction). Right now the Matrix class in sympy has
> methods row_swap, and row_op. The former, row_swap is fine, but row_op has a
> general functorial definition that is too advanced for them. I want instead
> row_add and row_mult methods that specify the basic data of the operation as
> inputs (e.g. for row_add, source row, target row, and factor that the source
> row gets multiplied by before adding to target), and modifies the matrix in
> place.
>
> Right now, I write a bit of code for them to redefine the Matrix class and
> adds these two methods to it, and then have them work with that. However, I'm
> wondering if these methods can be added to sympy. It would be useful to them
> and perhaps others using sympy in a classroom. I'm confident I know what
> needs to be done, but I'm inexperienced with open source and I'm not sure
> where to begin in suggesting this change be incorporated. Just exploring this
> question led me to the idea that posting here might be a good first step. Any
> advice would be appreciated!
> Thank you.
I agree that row_op has a weird interface. Probably whoever wrote that
thought that it's good to try to make things as general as possible
but in fact it's really turning a one liner into something that is
more complicated than just writing the code directly without using the
row_op method. The Matrix class already has far too many redundant
methods though and I'm not sure it's a good idea to add more. If
anything I'd rather just remove the row_op method if the interface was
being redesigned from scratch.
It isn't hard to make your own function to do this:
def row_mult(M, i, f):
"""Multiply row i of Matrix M by f in place and return M"""
M[i, :] *= f
return M
That being said, the function is just a one-liner and if you taught
the students about the more general concept of slicing then they could
do it themselves:
In [20]: M = eye(3)
In [21]: M[1,:] *= -3
Out[21]:
⎡1 0 0⎤
⎢ ⎥
⎢0 -3 0⎥
⎢ ⎥
⎣0 0 1⎦
In [22]: M[1,:] -= 2*M[0,:]
In [23]: M
Out[23]:
⎡1 0 0⎤
⎢ ⎥
⎢-2 -3 0⎥
⎢ ⎥
⎣0 0 1⎦
If they can understand how that slicing works then they can also
translate that to an understanding of many other things in Python like
lists, strings, numpy arrays etc because slicing is a fairly
ubiquitous idiom in Python.
Personally if I was teaching this stuff to students then I think I
would want them to make the function or code that does this themselves
using a loop so that they can understand the row operation in more
elementary algorithmic terms. Obviously that depends on exactly what
you're trying to teach so I'm not saying that your approach there is
wrong in any way. What I am saying though is that there are many
different ways that things like this could be taught and I'm not sure
we should add methods to the Matrix class to accommodate one
particular way.
--
Oscar
--
You received this message because you are subscribed to the Google Groups
"sympy" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to sympy+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/sympy/CAHVvXxSgP5%3DudLruO6a%3Da%3DHPrJW9soJVxChNUrENs73juLiYFw%40mail.gmail.com.
