嵌套循环：置换由向量表示的 n 维数组

Question

我有一个n 维数组T，其中每个维度的长度相同L。该数组由一维向量v 表示（可以看作是T 的“重塑”版本，因此v 的长度为L^n）。

以下示例显示如何根据T（其中n = 3 和L = 4）的索引对v 进行索引：

（例如T(0,3,2) = v[14]）

我想做的是创建一个向量u，它代表一个n维数组S，其中S是通过将T置换/旋转1获得的，即

T(i1,i2,...,in) = S(i2,i3,...,in,i1) 用于任何(i1,i2,...,in)。

（当T为矩阵时，S对应T的转置）。

更新：

以下代码可能更好地解释我的问题：

void permute(vector<double> &output, const vector<double> &v, int L)
{
    int n = log(v.size())/log(L);

    // Suppose that we have a function doing this
    narray T = get_narray_from_vector(v, L);

    // Get the permutation of T
    narray S(T.size());
    for(int i1 = 0; i1 < L; i1++){
        for(int i2 = 0; i2 < L; i2++){
            ...
            for(int in = 0; in < L; in++){
                S(i2,i3,...,in,i1) = T(i1,i2,...,in);
            }
        }
    }

    // get vector from narray
    output.resize(v.size());
    int idx = 0;   
    for(int i1 = 0; i1 < L; i1++){
        for(int i2 = 0; i2 < L; i2++){
            ...
            for(int in = 0; in < L; in++){
                output[idx] = S(i1,i2,...,in);
                idx++;
            }
        }
    }   
}

然而，在实践中，我认为直接使用向量会更好。因此，我会做这样的事情：

void permute(vector<double> &output, const vector<double> &v, int L)
{
    int n = log(v.size())/log(L);
    output.resize(v.size());

    // Get the permutation
    for(int i1 = 0; i1 < L; i1++){
        for(int i2 = 0; i2 < L; i2++){
            ...
            for(int in = 0; in < L; in++){
                output[i2*pow(L, n-1) + i3*pow(L, n-2) + ... + in*L + i1] = v[i1*pow(L, n-1) + i2*pow(L, n-2) + ... + i_{n-1}*L + in];
            }
        }
    } 
}

这里的难点在于嵌套循环，因为n是一个参数。

任何想法如何做到这一点？ 预先感谢您的帮助！！

Answer 1

这是一个不需要 n 嵌套 for 循环的解决方案。

首先，我有一些旧代码将数字分解为基于L 的数字系统。

std::vector<int>
num2base(const int value,
         const unsigned int base){

  // Represents an input int VALUE in a new BASE-based number system                                                                                                    
  // n = a0*b^0 + a1*b^1 + ...                                                                                                                                          

  std::vector<int> base_representation;
  unsigned int num_digs = (unsigned int) (floor(log(value)/log(base))+1);
  base_representation.resize(num_digs);

  for (unsigned int i_dig = 0; i_dig < num_digs; i_dig++){
    base_representation[i_dig] =
      ((value % (int) pow(base,i_dig+1)) - (value % (int) pow(base, i_dig))) /
      (int) pow(base, i_dig);
  }

  return base_representation;
}

换句话说，这是一种将单值索引idx 转换为i1 到in n-元组索引的方法。

idx = i1*L^0 + i2*L^1 + ... in*L^(n-1)

这是另一种方式的代码

int
base2num(const std::vector<int> base_representation,
         const unsigned int base){

  unsigned int digit_val = 1;

  int value = 0;

  for (unsigned int digit = 0; digit < base_representation.size(); digit++){
    value += base_representation[digit]*digit_val;
    digit_val *= base;
  }

  return value;
}

一旦有了代表n-tuple 索引的std::vector<int>，就很容易置换它。

void
permute_once(std::vector<int> &base_representation){

  std::vector<int>::iterator pbr = base_representation.begin();
  int tmp = *pbr;
  base_representation.erase(pbr);
  base_representation.push_back(tmp);

  return;
}

所以，要生成新的n维数组S

1. 遍历idxS 的每个索引S。

2. 将idxS 转换为n-元组（iS1，iS2，...，iSn）

3. 在T及其n-tuple（iT1、iT2、...、iTn）中查找关联条目

4. 将其转换为单个索引idxT。

5. u[idxS] = v[idxT];