Quero expor a resposta simples com várias notas de desempenho. O np.linalg.norm fará talvez mais do que você precisa:
dist = numpy.linalg.norm(a-b)
Em primeiro lugar - esta função foi projetada para trabalhar em uma lista e retornar todos os valores, por exemplo, para comparar a distância do pA
conjunto de pontos sP
:
sP = set(points)
pA = point
distances = np.linalg.norm(sP - pA, ord=2, axis=1.) # 'distances' is a list
Lembre-se de várias coisas:
- Chamadas de função Python são caras.
- [Regular] O Python não armazena em cache as pesquisas de nome.
assim
def distance(pointA, pointB):
dist = np.linalg.norm(pointA - pointB)
return dist
não é tão inocente quanto parece.
>>> dis.dis(distance)
2 0 LOAD_GLOBAL 0 (np)
2 LOAD_ATTR 1 (linalg)
4 LOAD_ATTR 2 (norm)
6 LOAD_FAST 0 (pointA)
8 LOAD_FAST 1 (pointB)
10 BINARY_SUBTRACT
12 CALL_FUNCTION 1
14 STORE_FAST 2 (dist)
3 16 LOAD_FAST 2 (dist)
18 RETURN_VALUE
Primeiramente - toda vez que chamamos, temos que fazer uma pesquisa global para "np", uma pesquisa com escopo para "linalg" e uma pesquisa com escopo para "norma", e a sobrecarga de simplesmente chamar a função pode equivaler a dezenas de python instruções.
Por fim, desperdiçamos duas operações para armazenar o resultado e recarregá-lo para retorno ...
Primeira passagem na melhoria: agilize a pesquisa, pule a loja
def distance(pointA, pointB, _norm=np.linalg.norm):
return _norm(pointA - pointB)
Ficamos muito mais simplificados:
>>> dis.dis(distance)
2 0 LOAD_FAST 2 (_norm)
2 LOAD_FAST 0 (pointA)
4 LOAD_FAST 1 (pointB)
6 BINARY_SUBTRACT
8 CALL_FUNCTION 1
10 RETURN_VALUE
A sobrecarga de chamada de função ainda equivale a algum trabalho, no entanto. E você desejará fazer benchmarks para determinar se é melhor fazer as contas sozinho:
def distance(pointA, pointB):
return (
((pointA.x - pointB.x) ** 2) +
((pointA.y - pointB.y) ** 2) +
((pointA.z - pointB.z) ** 2)
) ** 0.5 # fast sqrt
Em algumas plataformas, **0.5
é mais rápido que math.sqrt
. Sua milhagem pode variar.
**** Notas de desempenho avançadas.
Por que você está calculando a distância? Se o único objetivo é exibi-lo,
print("The target is %.2fm away" % (distance(a, b)))
seguir em frente. Mas se você estiver comparando distâncias, verificando o alcance etc., gostaria de adicionar algumas observações úteis sobre o desempenho.
Vamos considerar dois casos: classificação por distância ou seleção de uma lista de itens que atendem a uma restrição de intervalo.
# Ultra naive implementations. Hold onto your hat.
def sort_things_by_distance(origin, things):
return things.sort(key=lambda thing: distance(origin, thing))
def in_range(origin, range, things):
things_in_range = []
for thing in things:
if distance(origin, thing) <= range:
things_in_range.append(thing)
A primeira coisa que precisamos lembrar é que estamos usando Pitágoras para calcular a distância ( dist = sqrt(x^2 + y^2 + z^2)
), por isso estamos fazendo muitas sqrt
ligações. Math 101:
dist = root ( x^2 + y^2 + z^2 )
:.
dist^2 = x^2 + y^2 + z^2
and
sq(N) < sq(M) iff M > N
and
sq(N) > sq(M) iff N > M
and
sq(N) = sq(M) iff N == M
Em resumo: até exigirmos a distância em uma unidade de X em vez de X ^ 2, podemos eliminar a parte mais difícil dos cálculos.
# Still naive, but much faster.
def distance_sq(left, right):
""" Returns the square of the distance between left and right. """
return (
((left.x - right.x) ** 2) +
((left.y - right.y) ** 2) +
((left.z - right.z) ** 2)
)
def sort_things_by_distance(origin, things):
return things.sort(key=lambda thing: distance_sq(origin, thing))
def in_range(origin, range, things):
things_in_range = []
# Remember that sqrt(N)**2 == N, so if we square
# range, we don't need to root the distances.
range_sq = range**2
for thing in things:
if distance_sq(origin, thing) <= range_sq:
things_in_range.append(thing)
Ótimo, ambas as funções não têm mais raízes quadradas caras. Isso será muito mais rápido. Também podemos melhorar o in_range convertendo-o em um gerador:
def in_range(origin, range, things):
range_sq = range**2
yield from (thing for thing in things
if distance_sq(origin, thing) <= range_sq)
Isso tem benefícios especiais se você estiver fazendo algo como:
if any(in_range(origin, max_dist, things)):
...
Mas se a próxima coisa que você fizer exigir uma distância,
for nearby in in_range(origin, walking_distance, hotdog_stands):
print("%s %.2fm" % (nearby.name, distance(origin, nearby)))
considere produzir tuplas:
def in_range_with_dist_sq(origin, range, things):
range_sq = range**2
for thing in things:
dist_sq = distance_sq(origin, thing)
if dist_sq <= range_sq: yield (thing, dist_sq)
Isso pode ser especialmente útil se você puder encadear verificações de alcance ('encontre coisas próximas de X e dentro de Nm de Y', pois você não precisa calcular a distância novamente).
Mas e se estamos pesquisando uma lista realmente grande de things
e antecipamos que muitos deles não valem a pena ser considerados?
Na verdade, existe uma otimização muito simples:
def in_range_all_the_things(origin, range, things):
range_sq = range**2
for thing in things:
dist_sq = (origin.x - thing.x) ** 2
if dist_sq <= range_sq:
dist_sq += (origin.y - thing.y) ** 2
if dist_sq <= range_sq:
dist_sq += (origin.z - thing.z) ** 2
if dist_sq <= range_sq:
yield thing
Se isso é útil, dependerá do tamanho das 'coisas'.
def in_range_all_the_things(origin, range, things):
range_sq = range**2
if len(things) >= 4096:
for thing in things:
dist_sq = (origin.x - thing.x) ** 2
if dist_sq <= range_sq:
dist_sq += (origin.y - thing.y) ** 2
if dist_sq <= range_sq:
dist_sq += (origin.z - thing.z) ** 2
if dist_sq <= range_sq:
yield thing
elif len(things) > 32:
for things in things:
dist_sq = (origin.x - thing.x) ** 2
if dist_sq <= range_sq:
dist_sq += (origin.y - thing.y) ** 2 + (origin.z - thing.z) ** 2
if dist_sq <= range_sq:
yield thing
else:
... just calculate distance and range-check it ...
E, novamente, considere render o dist_sq. Nosso exemplo de cachorro-quente passa a ser:
# Chaining generators
info = in_range_with_dist_sq(origin, walking_distance, hotdog_stands)
info = (stand, dist_sq**0.5 for stand, dist_sq in info)
for stand, dist in info:
print("%s %.2fm" % (stand, dist))