Comment ajouter des tableaux à deux dimensions, coin par coin ?

Question

Question :

J'ai n tableaux carrés bidimensionnels d'ordre arbitraire. Pour simplifier, disons que j'ai 3 tableaux bidimensionnels A, B, C avec les ordres 3×3, 4×4, 2×2 respectivement. Ici :

   [[a a a]      [[b b b b]     [[c c]  
A=  [a a a]  ,B=  [b b b b] ,C=  [c c]]
    [a a a]]      [b b b b]
                  [b b b b]

Je sais que pour les tableaux bidimensionnels ayant le même nombre de lignes, nous pouvons les ajouter très facilement (en ajoutant simplement les colonnes latéralement), mais même si ces tableaux avaient le même nombre de lignes, je ne veux pas qu'ils soient ajoutés latéralement mais je veux créer à partir de ces 3 tableaux un autre tableau carré bidimensionnel d'ordre 3+4+2=9, c'est-à-dire un 9×9 array disons, coll_array . Ici :

            [[a a a 0 0 0 0 0 0]
             [a a a 0 0 0 0 0 0]
             [a a a 0 0 0 0 0 0]
             [0 0 0 b b b b 0 0]
coll_array=  [0 0 0 b b b b 0 0]
             [0 0 0 b b b b 0 0]
             [0 0 0 b b b b 0 0]
             [0 0 0 0 0 0 0 c c]
             [0 0 0 0 0 0 0 c c]]

Veuillez regarder attentivement le tableau ci-dessus. Je sais que ce n'est pas append mais Je ne suis pas de formation CS Je ne sais pas comment on peut l'appeler. I Je suis en train d'insérer les éléments de ces 3 tableaux dans ce tableau collectif.

Ce que j'ai essayé :

T = len(A)+len(B)+len(C)

Je sais que je peux d'abord initialiser un tableau bidimensionnel T×T :

coll_array=np.array([[0]*T]*T).reshape(T,T)
for i in range(T):
    for j in range(T):
        if (i< len(A)) and (j<len(A)):
           coll_array[i,j]=a  # yes i have same values in the individual arrays, would have been more complex with this method if not.
        elif (i>=len(A)) and (j>=len(A)) and (i<len(A)+len(B)) and (j<len(A)+len(B)):
           coll_array[i,j]=b
        elif (i>=len(A)+len(B)) and (j>=len(A)+len(B)) and (i<len(A)+len(B)+len(C)) and (j<len(A)+len(B)+len(C)):
           coll_array[i,j]=c
        else:
           coll_array[i,j]=0

Oui, cela pourrait fonctionner, mais le problème est que je n'ai pas seulement 3 tableaux carrés bidimensionnels à combiner, mais que j'en ai n, et que n peut être très grand, pour lequel je dois écrire n-1 instructions elif, ce qui nécessite une boucle ou autre. Je peux créer des variables globales dynamiques comme lensum1 for len(A) , lensum2 for len(A)+len(B) , lensum10 for len(A)+len(B)+...+ len(L) . Ce n'est pas un problème, mais écrire automatiquement ces nombreuses instructions elif est la tâche principale.

Nota: Je n'ai pas ces tableaux nommés A, B, C etc. Mais j'ai un autre tableau de ces tableaux comme ceci : ind_array= [A B C . . .] et je pourrais avoir besoin d'assigner un nom de variable globale à ces tableaux comme A1,A2, etc. si nécessaire, mais ce serait mieux s'ils peuvent être appelés directement en utilisant ind_array[0], ind_array[1] etc.

A propos de l'efficacité :

Bien entendu, je ne voudrais pas que mon programme vérifie autant de conditions if-elif pour chaque (i,j) Par conséquent, j'ai besoin d'une méthode pour ajouter ces tableaux d'un coin à l'autre, ou de tout autre programme efficace qui puisse accomplir cette tâche.

Merci. Toute aide sera appréciée.

Demande : S'il vous plaît, ne marquez pas ce sujet comme étant hors sujet et ne le fermez pas avant que je ne reçoive de l'aide.

Answer 1

Vous êtes à la recherche de scipy.linalg.block_diag :

import numpy as np
from scipy.linalg import block_diag

a = np.full((3,3), "a")
b = np.full((4,4), "b")
c = np.full((2,2), "c")

block_diag(a, b, c)
# or block_diag(*[list_or_arrays])

Ou faire la longueur variable d'un tableau carré (comme dans le commentaire) :

ind_array = ["a", "b", "c"]
shape_array = [3, 4, 2]

block_diag(*[np.full((i, i), c) for c, i in zip(ind_array, shape_array)])

Sortie :

array([['a', 'a', 'a', 0, 0, 0, 0, 0, 0],
       ['a', 'a', 'a', 0, 0, 0, 0, 0, 0],
       ['a', 'a', 'a', 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 'b', 'b', 'b', 'b', 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 'c', 'c'],
       [0, 0, 0, 0, 0, 0, 0, 'c', 'c']], dtype=object)