如何将 M 维数组转换为 N 维数组？

Question

在阅读了这篇文章及其下面的评论后，受到arr2D[i][j]和arr1D[i * k + j]启发，我想知道一种可以改变任何数组维度的算法。

让我尝试将其正式化：

输入：

1. 一个M维容器A

2. 集装箱的尺寸D （尺寸）

3. 目标维度N

输出：

如果N > 0则返回与A内容相同的 N 维容器B ，否则返回错误代码。

笔记：

您可以为 N 维容器选择任何最佳大小。

编辑：

我不需要任何完全工作的代码。 我在问是否有任何算法可以做到这一点？

Answer 1

将 [100] 转换为 [10][10]：

#include <iostream>

typedef int (*parray)[10];

parray foo (int *in) {
    return (parray)in;
}

int main()
{
    int in[100];
    in[55] = 42;
    int (*out)[10] = foo(in);
    std::cout << out[5][5] << std::endl;

    return 0;
}

Answer 2

你原来的M维容器是A 。

我们想创建一个新的N维容器B来保存A所有内容。

首先，我们必须找出一个映射，我们可以很容易地在A和B找到相同的元素。

让我们用一些例子来推断映射是怎样的：

(1) M = 2, N = 1

A: a * b    B: c
we can set the dimension c to be a * b, thus we have
A[i][j] = B[i * c + j]

(2) M = 3, N = 1

A: a * b * c    B: d
d = a * b * c
A[i][j][k] = B[(i * b * c) + (j * c) + k]

(3) M = 3, N = 2

A: a * b * c    B: d * e
d = a, e = b * c
A[i][j][k] = B[i][j * c + k]

(4) M = 4, N = 1

A: a * b * c * d    B: e
e = a * b * c * d
A[i][j][k][l] = B[(i * b * c * d) + (j * c * d) + (k * d) + l]

(5) M = 5, N = 4

A: a * b * c * d * e    B: u * v * w * x
u = a, v = b, w = c, x = d * e
A[i][j][k][l][m] = B[i][j][k][(l * e) + m]

(6) M = 5, N = 2

A: a * b * c * d * e    B: f * g
f = a, g = b * c * d * e
A[i][j][k][l][m] = B[i][(j * c * d * e) + (k * d * e) + (l * e) + m]

---

如果 A 有 M 个维度 a1, a2, ..., aM 并且 B 有 N 个维度 b1, b2, ..., bN，我们可以说：

如果 M > N，则对于所有 0 < i < N，bi = ai 和 bN = aN * aN+1 * ... * aM。

这样我们就知道如何创建 B 以及它的每个维度的大小。

使用示例中显示的映射函数，您可以轻松地将任何M维矩阵转换为N维矩阵。

如果M < N ，你可以做同样的事情，但方向相反。

Answer 3

由于您不需要代码，让我解释一下如何使用模板来实现。

假设您有一个大小为 n_{0},...,n_{d-1} 的 D 维数组，您总是可以通过合并其中两个乘以大小来删除一维。 示例：a[5][4][3] 包含 60 个元素，因此 b[20][3] 或 c[5][12]（对于简单的情况，因为您甚至可以构造 d[15][4] 和任何排列）都可以很容易地包含与 a 相同的元素，索引的映射也是如此明显......

现在使用 C++ 做这件事要棘手得多，但您将需要：可变参数模板和模板元编程。

可变参数模板定义您喜欢的任何维度的数组类型，模板元编程定义一个运算符将 D 维数组映射到 N 维数组。 （我可能会说这并不容易，但是模板元编程中的一个非常困难的好练习）。

Answer 4

因此，您只想在不更改数据的情况下重新格式化矩阵。 正如我在评论中暗示的那样，最简单的方法是使用一维数组中间步骤将 M 维转换为 N 维。

这里的其他答案在同一条轨道上，但缺乏整个数学......他们只有一些没有普遍方程的小维度的例子，所以这里是：

在A[A0][A1]...[A(M-1)]和X[A0*A1*...*A(M-1)] ，其中A0,A1,...A(M-1)是容器的尺寸大小（分辨率），只需执行以下操作：

// M-D -> 1D
x = a0
   +a1*A0
   +a2*A0*A1
   ...
   +a(M-1)*A0*A1*...*A(M-2);

// 1D -> M-D   
q=x;
a0 = q%A0; q/=A0;
a1 = q%A1; q/=A1;
a2 = q%A2; q/=A2;
...
a(M-1) = q%A(M-1); q/=A(M-1);

其中a0,a1,...a(M-1)和x是数组中的索引。

您实际上不需要将 MD 数组转换为 1D，然后再返回到 ND 就足以转换索引，因此：

for (a0=0;a0<A0;a0++)
 for (a1=0;a1<A1;a1++)
  ...
   for (a(M-1)=0;a(M-1)<A(M-1);a(M-1)++)
      {
      // M-D -> 1D
      x = a0
         +a1*A0
         +a2*A0*A1
         ...
         +a(M-1)*A0*A1*...*A(M-2);
      // 1D -> N-D   
      q=x;
      b0 = q%B0; q/=B0;
      b1 = q%B1; q/=B1;
      b2 = q%B2; q/=B2;
      ...
      b(N-1) = q%B(N-1); q/=B(N-1);
      // copy A -> B
      B[b0][b1]...[b(N-1)] = A[A0][A1]...[A(M-1)];
      }

不要忘记尺寸必须是：

A0*A1*...*A(M-1) <= B0*B1*...*B(N-1)

否则您将访问数组超出其范围，因为A的数据将不适合B 。

如果您有动态维度，您可以使用：

• 动态嵌套for循环nested_for