Python 中的矩阵运算

Question

I want to write a function so that it takes a Matrix, a row number and a column number. And thereafter to get the matrix such that 1 in the A(i,j) position and zeros in all the other positions in the i-th column using only row operations. I am new to Python. Please give me some help. Thank you.

How I started is as this,

import numpy as np

def A = np.array([B]) # the matrix B is yet to provide

def i = A[i,:]

def j= A[:,j]

But this doesn't seems to be working!

Answer 1

`

import numpy as np

m = np.array([[1, 1, 1, 1],[2, 2, 2, 2],[3, 3, 3, 3]])


def func(matrix, col, row):
    matrix[:, col] = 0
    matrix[row, col] = 1


func(m, 1, 1)

print(m)`

hope it helps:)

Answer 2

Setup:

import numpy as np          
from functools import reduce

N = 6
A = np.random.randint(0,10,(N,N))
i,j = np.random.randint(0,N,2)
A
# array([[8, 9, 8, 1, 9, 4],
#        [0, 3, 5, 4, 5, 2],
#        [2, 7, 4, 6, 2, 7],
#        [9, 8, 1, 5, 1, 9],
#        [0, 1, 0, 8, 0, 3],
#        [3, 4, 5, 0, 6, 7]])
i,j
# (5, 1)

Helpers:

I = np.identity(N)                    
e = I[:,None]      # standard base row vectors                   
eT = I[...,None]   # standard base column vectors                                             

The row ops:

rowops = [I + eT[i]@e[i]*(1/A[i,j]-1)] + [I - (eT[k]*A[k,j])@(e[i]/A[i,j]) for k in range(6) if k!=i]                          

The first one scales the ith row. The others subtract the ith row times a factor from the kth row.

Let's apply them one by one and keep track of the jth column:

B = A.copy()                       
for r in reversed(rowops):
    print(B[:,j])
    B = r@B
# [9 3 7 8 1 4]
# [9. 3. 7. 8. 0. 4.]
# [9. 3. 7. 0. 0. 4.]
# [9. 3. 0. 0. 0. 4.]
# [9. 0. 0. 0. 0. 4.]
# [0. 0. 0. 0. 0. 4.]
print(B[:,j])
# [0. 0. 0. 0. 0. 1.]

Now let's combine all rowops into a single op by multiplying them:

combined = reduce(np.matmul,rowops)

This gives indeed the same result when applied to A

np.allclose(combined@A,B)
# True

This combined op we could have obtained directly:

R = I + (eT[i]-A@eT[j])@e[i]/A[i,j]

Check:

np.allclose(combined,R)
# True

Applied to A:

R@A
# array([[  1.25,   0.  ,  -3.25,   1.  ,  -4.5 , -11.75],
#        [ -2.25,   0.  ,   1.25,   4.  ,   0.5 ,  -3.25],
#        [ -3.25,   0.  ,  -4.75,   6.  ,  -8.5 ,  -5.25],
#        [  3.  ,   0.  ,  -9.  ,   5.  , -11.  ,  -5.  ],
#        [ -0.75,   0.  ,  -1.25,   8.  ,  -1.5 ,   1.25],
#        [  0.75,   1.  ,   1.25,   0.  ,   1.5 ,   1.75]])