0

我有一个要转换的函数，以便可以与笨拙的数组 1 一起使用。

由于已知原因，其后的函数用于浮点数但不适用于笨拙的数组。

def Phi_mpi_pi(x):
    kPI=(3.14159265)
    kTWOPI = 2 * kPI

    #while ((x.any() >= kPI).any()): x = x - kTWOPI;                                                                                                                                                        
    #while ((x.any() < -kPI).any()): x = x + kTWOPI;                                                                                                                                                        
    while ((x >= kPI)): x = x - kTWOPI;
    while ((x < -kPI)): x = x + kTWOPI;
    return x;

我试图将其转换为 numpy/awkward 兼容的形式，新功能看起来像

def Phi_mpi_pi(x):
    kPI=numpy.array(3.14159265)
    kPI = kPI.repeat(len(x))
    kTWOPI = 2 * kPI
    while ((x >= kPI)): x = x - kTWOPI;
    while ((x < -kPI)): x = x + kTWOPI;
    return x;

这个函数永远停留在while循环中，我找不到调试它的方法。

该函数的任务是将值保持在 +- kPI 之间的尴尬数组中，但此逻辑没有给出所需的结果。

例如

x=ak.Array([[0.7999999999999998, 1.0, -1.3], [], [-1.4], [-1.8000000000000003, -6.1000000000000005, -1.6000000000000005], [-4.6]])

但是 ((x < -kPI)) 这给出了所需的输出。

>>> ak.to_list(x <= -kPI)
    [[False, False, False], [], [False], [False, True, False], [True]]

但不是功能

基于while循环的逻辑，所需的输出应该是b/w +- kPI，有什么可以使用的直接或建议吗？

4

2 回答 2

0

我不太明白你想要什么，但这至少可以帮助你调试：

import numpy
import awkward1 as ak

def Phi_mpi_pi(x):
    kPI=numpy.array(3.14159265)
    kPI = kPI.repeat(len(x))
    kTWOPI = 2 * kPI
    print("kPI =", kPI)
    print("kTWOPI =", kTWOPI)
    while ((x >= kPI)):
        print(x)
        x = x - kTWOPI
    while ((x < -kPI)):
        print(x)
        x = x + kTWOPI
    return x

x=ak.Array([[0.7999999999999998, 1.0, -1.3], [], [-1.4], [-1.8000000000000003, -6.1000000000000005, -1.6000000000000005], [-4.6]])

print(Phi_mpi_pi(x))

评论太长了，所以我将其发布为答案，尽管它当然并不直接代表解决方案。

于 2020-10-09T17:57:39.233 回答
0

好，知道了。您希望将 x（所有角度）中的每个标量值调整为介于 -π 和 π 之间。

你可以这样做：

def Phi_mpi_pi(x):
    y = numpy.add(x, numpy.pi)
    y = numpy.mod(y, 2*numpy.pi)
    y = numpy.subtract(y, numpy.pi)
    return y

或者，更简洁，可读性更差：

def Phi_mpi_pi(x):
    return numpy.subtract(numpy.mod(numpy.add(x, numpy.pi), 2*numpy.pi), numpy.pi)

它的作用是这样的：

  1. 将 π 添加到所有角度（使它们指向相反的方向）。
  2. 对所有角度取模 2π，因此它们都是从 0 到 2π（不包括 2π）。
  3. 再次从所有角度减去 π（因此它们再次指向正确的方向）。现在它们都是从 -π 到 +π（不包括 +π）。

测试：

x = ak.Array([[0.3, 3.1, numpy.pi, -numpy.pi, -4 * numpy.pi,
               200 * numpy.pi, 2 * numpy.pi, -400 * numpy.pi], 
              [], [-1.4], [-1.8, -6, -1.6], [-4.6]])
y = Phi_mpi_pi(x)
print("Type of result:", type(y))
print("Result =", y)

# Check that the resulting range of each value is correct.
range_is_correct = (ak.all(y >= -numpy.pi) and ak.all(y < numpy.pi))

# Calculate the factors of the 2π adjustments.
factors = (x - y) / (2 * numpy.pi)
print("2π factors=", factors)

# Test that all factors of the 2π adjustmenst are approximate integers.
adjustments_are_correct = ak.all(numpy.abs(numpy.mod(factors, 1)) < 1e-15)

# Test that all values are correct, given the test input.
print("Result is correct:", range_is_correct and adjustments_are_correct)

给出这个输出：

Type of result: <class 'awkward1.highlevel.Array'>
Result = [[0.3, 3.1, -3.14, -3.14, 0, 1.78e-14, 0, 4.62e-14, ... [-1.8, 0.283, -1.6], [1.68]]
2π factors= [[2.65e-17, 7.07e-17, 1, 0, -2, 100, 1, -200], [], [0], [0, -1, 0], [-1]]
Result is correct: True

这证明使用专门使用的测试数据正确执行了操作。

那是你想要的吗？

于 2020-10-10T13:13:09.277 回答