tstillwell
diff --git a/‎.gitignore
Lines changed: 1 addition & 0 deletions b/‎.gitignore
Lines changed: 1 addition & 0 deletions
diff --git a/‎README.md
Lines changed: 118 additions & 110 deletions b/‎README.md
Lines changed: 118 additions & 110 deletions
diff --git a/‎README.zh-CN.md
Lines changed: 90 additions & 90 deletions b/‎README.zh-CN.md
Lines changed: 90 additions & 90 deletions
diff --git a/‎README.zh-TW.md
Lines changed: 90 additions & 90 deletions b/‎README.zh-TW.md
Lines changed: 90 additions & 90 deletions
diff --git a/‎package-lock.json
Lines changed: 1 addition & 1 deletion b/‎package-lock.json
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/algorithms/math/bits/README.md
Lines changed: 99 additions & 0 deletions b/‎src/algorithms/math/bits/README.md
Lines changed: 99 additions & 0 deletions
diff --git a/‎src/algorithms/math/bits/__test__/clearBit.test.js
Lines changed: 15 additions & 0 deletions b/‎src/algorithms/math/bits/__test__/clearBit.test.js
Lines changed: 15 additions & 0 deletions
diff --git a/‎src/algorithms/math/bits/__test__/divideByTwo.test.js
Lines changed: 12 additions & 0 deletions b/‎src/algorithms/math/bits/__test__/divideByTwo.test.js
Lines changed: 12 additions & 0 deletions
diff --git a/‎src/algorithms/math/bits/__test__/getBit.test.js
Lines changed: 23 additions & 0 deletions b/‎src/algorithms/math/bits/__test__/getBit.test.js
Lines changed: 23 additions & 0 deletions
diff --git a/‎src/algorithms/math/bits/__test__/multiplyByTwo.test.js
Lines changed: 12 additions & 0 deletions b/‎src/algorithms/math/bits/__test__/multiplyByTwo.test.js
Lines changed: 12 additions & 0 deletions
@@ -2,3 +2,4 @@ node_modules
 .idea
 coverage
 .vscode
+.DS_Store
@@ -0,0 +1,99 @@
+
+#### 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)
@@ -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);
+  });
+});
@@ -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);
+  });
+});
@@ -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);
+  });
+});
@@ -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);
+  });
+});