Array division- translating from MATLAB to Python

Question

I have this line of code in MATLAB, written by someone else:

c=a.'/b

I need to translate it into Python. a, b, and c are all arrays. The dimensions that I am currently using to test the code are:

a: 18x1,
b: 25x18,

which gives me c with dimensions 1x25.

The arrays are not square, but I would not want the code to fail if they were. Can someone explain exactly what this line is doing (mathematically), and how to do it in Python? (i.e., the equivalent for the built-in mrdivide function in MATLAB if it exists in Python?)

Answer 1

In Matlab, A.' means transposing the A matrix. So mathematically, what is achieved in the code is A^T/B.

---

How to go about implementing matrix division in Python (or any language) (Note: Let's go over a simple division of the form A/B; for your example you would need to do A^T first and then A^T/B next, and it's pretty easy to do the transpose operation in Python |left-as-an-exercise :)|)

You have a matrix equation C*B=A (You want to find C as A/B)

RIGHT DIVISION (/) is as follows:

C*(B*B^T)=A*B^T

You then isolate C by inverting (B*B^T)

i.e.,

C = A*B^T*(B*B^T)' ----- [1]

Therefore, to implement matrix division in Python (or any language), get the following three methods.

• Matrix multiplication
• Matrix transpose
• Matrix inverse

Then apply them iteratively to achieve division as in [1].

Only, you need to do A^T/B, therefore your final operation after implementing the three basic methods should be:

A^T*B^T*(B*B^T)'

Note: Don't forget the basic rules of operator precedence :)

Answer 2

The symbol "/" is the matrix right division operator in MATLAB, which calls the MRDIVIDE function. From the documentation, matrix right division is related to matrix left division in the following way:

B/A = (A'\B')'

If A is a square matrix, B/A is roughly the same as B*inv(A) (although it's computed in a different way). Otherwise, X = B/A is the solution in the least squares sense to the under- or overdetermined system of equations XA = B.

More detail about the algorithms used for solving the system of equations is given in the link to the MRDIVIDE documentation above. Most use LAPACK or BLAS. It's all rather complicated, and you should check to see if Python already has an MRDIVIDE-like function before you try to do it yourself.

EDIT:

The NumPy package for Python contains a routine lstsq for computing the least-squares solution to a system of equations, as mentioned in a comment by David Cournapeau. This routine will likely give you comparable results to using the MRDIVIDE function in MATLAB, but it is unlikely to be exact. Any differences in the underlying algorithms used by each function will likely result in answers that differ slightly from one another (i.e. one may return a value of 1.0, whereas the other may return a value of 0.999). The relative size of this error could end up being larger, depending heavily on the specific system of equations you are solving.

To use lstsq, you may have to adjust your problem slightly. It appears that you want to solve an equation of the form cB = a, where B is 25-by-18, a is 1-by-18, and c is 1-by-25. Applying a transpose to both sides gives you the equation B^Tc^T = a^T, which is a more standard form (i.e. Ax = b). The arguments to lstsq should be (in this order) B^T (an 18-by-25 array) and a^T (an 18-element array). lstsq should return a 25-element array (c^T).

Disclaimer: I don't know if Python makes any distinction between a 1-by-N or N-by-1 array, so transposes may not be necessary for 1-dimensional arrays. MATLAB certainly considers them as different, and will yell at you for it. =)

Answer 3

[edited] As Suvesh pointed out, i was completely wrong before. however, numpy can still easily do the procedure he gives in his post:

A = numpy.matrix(numpy.random.random((18, 1))) # as noted by others, your dimensions are off
B = numpy.matrix(numpy.random.random((25, 18)))
C = A.T * B.T * (B * B.T).I

Answer 4

The line

c = a.' / b

computes the solution of the equation c b = a^T for c. Numpy does not have an operator that does this directly. Instead you should solve b^T c^T = a for c^T and transpose the result:

c = numpy.linalg.lstsq(b.T, a.T)[0].T