1

我在 Processing 中编写了一个程序，它可以模拟任意数量维度的元胞自动机（完全、最近邻、摩尔邻域）。为了简化事情并使程序尽可能通用，我将单元的状态存储在一维整数数组中。为了计算一个单元的 n 维邻居，我将一维数组视为光栅顺序（将第一个坐标从零迭代到相关空间的大小，然后将下一个坐标递增 1 并迭代第一个再一次，以此类推。）

由于在计算机屏幕的 2 维中显示 n 维数据的优雅方式很少（特别是在这种情况下，n 理论上可以从 2 到无穷大，实际上至少可以从 2 到 5），我决定尝试使用 Z 顺序，但我读到的关于该主题的所有内容都让我感到困惑，所有材料似乎都是从笛卡尔坐标 (x1,x2,x3...xn) 的假设开始的，其中不适用于我的情况。

我想要的是能够将一维元胞数组中的元素存储在另一个一维数组中，按 n 维 Z 顺序排序，然后将该数组转换为按二维 Z 排序的数组-订单，以便我可以显示它。我想以一种有效的方式做到这一点（我试图让程序以每秒至少 0.5 帧的速度运行，这在 5 个维度上已经很困难，即使对于小空间也是如此）。

我知道位交错算法，但我不太确定如何在处理中实现它而不会溢出我的 32 位整数。任何帮助，将不胜感激。如果您想了解更多详细信息，我在下面包含了相关代码（是的，我知道这很混乱；这就是我的工作方式）：

void setup() {
  colorMode(HSB,255);
  background(0);
  frameRate(10);
  noStroke();
  ruledensity = random(1.1);
  celldensity = 0.1;
  dimension = 2;
  numstates = 5;
  scale = 20;
  rule = new int[int(pow(3.0,float(dimension)))*numstates];
  cells = new int[int(pow(float(scale),float(dimension)))];
  ncells = new int[int(pow(float(scale),float(dimension)))];
  zorder = new int[int(pow(float(scale),float(dimension)))];
  
  size(scale * 4,scale * 4);
  
  for (int a = 0; a < rule.length; a++) {
    if (random(1.0) < ruledensity) {
      rule[a] = 1 + floor(random(numstates - 1));
    } else {
      rule[a] = 0;
    }
  }
  
  for (int b = 0; b < cells.length; b++) {
    if (random(1.0) < celldensity) {
      cells[b] = 1 + floor(random(numstates - 1));
    } else {
      cells[b] = 0;
    }
    ncells[b] = cells[b];
  }
  
  
}

void draw() {
  background(0);
  for (int x = 0; x < cells.length; x++) {
    nsum = 0;
    for (int ex = 0; ex <= dimension; ex++) {
      for(int i = -1; i <= 1; i++) {
        nsum += cells[cyclize(x + i * int(pow(float(scale),float(ex-1))),cells.length)];
      }
    }
    ncells[x] = rule[nsum];
  }

4

0 回答 0