标签: euclidean-distance

当我给他一个加权图并且顶点之间的边权重指向顶点之间的距离时，是否有一种算法可以给我图中顶点的坐标？

就像是：

public _ArrayOfCoordinatesForVertices_ **super_hyper_algorithm**(weighted_graph){  
     return _foo_;  
}

我试图在Python中计算从A点到B点通过中间点列表的路径长度.我知道怎么做,但我确实想使用reduce Built-in功能.

为什么我到目前为止尝试过,请注意这是完全错误的,是这样的:

reduce(lambda x,y: math.sqrt((y[1]-y[0])**2+(x[1]-x[0])**2) , ((1,2),(3,4),(1,8)))

任何的想法？

谢谢.

public class Point
{ 
// Placeholders for xcoordinate, ycoordinate, and quadrants
int xcoord = 0;
int ycoord =0;
double distance = 0.0;
String quadrant = ("NW");


//moveUp changes the y coordinate 
void moveUp (int x) {
    int moveUp = ycoord + x;
    ycoord= moveUp;
    System.out.println(moveUp);
    }
// moveDown changes the y coordinate    
void moveDown (int y){
    int moveDown = ycoord - y;
    ycoord =moveDown;
    System.out.println(moveDown);}
// moveLeft changes the x coordinate    
void moveLeft (int f){
    int moveLeft = xcoord -f …

我在Python中有以下问题需要解决：

给定两个坐标矩阵 (NumPy ndarrays) A和B，查找中相应坐标向量a中的所有坐标向量，使得欧几里得距离最小。坐标矩阵和可以具有不同数量的坐标向量（即不同的行数）。AbB||a-b||AB

此方法应返回一个坐标向量矩阵，其中中的C第 i 个向量是与中的第 i 个坐标向量的欧几里德距离最小化的向量。cCBaA

例如，假设

A = np.array([[1,1], [3,4]])和B = np.array([[1,2], [3,6], [8,1]])

向量[1,1]inA和向量 in之间的欧几里德距离B为：

1, 5.385165, 7

所以第一个向量C是[1,2]

[3,4]类似地，向量inA和向量 in的距离B为：

2.828427, 2, 5.830952  

所以第二个也是最后一个向量C将是[3,6]

所以C = [[1,2], [3,6]]

如何在 Python 中高效地编写此代码？

我需要一个最短路径算法来控制现实生活中的机器人。

假设我有矩阵形式的环境地图，其中 1 是障碍物，0 是自由空间。如果我使用传统的最短路径算法，例如 A*，那么这将为我提供曼哈顿距离最短路径。所以离实际的最短路径还差得很远。出现这个问题是因为我想不出一种方法来惩罚运动，使对角线比两条直线更好。我可以做一个启发式，让 A* 首先尝试两点之间的欧几里德最短路径，但实际上并没有使欧几里德最短路径成为更好的路径。

有谁知道获得连续空间最短路径的方法吗？它不一定是实际的最佳路径，但比直线和 90 度角更好。

我有一个想法：从起点画一个圆。增加圆的半径，直到圆上的一个点靠近墙壁或球门。圆边缘上的所有点都被设置为子节点，并受到圆半径的惩罚。圆内所有不开放的点都将被关闭，因为没有理由测试它们。以欧几里德最短路径为启发式，以 A* 方式重复此过程，直到达到目标状态。使机器人从一个点直线移动到下一个点。

这应该会提供更接近我正在寻找的东西。一组具有不同角度的直线。当然，如果有连续的曲线就更好了……

我想创建一个矩阵,其中包含从一个数据帧到另一个数据帧的行的欧几里德距离.例如,假设我有以下数据框:

a <- c(1,2,3,4,5)
b <- c(5,4,3,2,1)
c <- c(5,4,1,2,3)
df1 <- data.frame(a,b,c)

a2 <- c(2,7,1,2,3)
b2 <- c(7,6,5,4,3)
c2 <- c(1,2,3,4,5)
df2 <- data.frame(a2,b2,c2)

我想创建一个矩阵,其中df1中每行的距离与df2的行相距.

因此矩阵[2,1]应该是df1 [2,]和df2 [1,]之间的欧氏距离.矩阵[3,2] df [3,]和df2 [2,]等之间的距离.

有谁知道如何实现这一目标？

def distance(alist, blist):
    sum_of = 0
    for x in alist:
        for y in blist:
            ans = (x - y)**2
            sum_of += ans
    return (sum_of)**(1/2)
print(distance([1, 1, 3], [2, 2, 3])) #1.4142135623730951
print(distance([1, 2, 3], [2, 2, 3])) #1.0
print(distance([2, 2, 3], [2, 2, 3])) #0.0
print(distance([1, 1], [2, 2])) #1.4142135623730951

所以我有一组测试用例，它们给了我两个带有数字的列表。我的任务是计算给定列表的欧几里德距离。但是，我没有得到正确的结果。相反，我得到的是 3.7416573867739413、3.0、2.0 和 2.0。这就是我到目前为止所拥有的，我不确定我做错了什么。

我有一个numpy像这样的数组:

import numpy as np
a = np.array([[1,0,1,0],
             [1,1,0,0],
             [1,0,1,0],
             [0,0,1,1]])

我想euclidian distance在每对行之间进行计算.

from scipy.spatial import distance
for i in range(0,a.shape[0]):
    d = [np.sqrt(np.sum((a[i]-a[j])**2)) for j in range(i+1,a.shape[0])]
    print(d)

[1.4142135623730951,0.0,1.4142135623730951]

[1.4142135623730951,2.0]

[1.4142135623730951]

[]

有没有更好的pythonic方法来做到这一点,因为我必须在一个巨大的numpy阵列上运行此代码？

我正在尝试计算欧几里得距离的矢量化实现（使用内积在 X 和 Y 中的每个元素之间）。数据如下：

X = np.random.uniform(low=0, high=1, size=(10000, 5))
Y = np.random.uniform(low=0, high=1, size=(10000, 5))

我所做的是：

euclidean_distances_vectorized = np.array(np.sqrt(np.sum(X**2, axis=1) - 2 * np.dot(X, Y.T) + np.sum(Y**2, axis=1)))

尽管这给出了“一些输出”，但答案是错误的，因为每行仍然包含 5 个元素。

有谁知道我做错了什么？

我是数据科学的新手，目前正在学习可以使用Python进行的各种技术。目前，我正在尝试使用Spotify的API播放自己的播放列表。

目的是找到两个不同播放列表之间最相似的功能。

我的问题是识别这两个播放列表之间最相似功能的最佳方法是什么？

我首先获得了每个播放列表中的所有曲目及其各自的功能。然后，我计算了每个特征的均值。

这是我最终得到的DataFrame。数据值是所有曲目特征到达其各自播放列表的均值

                   playlist1  playlist2
                   --------------------
danceability      | 0.667509   0.592140
energy            | 0.598873   0.468020
acousticness      | 0.114511   0.398372
valence           | 0.376920   0.287250
instrumentalness  | 0.005238   0.227783
speechiness       | 0.243587   0.088612

我进行了一些挖掘，发现了两个常见过程：

1.欧氏距离

2.余弦相似度

由于某种原因，我无法使用我的头，而是继续计算每个功能之间的绝对差异。简单的减法，因为这对我来说很有意义。差异最大的特征就是“最不相似”。

通过这种方法，我最终使用了这些结果，并得出结论，能量和声学是最不相似的

                   playlist1    playlist2   absoluteDifference
                   ----------------------------------------------------
energy             |0.871310    0.468020    0.403290
acousticness       |0.041479    0.398372    0.356893
valence            |0.501890    0.287250    0.214640
instrumentalness   |0.049012    0.227783    0.178771
danceability       |0.531071    0.592140    0.061069
speechiness        |0.109587    0.088612    0.020975

我的直觉是否正确/不正确？何时使用上述技术？这些技术中的任何一种在这种情况下是否适用？

最终，我想将最重要的两个差异作为KNN的轴。我的直觉是，我可以识别两个播放列表的最相似的功能，可以使播放列表具有更清晰，定义更明确的功能，并且可以更准确地预测该播放列表应属于哪首歌曲。