(C++实现)2-NAF

(C++实现)2-NAF

前言

‍

任何一个非负整数，都有一个唯一的 NAF (Non-adjacent form) 表示。

因着课程的缘由，我不得不研究一下 NAF 是怎么实现的，也是现学现用。

‍

Note:

‍

• 采用 C++ 实现
• 一篇很短的博客，专注于 2-NAF

‍

---

‍

目录

‍

目录

• (C++实现)2-NAF
  • 前言
  • 目录
  • 定义
  • 实现
    • V1，最low实现
    • V2，位运算
    • V3, 打破循环
    • V4，直接一次判断两位的组合
    • V5，消灭分支
  • 参考资料

‍

---

‍

定义

‍

NAF 是一种二进制符号的表示形式，定义为：

\[n=\sum_{i=0}^{i}d_{i}2^{i},d_{i}\in\left\lbrace-1,0,1\right\rbrace,\forall i\in\left\lbrace0,1,2,\ldots,k-1\right\rbrace,d_{i}\cdot d_{i+1}=0
\]

说人话就是就是没有两个相邻的非零系数。

naf的原理是下面这个等式：

\[2^{i}+2^{i-1}+\cdots+2^{j}=2^{j+1}-2^{i}
\]

这样一来，原来整数的二进制中的连续为1的表示，如{1,0,0,1,1,1,1}，就可以转化为{1,0,1,0,0,0,-1}了。

---

‍

实现

‍

V1，最low实现

‍

std::vector<int> to2NAF(long long n) {
    std::vector<int> naf; // 创建一个整数向量，用于存储NAF表示

    // 获取二进制表示，将n转换成二进制形式并存储在naf向量中
    while(n != 0) { // 只要n不为0，就继续循环
        naf.push_back(n % 2); // 将n的最低位（奇数或偶数）推入naf向量
        n >>= 1; // 将n右移一位，相当于n除以2
    }

    // 未翻转之前，下标对应的就是二进制的指数
    for(int i = 0, j = 0;;) { // 使用两个索引i和j遍历naf向量
        if(naf.size() <= i) { // 如果i超出了naf的范围，结束循环
            break;
        }
        for(; naf[i] == 0; i++); // 跳过所有值为0的位，直到找到非零位或到达末尾

        j = i + 1; // 从当前找到的非零位的下一位开始
        if(naf.size() <= j) { // 如果j超出了naf的范围，结束循环
            break;
        }
        if(naf[j] == 0) { // 如果下一位是0，那么不需要修改，继续查找下一个非零位
            i = j;
        } else { // 如果下一位是非零的
            for(; naf[j] == 1; j++) { // 跳过所有连续的1，直到找到0或到达末尾
                naf[j] = 0; // 将这些1置为0
            }
            if(naf.size() <= j) { // 如果j超出了naf的范围，需要扩展naf
                naf.resize(naf.size() + 1); // 扩展naf向量，添加一个新元素
            }
            naf[j] = 1; // 将跳过1后的第一个位置设为1
            naf[i] = -1; // 将当前位置的值改为-1，以保持数值不变

            i = j; // 更新i的位置
        }
    }

    std::reverse(naf.begin(), naf.end()); // 翻转naf向量

    return naf; // 返回NAF表示的向量
}

‍

这是一个简单的实现，为什么说很 low ？因为存在大量的边界检查，还必须要先将 N 转化为完整的2进制表示后才能处理。不行啊，就不能边转化边处理吗？

有了，假如......

‍

---

‍

V2，位运算

‍

假如，我们只聚焦两位呢，因为事实上，我们确实只需要关注两个bit位，如果组合为 (11)b，那么我们就要将其变成 (100)b，放一个 -1 进naf，如果组合为 (01)b，那么我们就要将其变成 (00)b，放一个 0 进naf，如果为 (10)b 或者 (00)b，则放一个 0 进naf即可。

为什么这样做呢？

前面我们提到了 naf 的原理，本质上就是要检查有无 (11)b 这样的表示，也就是检查两个 bit 位即可。

‍

std::vector<int> to2NAF(long long n) {
    std::vector<int> naf;
    while (n > 0) {
        int currentBit = n & 1;
        if (currentBit == 1) {
            int nextBit = (n >> 1) & 1;

            if (nextBit == 1) {
                // 2^{i}
                naf.push_back(-1);
                naf.push_back(0);
                n >>= 2;
                for(nextBit = n & 1;nextBit & 1;nextBit = n & 1){
                    naf.push_back(0);
                    n >>= 1;
                }
                // 2^{j+1}
                n += 1;
            } else {
                naf.push_back(1);
                n >>= 1;
            }
        } else {
            naf.push_back(0);
            n >>= 1;
        }
    }
    if (naf.empty()) {
        naf.push_back(0);
    }
    std::reverse(naf.begin(), naf.end());
    return naf;
}

‍

事实上，这样的实现还是不够好，为什么呢，因为有个碍眼的循环，假使没有这个循环就好了......

‍

---

‍

V3, 打破循环

‍

前面我们提到，如果组合为 (11)b，那么我们就要将其变成 (100)b，那么只需要给末位加上一个1，不就可以自动实现了吗？

‍

std::vector<int> to2NAF(long long n) {
    std::vector<int> naf;
    while (n > 0) {
        int currentBit = n & 1;
        if (currentBit & 1) {
            int nextBit = (n >> 1) & 1;

            if (nextBit & 1) {
                // 2^{i}
                naf.push_back(-1);
                // 2^{j+1}
                n += 1;
                n >>= 1;
            } else {
                naf.push_back(1);
                n >>= 1;
            }
        } else {
            naf.push_back(0);
            n >>= 1;
        }
    }
    if (naf.empty()) {
        naf.push_back(0);
    }
    std::reverse(naf.begin(), naf.end());
    return naf;
}

‍

但是呢，实现还是不够优雅，有些太长了，每次要单独看看两位 bit 位，如果说，我们能直接判断是不是(11)b,(10)b,(01)b,(00)b这样的组合就好了......

‍

---

‍

V4，直接一次判断两位的组合

‍

我们重新梳理一下逻辑：

‍

• (11)b->(100)b->(10)b
• (10)b|(00)b->(1)b|(0)b
• (01)b->(00)b

‍

(10)b|(00)b 对应的是什么呢？是偶数，也就是 n & 1 ** 0 的情况，与之相对的 (11)b 和 (01)b 则对应 n & 1 ** 1，那么，我们只需要......

‍

std::vector<int> to2NAF(long long N) {
    std::vector<int> naf;

    while (N > 0) {
        if (N & 1) {
            int flag = N & 3;
            if(flag == 3){
                // 如果N & 3的结果是3（二进制11），则进-1，+1得(100)b
                naf.push_back(-1);
                N += 1;
            }else{
                // 如果N & 3的结果是1（二进制01），则进1，-1得(00)b
                naf.push_back(1);
                N -= 1;
            }
        } else {
            // (10)b|(00)，进0
            naf.push_back(0);
        }
        N >>= 1;
    }

    std::reverse(naf.begin(), naf.end());
    return naf;
}

‍

但是我还是不满足，我觉得那个flag的分支判断比较碍眼，能不能也优化掉呢？比方说不判断，直接放相应的计算值就行了。

假如......

‍

---

‍

V5，消灭分支

‍

既然 N & 3 为 3 的时候放 -1 进去，N & 3 为 1 的时候放 1 进去，什么数与 1 差为 1，与 3 差为 -1 呢？

答案是 2。

然后，放 1 进去，N 要减 1，放 -1进去，N要减去(-1)。

那么，我们可以这样优化......

‍

std::vector<int> to2NAF(long long N) {
    std::vector<int> naf;

    while (N > 0) {
        if (N & 1) {
            // 如果N & 3的结果是3（二进制11），则进-1，+1得(100)b
            // 如果N & 3的结果是1（二进制01），则进1，-1得(00)b
            naf.push_back(2 - (N & 3));
            N -= naf.back();
        } else {
            // (10)b|(00)，进0
            naf.push_back(0);
        }
        N >>= 1;
    }

    std::reverse(naf.begin(), naf.end());
    return naf;
}

‍

想了想，如果一次移动两位，则要考虑 N 能不能移两位，感觉目前已经是最优解（大概）了，就此结束。

‍

---

‍

参考资料

‍

• NULL

‍

---

‍