/**
* bit相关工具类
*/
bitUtils = {
/**
* @description 此方法将相关位移到第0位。执行与操作，如果相关位为1，则结果为1，否则结果为0。
* @param {number} number
* @param {number} bitPosition - zero based.
* @return {number}
*/
getBit: function(number, bitPosition) {
return (number >> bitPosition) & 1;
},
/**
* @description 此方法按位置位移动1，执行或操作，将特定位设置为1，但不影响数字的其他位。
* @param {number} number
* @param {number} bitPosition - zero based.
* @return {number}
*/
setBit: function(number, bitPosition) {
return number | (1 << bitPosition);
},
/**
* @description 此方法按位位置位移动1，创建一个类似于00100的值。然后它反转这个掩码，得到看起来像11011的数字。然后，操作将同时应用于数字和掩码。那次操作使钻头复位。
* @param {number} number
* @param {number} bitPosition - zero based.
* @return {number}
*/
clearBit: function(number, bitPosition) {
const mask = ~ (1 << bitPosition);
return number & mask;
},
/**
* @description 此方法为setBit与clearBit的结合，更新指定为的值
* @param {number} number
* @param {number} bitPosition - zero based.
* @param {number} bitValue - 0 or 1.
* @return {number}
*/
updateBit: function(number, bitPosition, bitValue) {
const bitValueNormalized = bitValue ? 1 : 0;
const clearMask = ~ (1 << bitPosition);
return (number & clearMask) | (bitValueNormalized << bitPosition);
},
/**
* @description 此方法确定提供的数字是否为偶数。这是基于奇数的最后一个正确位被设置为1的事实。
* @param {number} number
* @return {boolean}
*/
isEven: function(number) {
return (number & 1) === 0;
},
/**
* @description 此方法确定数字是否为正。它基于这样一个事实：所有正数的最左边的位都设置为0。但是，如果提供的数字为零或负零，则仍应返回false。
* @param {number} number
* @return {boolean}
*/
isPositive: function(number) {
if (number === 0) {
return false;
}
return ((number >> 31) & 1) === 0;
},
/**
* @description 此方法将原始数字向左移动一位。因此，所有二进制数的分量（2的幂）都是乘2的，因此数字本身是乘2的。
* @param {number} number
* @return {number}
*/
multiplyByTwo: function(number) {
return number << 1;
},
/**
* @description 此方法将原始数字向右移动一位。因此，所有二进制数的分量（2的幂）都被2除，因此数字本身被2除，没有余数。
* @param {number} number
* @return {number}
*/
divideByTwo: function(number) {
return number >> 1;
},
/**
* @description 这种方法使正数变成负数和倒数。为了做到这一点，它使用了“两个补码”的方法，通过反转数字的所有位并加上1来实现。
* @param {number} number
* @return {number}
*/
switchSign: function(number) {
return~ number + 1;
},
/**
* @description 此方法使用位运算符将两个有符号整数相乘。该方法基于以下事实：
a*b可以用以下格式书写：
0如果a为零或b为零或a和b都为零
2a*（b/2）如果b是偶数
2a*（b-1）/2+a如果b是奇数正的
2a*（b+1）/2-a如果b是奇数和负数
这种方法的优点是，在每个递归步骤中，一个操作数减少到其原始值的一半。因此，运行时复杂度是O（log（b）），其中B是在每个递归步骤上减少到一半的操作数。
* @param {number} number
* @return {number}
*/
multiply: function(a, b) {
if (b === 0 || a === 0) {
return 0;
}
const multiplyByOddPositive = () = > this.multiply(this.multiplyByTwo(a), this.divideByTwo(b - 1)) + a;
const multiplyByOddNegative = () = > this.multiply(this.multiplyByTwo(a), this.divideByTwo(b + 1)) - a;
const multiplyByEven = () = > this.multiply(this.multiplyByTwo(a), this.divideByTwo(b));
const multiplyByOdd = () = > (this.isPositive(b) ? multiplyByOddPositive() : multiplyByOddNegative());
return this.isEven(b) ? multiplyByEven() : multiplyByOdd();
},
/**
* @description 此方法使用位运算符将两个整数相乘。这种方法是基于“每个数都可以表示为2的幂和”。按位乘法的主要思想是，每一个数可以被分成两个幂的和：
即。19=2^4+2^1+2^0,那么x乘以19等于：x*19=x*2^4+x*2^1+x*2^0。现在我们需要记住，x*2^4相当于将x左移4位（x<4）。
* @param {number} number1
* @param {number} number2
* @return {number}
*/
multiplyUnsigned: function(number1, number2) {
let result = 0;
let multiplier = number2;
let bitIndex = 0;
while (multiplier !== 0) {
if (multiplier & 1) {
result += (number1 << bitIndex);
}
bitIndex += 1;
multiplier >>= 1;
}
return result;
},
/**
* @description 此方法使用按位运算符计算数字中的设置位数。主要思想是，我们一次将数字右移一位，然后检查&operation的结果，如果设置了位，则结果为1，否则结果为0。
* @param {number} originalNumber
* @return {number}
*/
countSetBits: function(originalNumber) {
let setBitsCount = 0;
let number = originalNumber;
while (number) {
setBitsCount += number & 1;
number >>= 1;
}
return setBitsCount;
},
/**
* @description 此方法输出将一个数转换为另一个数所需的位数。这利用了这样一个特性：当数字被异或时，结果将是不同位的数字。
* @param {number} numberA
* @param {number} numberB
* @return {number}
*/
bitsDiff: function(numberA, numberB) {
return this.countSetBits(numberA ^ numberB);
},
/**
* @description 为了计算有价值的位数，我们需要每次左移1位，看看移位的位数是否大于输入位数。
* @param {number} number
* @return {number}
*/
bitLength: function(number) {
let bitsCounter = 0;
while ((1 << bitsCounter) <= number) {
bitsCounter += 1;
}
return bitsCounter;
},
/**
* @description 此方法检查提供的数字是否为2的幂。它使用以下属性。假设power number是一个由2的幂（即2、4、8、16等）构成的数。然后如果我们在power number和powerNumber-1之间执行操作，它将返回0（如果number是2的幂）。
* @param {number} number
* @return {boolean}
*/
isPowerOfTwo: function(number) {
return (number & (number - 1)) === 0;
},
/**
* @description 此方法使用按位运算符将两个整数相加。
* * Table(1)
* INPUT | OUT
* C Ai Bi | C Si | Row
* -------- | -----| ---
* 0 0 0 | 0 0 | 1
* 0 0 1 | 0 1 | 2
* 0 1 0 | 0 1 | 3
* 0 1 1 | 1 0 | 4
* -------- | ---- | --
* 1 0 0 | 0 1 | 5
* 1 0 1 | 1 0 | 6
* 1 1 0 | 1 0 | 7
* 1 1 1 | 1 1 | 8
* ---------------------
*
* Legend:
* INPUT C = Carry in, from the previous less-significant stage
* INPUT Ai = ith bit of Number A
* INPUT Bi = ith bit of Number B
* OUT C = Carry out to the next most-significant stage
* OUT Si = Bit Sum, ith least significant bit of the result
*
* @param {number} a
* @param {number} b
* @return {number}
*/
fullAdder: function(a, b) {
let result = 0;
let carry = 0;
for (let i = 0; i < 32; i += 1) {
const ai = this.getBit(a, i);
const bi = this.getBit(b, i);
const carryIn = carry;
const aiPlusBi = ai ^ bi;
const bitSum = aiPlusBi ^ carryIn;
const carryOut = (aiPlusBi & carryIn) | (ai & bi);
carry = carryOut;
result |= bitSum << i;
}
return result;
}
}
