Matrice symétrique "intelligente" Numpy

Question

Existe-t-il une matrice symétrique intelligente et compacte dans numpy qui remplit automatiquement (et de manière transparente) la position à [j][i] lorsque [i][j] est écrit ?

import numpy
a = numpy.symmetric((3, 3))
a[0][1] = 1
a[1][0] == a[0][1]
# True
print(a)
# [[0 1 0], [1 0 0], [0 0 0]]

assert numpy.all(a == a.T) # pour toute matrice symétrique

Un Hermitien automatique serait également agréable, bien que je n'en aurai pas besoin au moment de l'écriture.

Answer 1

Il est trivial de remplir de manière pythonique [i][j] si [j][i] est rempli. La question du stockage est un peu plus intéressante. On peut augmenter la classe de tableau numpy avec un attribut packed qui est utile à la fois pour économiser le stockage et pour lire ultérieurement les données.

class Sym(np.ndarray):

    # classe wrapper pour le tableau numpy pour les matrices symétriques. Le nouvel attribut peut emballer la matrice pour optimiser le stockage.
    # Utilisation :
    # Si vous avez une matrice symétrique A comme un tableau numpy de forme (n,n), Sym(A).packed est un tableau numpy de forme (n(n+1)/2,) 
    # qui est une version compressée de A. Pour le convertir à nouveau, il suffit d'emballer la liste à plat dans Sym(). Notez que Sym(Sym(A).packed)

    def __new__(cls, input_array):
        obj = np.asarray(input_array).view(cls)

        if len(obj.shape) == 1:
            l = obj.copy()
            p = obj.copy()
            m = int((np.sqrt(8 * len(obj) + 1) - 1) / 2)
            sqrt_m = np.sqrt(m)

            if np.isclose(sqrt_m, np.round(sqrt_m)):
                A = np.zeros((m, m))
                for i in range(m):
                    A[i, i:] = l[:(m-i)]
                    A[i:, i] = l[:(m-i)]
                    l = l[(m-i):]
                obj = np.asarray(A).view(cls)
                obj.packed = p

            else:
                raise ValueError('La longueur d'entrée unidimensionnelle doit être un nombre triangulaire.')

        elif len(obj.shape) == 2:
            if obj.shape[0] != obj.shape[1]:
                raise ValueError('L'entrée bidimensionnelle doit être une matrice carrée.')
            packed_out = []
            for i in range(obj.shape[0]):
                packed_out.append(obj[i, i:])
            obj.packed = np.concatenate(packed_out)

        else:
            raise ValueError('Le tableau d'entrée doit être en 1 ou 2 dimensions.')

        retourner obj

    def __array_finalize__(self, obj):
        if obj is None: return
        self.packed = getattr(obj, 'packed', None)

```