«Индекс 1 выходит за границы для оси 0 с размером 1» в Python

Question

Кажется, у меня проблема с индексацией? Я не знаю, как интерпретировать эту ошибку ...: / Я думаю, что это связано с тем, как я инициализировал вас.

У меня есть матрица 3x3 G, которую я создал, используя переменную u (вектор, x - y). Я только что сделал нулевую матрицу на данный момент, потому что я не совсем уверен, как ее кодировать, есть много частичных и норм, связанных с ха-ха. x_j = (x_1 (j), x_2 (j), x_3 (j)) и y_j = (y_1 (j), y_2 (j), y_3 (j)). x и y являются nx3 векторами. alpha_j - это матрица 3x3 Матрица A является блочной диагональной матрицей размером 3nx3n. У меня проблемы с матрицей W (размер 3nx3n, где (i, j) -й блок - это матрица 3x3, заданная alpha_i * G_ [ij] * alpha_j).

def G(u):

    u1 = u[0]
    u2 = u[1]
    u3 = u[2]
    g = np.array([[0,0,0],[0,0,0],[0,0,0]],complex)  

    return g

def W(x, y, k, alpha, A):

    # initialization
    n = x.shape[0] # the number of x vextors 
    result = np.zeros([3*n,3*n],complex)
    u = np.matlib.zeros((n, 3)) # u = x - y 
    print(u)
    num_in_blocks = n

    # variables
    a_i = alpha_j(alpha, A)
    a_j = alpha_j(alpha, A)

    for i in range(0, 2):
        x1 = x[i] # each row of x
        y1 = y[i] # each row of y
        for j in range(0, n-1):
            u[i][j] = x1[j] - y1[j] # each row of x minus each row of y
        if i != j:
            block_result = a_i * G((u[i][j]), k) * a_j
            for k in range(num_in_blocks):
                for l in range(num_in_blocks):
                    result[3*i + k, 3*j + l] = block_result[i, j] 

    return result

def alpha_j(a, A):
    alph = np.array([[0,0,0],[0,0,0],[0,0,0]],complex)
    n = A.shape[0]
    rho = np.random.rand(n,1)
    for i in range(0, n-1):
        for j in range(0, n-1):
            alph[i,j] = (rho[i] * a * A[i,j])
    return alph

#------------------------------------------------------------------

# random case

def x(n):
    return np.random.randint(100, size=(n, 3))

def y(n):
    return np.random.randint(100, size=(n, 3))

# SYSTEM PARAMETERS

theta = 0 # can range from [0, 2pi)

chi = 10 + 1j

lam = 0.5 # microns (values between .4-.7)

k = (2 * np.pi)/lam # 1/microns

V_0 = (0.05)**3 # microns^3

K = k * np.array([[0], [np.sin(theta)], [np.cos(theta)]])

alpha = (V_0 * 3 * chi)/(chi + 3)

A = np.matlib.identity(3) 

#------------------------------------------------------------------

# TEST FUNCTIONS

w = W(x(3), y(3), k, alpha, A)
print(w)

Я получаю сообщение об ошибке «недопустимый индекс в скалярной переменной». на линии u1 = u [0].

Answer 1

np.matlib составляет np.matrix, подкласс np.ndarray. Предполагается, что он дает ощущение MATLAB, и (почти) всегда создает 2d массив. Его использование в новом коде не рекомендуется.

In [42]: U = np.matrix(np.arange(9).reshape(3,3))                                    
In [43]: U                                                                           
Out[43]: 
matrix([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])

Индексирование с помощью [0] выбирает первую строку, но возвращает двумерную матрицу.

In [44]: U[0]                                                                        
Out[44]: matrix([[0, 1, 2]])
In [45]: U[0].shape                                                                  
Out[45]: (1, 3)

Добавление еще одного [1] по-прежнему индексирует первое измерение (которое теперь имеет размер 1):

In [46]: U[0][1]                                                                     
---------------------------------------------------------------------------
IndexError: index 1 is out of bounds for axis 0 with size 1

Обычно мы индексируем numpy массивы с помощью составного индекса:

In [47]: U[0,1]                                                                      
Out[47]: 1

Если вместо этого мы сделаем ndarray:

In [48]: U = np.arange(9).reshape(3,3)                                               
In [49]: U                                                                           
Out[49]: 
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
In [50]: U[0]                                                                        
Out[50]: array([0, 1, 2])      # 1d
In [51]: U[0][1]               # works,                                                       
Out[51]: 1
In [52]: U[0,1]                # still preferable                                                      
Out[52]: 1