Existem desvantagens no uso de verificações de distância ao quadrado em vez de distância?

Uso verificações de distância ao quadrado para basicamente todas as minhas verificações de distância (comprimento do vetor3), devido ao aumento de desempenho por não incorrer em uma raiz quadrada (como nas verificações de comprimento simples).

Pelo que parece, as verificações de distância ao quadrado funcionam bem em todas as situações:

if x^2 < y^2, then x < y, even when 0 < (x or y) < 1

Não estou considerando situações em que x ou y é menor que 0, pois a distância e a distância ao quadrado sempre serão positivas.

Como isso funciona, parece que nunca são necessárias verificações de distância, mas sinto que estou perdendo alguma coisa. Isso ainda se mantém em situações críticas de precisão?

Não tenho nenhuma desvantagem ao usar o comprimento ao quadrado para comparar distâncias. Pense assim: você está pulando o sqrtque não fornece precisão adicional. Se você não precisar da distância euclidiana real, poderá sair com segurança sqrt.

É claro que o comprimento ao quadrado varia de maneira bem diferente da distância euclidiana e, portanto, é um candidato ruim para coisas como heurísticas de busca de caminhos .

Como bummzack sugeriu com a analogia de localização de caminho, você PRECISA usar o comprimento "normal" toda vez que adicionar distâncias e desejar comparar sua soma. (Só porque somas de quadrados de comprimentos são diferentes de somas de quadrados de comprimentos).

x ^ 2 + y ^ 2! = (x + y) ^ 2

A única desvantagem em que consigo pensar é quando se lida com números grandes que transbordam ao quadrado.

Por exemplo, em Java:

int x = Integer.MAX_VALUE / 1000000; //2147
int y = Integer.MAX_VALUE / 5000; //429496
System.out.println("x < y: " + (x < y)); //true
System.out.println("x*x: " + (x * x)); //4609609
System.out.println("y*y: " + (y * y)); //-216779712 - overflows!
System.out.println("x*x < y*y: " + (x * x < y * y)); //false - incorrect result due to overflow!

Também é importante notar que é o que acontece quando você usa Math.pow () com exatamente os mesmos números e retorna ao int a partir do dobro retornado deMath.pow() :

System.out.println("x^2: " + (int) (Math.pow(x, 2))); //4609609
System.out.println("y^2: " + (int) (Math.pow(y, 2))); //2147483647 - double to int conversion clamps to Integer.MAX_VALUE
System.out.println("x^2 < y^2: " + ((int) (Math.pow(x, 2)) < (int) (Math.pow(y, 2)))); //true - but for the wrong reason!

Está funcionando? Não , apenas deu a resposta correta porque y*yestá presa Integer.MAX_VALUEe x*xé menor queInteger.MAX_VALUE . Se x*xtambém foi preso Integer.MAX_VALUE, você obteria uma resposta incorreta.

Princípios semelhantes também se aplicam a carros alegóricos e duplos (exceto que obviamente têm um alcance maior antes do transbordamento) e a qualquer outro idioma que silenciosamente permita transbordamentos.

Uma vez eu estava trabalhando em distâncias quadradas e cometi o erro de acumular distâncias quadradas, para uma contagem de odômetros.

Claro, você não pode fazer isso, porque matematicamente,

(a^2+b^2+c^2+d^2)!=(a+b+c+d)^2

Então, acabei com um resultado incorreto lá. Opa!

Você pode ter problemas se estiver escrevendo um algoritmo que exija a computação de uma posição otimizada. Por exemplo, digamos que você tenha um conjunto de objetos e esteja tentando calcular a posição com a menor distância total de todos os objetos. Apenas para um exemplo concreto, digamos que estamos tentando alimentar três edifícios e queremos descobrir para onde a usina deve ir, para que possamos conectá-la a todos os edifícios usando o menor comprimento total de fio. Usando a métrica da distância ao quadrado, você terminaria com a coordenada x da usina sendo a média das coordenadas x de todos os edifícios (e analogamente para a coordenada y). Usando a métrica de distância comum, a solução seria diferente e geralmente muito distante da solução ao quadrado da distância.

Usar a distância ao quadrado quase sempre é bom e bom para o desempenho. As seguintes considerações são importantes:

Se você quiser pensar na soma de um número de distâncias, a distância ao quadrado será imprecisa. Por exemplo, tenho duas distâncias e quero garantir que a soma seja menor que 10. O código a seguir está incorreto:

a = get_distance_squared(c,d);
b = get_distance_squared(e,f);
assert(a+b < 10^2);

Falha ao afirmar no seguinte caso inválido: a=36eb=49 . Nesse caso, o primeiro comprimento é 6 e o ​​segundo 7; sua soma é maior que 10, mas a soma dos quadrados não é 100 ou maior.

Outra consideração: para distâncias com valor real, a distância ao quadrado sempre será positiva. Se você está medindo o deslocamento, por exemplo, pode ser necessário lidar com valores negativos, e a quadratura deles não é suficiente.