那么，它是如何运作的？

Question

有没有任何已知的方法来计算两个格雷码的加法（也许是减法）而不必将两个格雷码转换为常规二进制，执行二进制加法然后将结果转换回格雷码？我设法编写递增和递减函数，但加法和减法似乎记录得更少，更难写。

Answer 1

在＃{3}}下的＃6中，有一个用于添加序列格雷码的算法（直接复制;请注意，⊕为xor）：

procedure add (n: integer; A,B:word; PA,PB:bit;
               var S:word; var PS:bit; var CE, CF:bit);
var i: integer; E, F, T: bit;
begin
   E := PA; F := PB;
   for i:= 0 to n-1 do begin {in parallel, using previous inputs}
       S[i] := (E and F) ⊕ A[i] ⊕ B[i];
       E := (E and (not F)) ⊕ A[i];
       F := ((not E) and F) ⊕ B[i];
   end;
   CE := E; CF := F;
end;

这将格雷码字A和B相加以形成格雷码字S.操作数奇偶校验位是PA和PB，求和奇偶校验位是PS。这在内部传播两个进位位E和F，并产生两个外部进位位CE和CF

不幸的是，它没有说明有关减法的任何内容，但我认为，当你可以编码负数时，你可以使用加法。

Answer 2

我接受了@Sebastian Dressler的回答，因为建议的算法确实有效。为了完整起见，我在这里提出了相应的C99算法实现（C ++兼容）：

// lhs and rhs are encoded as Gray codes
unsigned add_gray(unsigned lhs, unsigned rhs)
{
    // e and f, initialized with the parity of lhs and rhs
    // (0 means even, 1 means odd)
    bool e = __builtin_parity(lhs);
    bool f = __builtin_parity(rhs);

    unsigned res = 0u;
    for (unsigned i = 0u ; i < CHAR_BIT * sizeof(unsigned) ; ++i)
    {
        // Get the ith bit of rhs and  lhs
        bool lhs_i = (lhs >> i) & 1u;
        bool rhs_i = (rhs >> i) & 1u;

        // Copy e and f (see {in parallel} in the original paper)
        bool e_cpy = e;
        bool f_cpy = f;

        // Set the ith bit of res
        unsigned res_i = (e_cpy & f_cpy) ^ lhs_i ^ rhs_i;
        res |= (res_i << i);

        // Update e and f
        e = (e_cpy & (!f_cpy)) ^ lhs_i;
        f = ((!e_cpy) & f_cpy) ^ rhs_i;
    }
    return res;
}

注意：__builtin_parity是编译器内部函数（GCC和Clang），它返回整数中设置位数的奇偶校验（如果内在函数不存在，则有other methods来计算它用手）。灰度代码即使具有偶数个设置位也是如此。该算法仍然可以改进，但这种实现相当忠实于原始算法。如果您需要有关优化实施的详细信息，可以查看“代码审查”中的this Q&A。

Answer 3

我最近设计了一种新算法来添加两个格雷码。不幸的是，它仍然比天真的双转换解决方案慢，并且也比Harold Lucal的算法（接受的答案中的那个）慢。但欢迎任何解决问题的新方案，对吗？

// lhs and rhs are encoded as Gray codes
unsigned add_gray(unsigned lhs, unsigned rhs)
{
    // Highest power of 2 in lhs and rhs
    unsigned lhs_base = hyperfloor(lhs);
    unsigned rhs_base = hyperfloor(rhs);

    if (lhs_base == rhs_base)
    {
        // If lhs and rhs are equal, return lhs * 2
        if (lhs == rhs)
        {
            return (lhs << 1u) ^ __builtin_parity(lhs);
        }
        // Else return base*2 + (lhs - base) + (rhs - base)
        return (lhs_base << 1u) ^ add_gray(lhs_base ^ lhs, lhs_base ^ rhs);
    }

    // It's easier to operate from the greatest value
    if (lhs_base < rhs_base)
    {
        swap(&lhs, &rhs);
        swap(&lhs_base, &rhs_base);
    }

    // Compute lhs + rhs
    if (lhs == lhs_base)
    {
        return lhs ^ rhs;
    }

    // Compute (lhs - base) + rhs
    unsigned tmp = add_gray(lhs ^ lhs_base, rhs);
    if (hyperfloor(tmp) < lhs_base)
    {
        // Compute base + (lhs - base) + rhs
        return lhs_base ^ tmp;
    }
    // Here, hyperfloor(lhs) == hyperfloor(tmp)
    // Compute hyperfloor(lhs) * 2 + ((lhs - hyperfloor(lhs)) + rhs) - hyperfloor(lhs)
    return (lhs_base << 1u) ^ (lhs_base ^ tmp);
}

该算法使用以下实用程序功能，以便正确地工作：

// Swap two values
void swap(unsigned* a, unsigned* b)
{
    unsigned temp = *a;
    *a = *b;
    *b = temp;
}

// Isolate the most significant bit
unsigned isomsb(unsigned x)
{
    for (unsigned i = 1u ; i <= CHAR_BIT * sizeof(unsigned) / 2u ; i <<= 1u)
    {
        x |= x >> i;
    }
    return x & ~(x >> 1u);
}

// Return the greatest power of 2 not higher than
// x where x and the power of 2 are encoded in Gray
// code
unsigned hyperfloor(unsigned x)
{
    unsigned msb = isomsb(x);
    return msb | (msb >> 1u);
}

那么，它是如何运作的？

我不得不承认，对于像“简单”这样的东西来说，这是一段代码。它主要基于对格雷码中位模式的观察;也就是说，我没有正式证明任何东西，但我还没有找到算法不起作用的情况（如果我不考虑溢出，它不处理溢出）。以下是用于构造算法的主要观察结果，假设所有内容都是格雷码：

2 * n =（n <＆lt; 1）⊕parity（n）
如果a是2的幂且a> 1。 b，然后a⊕b= a + b
因此，i a是2的幂，并且＆lt; b，然后a⊕b= a - b。这只有在b <1时才有效。 2 * a虽然。
如果a和b具有相同的地层但不相等，那么a + b =（超地层（a）<1）⊕（（地板（a）⊕a）+（地层（b）⊕b ））。

基本上，这意味着我们知道如何乘以2，如何将2的幂加到较小的格雷码中，以及如何从格雷码中减去2的幂，该格雷码大于2的幂但更小其余的都是技巧，所以我们可以用相等的数值或2的幂来推理。

如果您需要更多详细信息/信息，还可以查看Code Review上的this Q&A，它提出了算法的现代C ++实现以及一些优化（作为奖励，我们有一些很好的MathJax方程式不能在这里：D）。

格雷码添加

3 个答案:

那么，它是如何运作的？