Python lazy оценка numpy ndarray

Question

У меня есть большой 2D-массив, который я бы хотел объявить один раз, и изменил значение только значений в зависимости от параметра, не пересекая весь массив.

Чтобы построить этот массив, я подклассифицировал класс numpy ndarray с помощью dtype=object и назначил элементам, которые я хочу изменить, например. :

def f(parameter): 
    return parameter**2 

for i in range(np.shape(A)[0]): 
    A[i,i]=f 
    for j in range(np.shape(A)[0]): 
     A[i,j]=1. 

Я затем переопределен метод __getitem__ так, что он возвращает оценку функции с заданным параметром, если она является вызываемой, в противном случае возвращает само значение.

def __getitem__(self, key): 
     value = super(numpy.ndarray, self).__getitem__(key) 
     if callable(value): 
      return value(*self.args) 
     else: 
      return value 

, где self.args ранее были приведены к экземпляру MyClass.

Тем не менее, мне нужно работать с массивами с плавающей точкой в ​​конце, и я не могу просто преобразовать этот массив в массив с помощью этой техники. Я также попытался использовать виды numpy, которые не работают ни для dtype=object.

У вас есть альтернатива? Должен ли я переопределить метод view, а не getitem?

Редактировать Возможно, мне придется использовать Cython в будущем, поэтому, если у вас есть решение, включающее, например, C указатели, мне интересно.

Answer 1

В этом случае не нужно связывать функцию преобразования с каждым индексом вашего массива.

Вместо этого более эффективным подходом было бы определить преобразование как функцию вместе с подмножеством массива, к которому оно относится. Вот базовая реализация,

import numpy as np 

class LazyEvaluation(object): 
    def __init__(self): 
     self.transforms = [] 

    def add_transform(self, function, selection=slice(None), args={}): 
     self.transforms.append((function, selection, args)) 

    def __call__(self, x): 
     y = x.copy() 
     for function, selection, args in self.transforms: 
      y[selection] = function(y[selection], **args) 
     return y 

, которые могут быть использованы следующим образом:

x = np.ones((6, 6))*2 

le = LazyEvaluation() 
le.add_transform(lambda x: 0, [[3], [0]]) # equivalent to x[3,0] 
le.add_transform(lambda x: x**2, (slice(4), slice(4,6))) # equivalent to x[4,4:6] 
le.add_transform(lambda x: -1, np.diag_indices(x.shape[0], x.ndim),) # setting the diagonal 
result = le(x) 
print(result) 

, который печатает,

array([[-1., 2., 2., 2., 4., 4.], 
     [ 2., -1., 2., 2., 4., 4.], 
     [ 2., 2., -1., 2., 4., 4.], 
     [ 0., 2., 2., -1., 4., 4.], 
     [ 2., 2., 2., 2., -1., 2.], 
     [ 2., 2., 2., 2., 2., -1.]]) 

Таким образом, вы можете легко поддерживать все передовые индексацию Numpy (элемент по доступ к элементам, нарезка, удобная индексация и т. д.), в то же время сохраняя ваши данные в массиве с собственным типом данных (float, int и т. д.) whi ch намного эффективнее, чем использование dtype='object'.