Wie kann der euklidische Abstand mit NumPy berechnet werden?

Question

Ich habe zwei Punkte in 3D:

(xa, ya, za)
(xb, yb, zb)

Und ich möchte die Entfernung berechnen:

dist = sqrt((xa-xb)^2 + (ya-yb)^2 + (za-zb)^2)

Was ist der beste Weg, dies mit NumPy, oder mit Python im Allgemeinen zu tun? Ich habe:

import numpy
a = numpy.array((xa ,ya, za))
b = numpy.array((xb, yb, zb))

Answer 1

Start: Python 3.8 die math Modul bietet direkt die dist Funktion, die den euklidischen Abstand zwischen zwei Punkten (die als Tupel oder Liste von Koordinaten angegeben werden) zurückgibt:

from math import dist

dist((1, 2, 6), (-2, 3, 2)) # 5.0990195135927845

Und wenn Sie mit Listen arbeiten:

dist([1, 2, 6], [-2, 3, 2]) # 5.0990195135927845

Answer 2

Dies kann wie folgt geschehen. Ich weiß nicht, wie schnell es ist, aber es ist nicht mit NumPy.

from math import sqrt
a = (1, 2, 3) # Data point 1
b = (4, 5, 6) # Data point 2
print sqrt(sum( (a - b)**2 for a, b in zip(a, b)))

Answer 3

Ein schöner Einzeiler:

dist = numpy.linalg.norm(a-b)

---

Wenn die Geschwindigkeit jedoch eine Rolle spielt, würde ich empfehlen, mit Ihrem Rechner zu experimentieren. Ich habe festgestellt, dass die Verwendung von math der Bibliothek sqrt mit dem ** Operator für das Quadrat ist auf meinem Rechner viel schneller als die Einzeilerlösung von NumPy.

Ich habe meine Tests mit diesem einfachen Programm durchgeführt:

#!/usr/bin/python
import math
import numpy
from random import uniform

def fastest_calc_dist(p1,p2):
    return math.sqrt((p2[0] - p1[0]) ** 2 +
                     (p2[1] - p1[1]) ** 2 +
                     (p2[2] - p1[2]) ** 2)

def math_calc_dist(p1,p2):
    return math.sqrt(math.pow((p2[0] - p1[0]), 2) +
                     math.pow((p2[1] - p1[1]), 2) +
                     math.pow((p2[2] - p1[2]), 2))

def numpy_calc_dist(p1,p2):
    return numpy.linalg.norm(numpy.array(p1)-numpy.array(p2))

TOTAL_LOCATIONS = 1000

p1 = dict()
p2 = dict()
for i in range(0, TOTAL_LOCATIONS):
    p1[i] = (uniform(0,1000),uniform(0,1000),uniform(0,1000))
    p2[i] = (uniform(0,1000),uniform(0,1000),uniform(0,1000))

total_dist = 0
for i in range(0, TOTAL_LOCATIONS):
    for j in range(0, TOTAL_LOCATIONS):
        dist = fastest_calc_dist(p1[i], p2[j]) #change this line for testing
        total_dist += dist

print total_dist

Auf meinem Rechner, math_calc_dist läuft viel schneller als numpy_calc_dist : 1,5 Sekunden gegenüber 23,5 Sekunden.

Um einen messbaren Unterschied zwischen fastest_calc_dist et math_calc_dist Ich musste die TOTAL_LOCATIONS bis 6000. Dann fastest_calc_dist dauert ~50 Sekunden, während math_calc_dist dauert ~60 Sekunden.

Sie können auch experimentieren mit numpy.sqrt et numpy.square obwohl beide langsamer waren als die math Alternativen auf meinem Rechner.

Meine Tests wurden mit Python 2.6.6 durchgeführt.

Answer 4

Ich habe in matplotlib.mlab eine Funktion 'dist' gefunden, aber ich glaube nicht, dass sie praktisch genug ist.

Ich stelle sie hier nur als Referenz ein.

import numpy as np
import matplotlib as plt

a = np.array([1, 2, 3])
b = np.array([2, 3, 4])

# Distance between a and b
dis = plt.mlab.dist(a, b)

Answer 5

Sie können die Vektoren einfach subtrahieren und dann innerproduzieren.

Nach Ihrem Beispiel,

a = numpy.array((xa, ya, za))
b = numpy.array((xb, yb, zb))

tmp = a - b
sum_squared = numpy.dot(tmp.T, tmp)
result = numpy.sqrt(sum_squared)