Refactor bitwise multiplication.

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

@@ -0,0 +1,15 @@
+import multiplyUnsigned from '../multiplyUnsigned';
+
+describe('multiplyUnsigned', () => {
+  it('should multiply two unsigned numbers', () => {
+    expect(multiplyUnsigned(0, 2)).toBe(0);
+    expect(multiplyUnsigned(2, 0)).toBe(0);
+    expect(multiplyUnsigned(1, 1)).toBe(1);
+    expect(multiplyUnsigned(1, 2)).toBe(2);
+    expect(multiplyUnsigned(2, 7)).toBe(14);
+    expect(multiplyUnsigned(7, 2)).toBe(14);
+    expect(multiplyUnsigned(30, 2)).toBe(60);
+    expect(multiplyUnsigned(17, 34)).toBe(578);
+    expect(multiplyUnsigned(170, 2340)).toBe(397800);
+  });
+});

src/algorithms/math/bits/multiply.js

@@ -1,14 +0,0 @@
-/**
- * @param {number, number} 
- * @return {number} 
- */
-export default function multiply(number1, number2) {
-  var c = 0, result = 0; 
-  while(number2){
-    if(number2&1)
-        result += (number1 << c);
-    c += 1;
-    number2 >>= 1;
-  }
-  return result;
-}

src/algorithms/math/bits/multiplyUnsigned.js

@@ -0,0 +1,43 @@
+/**
+ * Multiply to unsigned numbers using bitwise operator.
+ *
+ * The main idea of bitwise multiplication is that every number may be split
+ * to the sum of posers of two:
+ *
+ * I.e. 19 = 2^4 + 2^1 + 2^0
+ *
+ * Then multiplying number x by 19 is equivalent of:
+ *
+ * x * 19 = x * 2^4 + x * 2^1 + x * 2^0
+ *
+ * Now we need to remember that (x * 2^4) is equivalent of shifting x left by 4 bits (x << 4).
+ *
+ * @param {number} number1
+ * @param {number} number2
+ * @return {number}
+ */
+export default function multiplyUnsigned(number1, number2) {
+  let result = 0;
+
+  // Let's treat number2 as a multiplier for the number1.
+  let multiplier = number2;
+
+  // Multiplier current bit index.
+  let bitIndex = 0;
+
+  // Go through all bits of number2.
+  while (multiplier !== 0) {
+    // Check if current multiplier bit is set.
+    if (multiplier & 1) {
+      // In case if multiplier's bit at position bitIndex is set
+      // it would mean that we need to multiply number1 by the power
+      // of bit with index bitIndex and then add it to the result.
+      result += (number1 << bitIndex);
+    }
+
+    bitIndex += 1;
+    multiplier >>= 1;
+  }
+
+  return result;
+}