当传递给 pgplot 时，是否有一种 O(1) 方法来分离复数数组的实部和虚部？

Question

我的代码中有一个库为我生成的复杂浮点数组。考虑它是这样的：

float _Complex data[N];

为了将其视为具有实部和虚部的单独数组，我遍历数组并获取如下值：

float real[N];
float imag[N];
for (int pt=0;pt<N;pt++) {
  real[pt] = creal(data[pt]);
  imag[pt] = cimag(data[pt]));    
}

但这确实是低效的，因为在执行时间和空间方面这是一个O(N) 操作。我想知道是否可以使用一些指针算法来分离数组，从而减少执行时间和内存使用？

我需要分别绘制实值和虚值。我的绘图库 PGPLOT 需要将一组值发送给它，因此我不能“就地”使用复杂的数组。

Answer 1

pgplot 库提供了一个无跨度的界面来绘制标记数组：

void cpgpt(int n, const float *xpts, const float *ypts, int symbol);

但这只是对cpgpt1 的个别调用的简单包装。因此，添加一个跨步界面很容易：

void cpgpts(int n, int stride, const float *xpts, const float *ypts, int symbol) {
  for (int i = 0; i < n; ++i) {
    cpgpt1(*xpts, *ypts, symbol);
    xpts += stride;
    ypts += stride;
  }
}

当然，您会想为复杂到浮点转换的丑陋编写包装器。例如：

void cpgptsc(int n, const float _Complex *pts, int symbol) {
  cpgpts(n, 2, (const float*)pts, ((const float*)pts)+1, symbol);
}

例子：

// Plot the data as symbols on the Re-Im plane
cpgptsc(count, data, symbol);

您可以类似地重新实现cpgline：

void cpglines(int n, int stride, const float *xpts, const float *ypts, int symbol) {
  cpgmove(*xpts, *ypts);
  for (int i = 1; i < n; ++ i) {
    xpts += stride;
    ypts += stride;
    cpgdraw(*xpts, *ypts);
  }
}

void cpglinesc(int n, const float _Complex *pts, int symbol) {
  cpglines(n, 2, (const float*)pts, ((const float*)pts)+1, symbol);
}

例子：

// Plot the data as lines on the Re-Im plane
cpglinesc(count, data);

如果您只绘制单个组件（无论是真实的还是虚构的），为它创建一个合理的包装器同样简单：

void cpglinesx(int n, int stride, float dx, float x0, const float *ypts) {
  cpgmove(x0, *ypts);
  for (int i = 1; i < n; ++ i) {
    x0 += dx;
    ypts += stride;
    cpgdraw(x0, *ypts);
  }
}

void cpglinesxre(int n, float dx, float x0, const float _Complex *pts) {
  cpglinesx(n, 2, dx, x0, (const float*)pts);
}

void cpglinesxim(int n, float dx, float x0, const float _Complex *pts) {
  cpglinesx(n, 2, dx, x0, ((const float*)pts)+1);
}

然后，要绘制从 x=0 开始的虚数分量，增量为 1.0，您可以这样做：

// Plot the imaginary coordinates of all the data
cpglinesxim(count, 1.0, 0.0, data);

Answer 2

给定：

float _Complex data[N];

我们知道：

float *ptr = (float *) data;
ptr[2 * n + 0] <- real part.
ptr[2 * n + 1] <- imaginary part.

我们可以看到一些合理化here。基本上，float _Complex 将具有与float[2] 相同的内存布局。

修改它以使所有实数都连续需要与问题中提到的O(n) 版本类似的操作。

Answer 3

如果您有一个长度为 N 的输入数组，那么实际上没有一个 O(1) 算法可以遍历所有这些。