C++ 快速序列有序Walsh-Hadamard变换

编辑您可以在Github上签出我的实现：

---

我正在寻找一种实现方法，或关于如何实现序列有序的快速沃尔什-哈达玛变换的指示（请参阅和）

我稍微修改了一个非常好的实现，发现：

/（a，b）->（a+b，a-b）无溢出
空心旋转（长a、长b）
{
静态长t；
t=a；
a=a+b；
b=t-b；
}
//整数log2
长ilog2（长x）
{
长l2=0；
对于（；x；x>>=1）++l2；
返回l2；
}
/**
*快速沃尔什-阿达玛变换
*/
无效fwht（标准：：矢量和数据）
{
const long l2=ilog2（data.size（））-1；
对于（长i=0；i
通过首先应用位反转置换，然后应用格雷码置换，可以从哈达玛矩阵的排序中导出沃尔什矩阵行的顺序排序

位反转算法有多种实现方式，例如：

// Bit-reversal
// adapted from http://www.idi.ntnu.no/~elster/pubs/elster-bit-rev-1989.pdf
void bitrev(int t, std::vector<long>& c)
{
  long n = 1<<t;
  long L = 1;
  c[0]  = 0;
  for (int q=0; q<t; ++q)
  {
    n /= 2;
    for (long j=0; j<L; ++j)
    {
      c[L+j] = c[j] + n;
    }
    L *= 2;
  }
}

这些可以结合起来产生最终排列：

// Compute a permutation of size 2^order 
// to reorder the Fast Walsh-Hadamard transform's output 
// into the Walsh-ordered (sequency-ordered)
void sequency_permutation(long order, std::vector<long>& p)
{
  long n = 1<<order;

  std::vector<long> tmp(n);
  bitrev(order, tmp);
  p.resize(n);
  for (long i=0; i<n; ++i)
  {
    p[i] = tmp[binaryToGray(i)];
  }
}

//计算大小为2^的排列顺序
//对快速沃尔什-阿达玛变换的输出进行重新排序
//进入沃尔什顺序（顺序顺序顺序）
空序排列（长序，标准：：向量&p）
{
long n=1谢谢：）我现在正在工作，但我回家后一定会试试你的帖子！期待测试！
/*
    The purpose of this function is to convert an unsigned
    binary number to reflected binary Gray code.

    The operator >> is shift right. The operator ^ is exclusive or.
*/
unsigned int binaryToGray(unsigned int num)
{
    return (num >> 1) ^ num;
}

// Compute a permutation of size 2^order 
// to reorder the Fast Walsh-Hadamard transform's output 
// into the Walsh-ordered (sequency-ordered)
void sequency_permutation(long order, std::vector<long>& p)
{
  long n = 1<<order;

  std::vector<long> tmp(n);
  bitrev(order, tmp);
  p.resize(n);
  for (long i=0; i<n; ++i)
  {
    p[i] = tmp[binaryToGray(i)];
  }
}

void permuted_fwht(std::vector<long>& data, const std::vector<long>& permutation)
{
  std::vector<long> tmp = data;
  fwht(tmp);

  for (long i=0; i<data.size(); ++i)
  {
    data[i] = tmp[permutation[i]];
  }
}

  std::vector<long> p;

  const long order = ilog2(data_block_size) - 1;
  sequency_permutation(order, p);

  permuted_fwht( data_block_1, p);
  permuted_fwht( data_block_2, p);
  //...