(C++实现)2-NAF
前言
任何一个非负整数，都有一个唯一的 NAF (Non-adjacent form) 表示。
因着课程的缘由，我不得不研究一下 NAF 是怎么实现的，也是现学现用。
Note:
- 采用 C++ 实现
- 一篇很短的博客，专注于 2-NAF
目录
定义
NAF 是一种二进制符号的表示形式，定义为：
说人话就是就是没有两个相邻的非零系数。
naf的原理是下面这个等式：
这样一来，原来整数的二进制中的连续为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
浙公网安备 33010602011771号