Merged fork master with upstream

Author: hariv

README.md

@@ -0,0 +1,99 @@
+# Bit Manipulation
+
+#### Get Bit
+
+This method shifts `1` over by `bitPosition` bits, creating a 
+value that looks like `00100`. Then we perform `AND` operation
+that clears all bits from the original number except the
+`bitPosition` one. Then we compare the result with zero. If 
+result is zero that would mean that original number has `0` at
+position `bitPosition`.
+
+> See `getBit` function for further details.
+
+#### Set Bit
+
+This method shifts `1` over by `bitPosition` bits, creating a
+value that looks like `00100`. Then we perform `OR` operation
+that sets specific bit into `1` but it does not affect on
+other bits of the number.
+
+> See `setBit` function for further details.
+
+#### Clear Bit
+
+This method shifts `1` over by `bitPosition` bits, creating a
+value that looks like `00100`. Than it inverts this mask to get
+the number that looks like `11011`. Then `AND` operation is
+being applied to both the number and the mask. That operation 
+unsets the bit.
+
+> See `clearBit` function for further details.
+
+#### Update Bit
+
+This method is a combination of "Clear Bit" and "Set Bit" methods.
+
+> See `updateBit` function for further details.
+
+#### Multiply By Two
+
+This method shifts original number by one bit to the left.
+Thus all binary number components (powers of two) are being
+multiplying by two and thus the number itself is being 
+multiplied by two.
+
+```
+Before the shift
+Number: 0b0101 = 5
+Powers of two: 0 + 2^2 + 0 + 2^0 
+
+After the shift
+Number: 0b1010 = 10
+Powers of two: 2^3 + 0 + 2^1 + 0 
+```
+
+> See `multiplyByTwo` function for further details.
+
+#### Divide By Two
+
+This method shifts original number by one bit to the right.
+Thus all binary number components (powers of two) are being
+divided by two and thus the number itself is being 
+divided by two without remainder.
+
+```
+Before the shift
+Number: 0b0101 = 5
+Powers of two: 0 + 2^2 + 0 + 2^0 
+
+After the shift
+Number: 0b0010 = 2
+Powers of two: 0 + 0 + 2^1 + 0 
+```
+
+> See `divideByTwo` function for further details.
+
+#### Switch Sign
+
+This method make positive numbers to be negative and backwards.
+To do so it uses "Twos Complement" approach which does it by
+inverting all of the bits of the number and adding 1 to it.
+
+```
+1101 -3
+1110 -2
+1111 -1
+0000  0
+0001  1
+0010  2
+0011  3
+``` 
+
+> See `switchSign` function for further details.
+
+## References
+
+- [Bit Manipulation on YouTube](https://www.youtube.com/watch?v=NLKQEOgBAnw&t=0s&index=28&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [Negative Numbers in binary on YouTube](https://www.youtube.com/watch?v=4qH4unVtJkE&t=0s&index=30&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [Bit Hacks on stanford.edu](https://graphics.stanford.edu/~seander/bithacks.html)

README.zh-CN.md

@@ -0,0 +1,15 @@
+import clearBit from '../clearBit';
+
+describe('clearBit', () => {
+  it('should clear bit at specific position', () => {
+    // 1 = 0b0001
+    expect(clearBit(1, 0)).toBe(0);
+    expect(clearBit(1, 1)).toBe(1);
+    expect(clearBit(1, 2)).toBe(1);
+
+    // 10 = 0b1010
+    expect(clearBit(10, 0)).toBe(10);
+    expect(clearBit(10, 1)).toBe(8);
+    expect(clearBit(10, 3)).toBe(2);
+  });
+});

README.zh-TW.md

@@ -0,0 +1,12 @@
+import divideByTwo from '../divideByTwo';
+
+describe('divideByTwo', () => {
+  it('should divide numbers by two using bitwise operations', () => {
+    expect(divideByTwo(0)).toBe(0);
+    expect(divideByTwo(1)).toBe(0);
+    expect(divideByTwo(3)).toBe(1);
+    expect(divideByTwo(10)).toBe(5);
+    expect(divideByTwo(17)).toBe(8);
+    expect(divideByTwo(125)).toBe(62);
+  });
+});

src/algorithms/math/bits/README.md

@@ -0,0 +1,23 @@
+import getBit from '../getBit';
+
+describe('getBit', () => {
+  it('should get bit at specific position', () => {
+    // 1 = 0b0001
+    expect(getBit(1, 0)).toBe(1);
+    expect(getBit(1, 1)).toBe(0);
+
+    // 2 = 0b0010
+    expect(getBit(2, 0)).toBe(0);
+    expect(getBit(2, 1)).toBe(1);
+
+    // 3 = 0b0011
+    expect(getBit(3, 0)).toBe(1);
+    expect(getBit(3, 1)).toBe(1);
+
+    // 10 = 0b1010
+    expect(getBit(10, 0)).toBe(0);
+    expect(getBit(10, 1)).toBe(1);
+    expect(getBit(10, 2)).toBe(0);
+    expect(getBit(10, 3)).toBe(1);
+  });
+});

src/algorithms/math/bits/__test__/clearBit.test.js

@@ -0,0 +1,12 @@
+import multiplyByTwo from '../multiplyByTwo';
+
+describe('multiplyByTwo', () => {
+  it('should multiply numbers by two using bitwise operations', () => {
+    expect(multiplyByTwo(0)).toBe(0);
+    expect(multiplyByTwo(1)).toBe(2);
+    expect(multiplyByTwo(3)).toBe(6);
+    expect(multiplyByTwo(10)).toBe(20);
+    expect(multiplyByTwo(17)).toBe(34);
+    expect(multiplyByTwo(125)).toBe(250);
+  });
+});

src/algorithms/math/bits/__test__/divideByTwo.test.js

@@ -0,0 +1,15 @@
+import setBit from '../setBit';
+
+describe('setBit', () => {
+  it('should set bit at specific position', () => {
+    // 1 = 0b0001
+    expect(setBit(1, 0)).toBe(1);
+    expect(setBit(1, 1)).toBe(3);
+    expect(setBit(1, 2)).toBe(5);
+
+    // 10 = 0b1010
+    expect(setBit(10, 0)).toBe(11);
+    expect(setBit(10, 1)).toBe(10);
+    expect(setBit(10, 2)).toBe(14);
+  });
+});

src/algorithms/math/bits/__test__/getBit.test.js

@@ -0,0 +1,13 @@
+import switchSign from '../switchSign';
+
+describe('switchSign', () => {
+  it('should switch the sign of the number using twos complement approach', () => {
+    expect(switchSign(0)).toBe(0);
+    expect(switchSign(1)).toBe(-1);
+    expect(switchSign(-1)).toBe(1);
+    expect(switchSign(32)).toBe(-32);
+    expect(switchSign(-32)).toBe(32);
+    expect(switchSign(23)).toBe(-23);
+    expect(switchSign(-23)).toBe(23);
+  });
+});