Ich versuche, mit NumPy- und Vektorisierungsoperationen einen Codeabschnitt schneller auszuführen. Ich scheine jedoch ein Missverständnis darüber zu haben, wie man diesen Code vektorisiert (wahrscheinlich aufgrund eines unvollständigen Verständnisses der Vektorisierung).

Hier ist der Arbeitscode mit Schleifen (A und B sind bereits initialisierte 2D-Arrays mit einer festgelegten Größe):

for k in range(num_v):
    B[:] = A[:]
    for i in range(num_v):
        for j in range(num_v):
            A[i][j] = min(B[i][j], B[i][k] + B[k][j])
return A

Und hier ist mein Versuch, den obigen Code zu vektorisieren:

for k in range(num_v):
    B = numpy.copy(A)
    A = numpy.minimum(B, B[:,k] + B[k,:])
return A

Um diese zu testen, habe ich Folgendes verwendet, wobei der obige Code in eine Funktion namens "Algorithmus" eingeschlossen war:

def setup_array(edges, num_v):
    r = range(1, num_v + 1)
    A = [[None for x in r] for y in r]  # or (numpy.ones((num_v, num_v)) * 1e10) for numpy
    for i in r:
        for j in r:
            val = 1e10
            if i == j:
                val = 0 
            elif (i,j) in edges:
                val = edges[(i,j)]
            A[i-1][j-1] = val 
    return A

A = setup_array({(1, 2): 2, (6, 4): 1, (3, 2): -3, (1, 3): 5, (3, 6): 5, (4, 5): 2, (3, 1): 4, (4, 3): 8, (3, 4): 6, (2, 4): -4, (6, 5): -5}, 6) 
B = []
algorithm(A, B, 6)

Das erwartete Ergebnis und was ich mit dem ersten Code bekomme, ist:

[[0, 2, 5, -2, 0, 10] 
 [8, 0, 4, -4, -2, 9]
 [4, -3, 0, -7, -5, 5]
 [12, 5, 8, 0, 2, 13]
 [10000000000.0, 9999999997.0, 10000000000.0, 9999999993.0, 0, 10000000000.0]
 [13, 6, 9, 1, -5, 0]]

Die zweite (vektorisierte) Funktion gibt stattdessen Folgendes zurück:

[[ 0. -4.  0.  0.  0.  0.]
 [ 0. -4.  0. -4.  0.  0.]
 [ 0. -4.  0.  0.  0.  0.]
 [ 0. -4.  0.  0.  0.  0.]
 [ 0. -4.  0.  0.  0.  0.]
 [ 0. -4.  0.  0. -5.  0.]]

Was vermisse ich?