复杂浮点数无序集的近似等式

Question

我想对无序的复杂浮点数组进行鼻子测试。

例如，如果

a = [1+1j, 1-1j, 2+2j, 2-2j, 2+2j, 2-2j]

和

b = [2+2j, 2-2j, 1+1j, 1.000000000000001-1j, 2+2j, 2-2j]

断言应该成功，因为它们具有大致相同的值和相同的次数。顺序无关紧要。

对于常规浮点数，assert_array_almost_equal（np.sort（a），np.sort（b））很好，但这在这里不起作用，因为它首先按实部排序，然后按虚部排序，因此由于浮点数错误，它们被排序为：

a: [ 1.-1.j,  1.+1.j,  2.-2.j,  2.-2.j,  2.+2.j,  2.+2.j]    
b: [ 1.+1.j,  1.-1.j,  2.-2.j,  2.-2.j,  2.+2.j,  2.+2.j]

有没有内置的方法可以做到这一点？如果没有，我想我可以求助于类似cplxreal的东西，但这似乎需要添加到测试文件中。

Answer 1

另一种方法可能是根据2d空间中的点进行思考<代码>a是一组点<代码>b是另一组。b中的每个点应接近a中的一个点。

diff = np.array(a)[None,:]-np.array(b)[:,None]
X = np.round(diff*diff.conjugate())==0  # round to desired error tollerance
X

array([[False, False,  True, False,  True, False],
       [False, False, False,  True, False,  True],
       [ True, False, False, False, False, False],
       [False,  True, False, False, False, False],
       [False, False,  True, False,  True, False],
       [False, False, False,  True, False,  True]], dtype=bool)

下一步是测试X。如果a（和b）中的值不同，则每列和每行应有一个True。但这里有重复的。

In [29]: I,J=np.where(X)

In [30]: I
Out[30]: array([0, 0, 1, 1, 2, 3, 4, 4, 5, 5])

In [31]: J
Out[31]: array([2, 4, 3, 5, 0, 1, 2, 4, 3, 5])

set（I）和set（J）都是[0,1，...5]，因此所有行和列都有匹配项。这个集合测试可能就足够了，即使是重复的。我必须探索点和不匹配的其他组合。

这个答案不完整，但可能提供一些有用的想法。

Answer 2

我不确定是否有任何方法可以在比O（n^2）更好的最坏情况下做到这一点，但如果您可以接受，您可以复制其中一个列表并使用修改后的equals函数消除以查看它们是否匹配。

def equals(a, b, tolerance):
    return abs(a-b) < tolerance

然后遍历列表，在找到匹配项时将其删除

def equivalent_lists(a, b, tolerance):
    new_b = b[:]
    for a_item in a:
        truths = [equals(a_item, b_item, tolerance) for b_item in new_b]
        if not any(truths):
            return False
        else:
            new_b.pop(truths.index(True))
    return not bool(new_b)

在您最初的情况下似乎有效，至少粗略地说：

a = [1+1j, 1-1j, 2+2j, 2-2j, 2+2j, 2-2j]
b = [2+2j, 2-2j, 1+1j, 1.000000000000001-1j, 2+2j, 2-2j]
c = [2+2j, 2-2j, 1+1j, 2-1j, 2+2j, 2-2j]

equivalent_lists(a, b, 0.0001)
>>> True
equivalent_lists(a, c, 0.0001)
>>> False

不是最漂亮的解决方案，但至少看起来以一种相当透明的方式工作。

Answer 3

按数组的大小排序如何？

def foo(a):
    return a[np.argsort(a*a.conjugate())]
np.testing.assert_array_almost_equal(foo(a),foo(b))