Make combinationsWithRep.js more efficient (josdejong#1602)

waseemyusuf · josdejong · commit c0e87c4b71d3 · 2019-08-28T15:10:24.000+02:00
* Implemented the `multicombinations` function * Write unit tests for `multicombinations` function * Integrate the `multicombinations` function throughout codebase 1. Include multicombinations factory function in factoriesAny.js and factoriesNumber.js 2. Write embedded docs for multicombinations 3. Added latex support 4. Refer to multicombinations in the "see also"-section of related functions * Change name from `multichoose` to `combinationsWithRep` * Update combinationsWithRep.js Instead of always cancelling `n-1 factorial` from the denominator and ignoring `k factorial`, added a conditional to cancel the the larger of the two, therefore further reducing redundant calculations. * Revert "Update combinationsWithRep.js" This reverts commit efef6d3. * Update combinationsWithRep.js Instead of always cancelling `n-1 factorial` from the denominator and ignoring `k factorial`, added a conditional to cancel the the larger of the two, therefore further reducing redundant calculations. * Add one more test for the case: k > n-1 * Refactor single for-loop into two separate ones
diff --git a/src/function/probability/combinationsWithRep.js b/src/function/probability/combinationsWithRep.js
@@ -41,14 +41,19 @@ export const createCombinationsWithRep = /* #__PURE__ */ factory(name, dependenc
         throw new TypeError('k must be less than or equal to n + k - 1')
       }
 
-      const prodrange = product(n, n + k - 1)
-      return prodrange / product(1, k)
+      if (k < n - 1) {
+        const prodrange = product(n, n + k - 1)
+        return prodrange / product(1, k)
+      }
+      const prodrange = product(k + 1, n + k - 1)
+      return prodrange / product(1, n - 1)
     },
 
     'BigNumber, BigNumber': function (n, k) {
       const BigNumber = n.constructor
       let result, i
       const one = new BigNumber(1)
+      const nMinusOne = n.minus(one)
 
       if (!isPositiveInteger(n) || !isPositiveInteger(k)) {
         throw new TypeError('Positive integer value expected in function combinationsWithRep')
@@ -57,10 +62,15 @@ export const createCombinationsWithRep = /* #__PURE__ */ factory(name, dependenc
         throw new TypeError('k must be less than or equal to n + k - 1 in function combinationsWithRep')
       }
 
-      const max = n.minus(one)
       result = one
-      for (i = one; i.lte(k); i = i.plus(1)) {
-        result = result.times(max.plus(i)).dividedBy(i)
+      if (k.lt(nMinusOne)) {
+        for (i = one; i.lte(nMinusOne); i = i.plus(one)) {
+          result = result.times(k.plus(i)).dividedBy(i)
+        }
+      } else {
+        for (i = one; i.lte(k); i = i.plus(one)) {
+          result = result.times(nMinusOne.plus(i)).dividedBy(i)
+        }
       }
 
       return result
diff --git a/test/unit-tests/function/probability/combinationsWithRep.test.js b/test/unit-tests/function/probability/combinationsWithRep.test.js
@@ -5,13 +5,15 @@ const combinationsWithRep = math.combinationsWithRep
 describe('combinations', function () {
   it('should calculate the combinations of a number taking k at a time', function () {
     assert.strictEqual(combinationsWithRep(7, 5), 462)
+    assert.strictEqual(combinationsWithRep(3, 10), 66)
     assert.strictEqual(combinationsWithRep(8, 33), 18643560)
     assert.strictEqual(combinationsWithRep(63, 7), 1078897248)
     assert.strictEqual(combinationsWithRep(25, 6), 593775)
   })
 
   it('should calculate the combinations of n items taken k at a time with BigNumbers', function () {
     assert.deepStrictEqual(combinationsWithRep(math.bignumber(7), math.bignumber(5)), math.bignumber(462))
+    assert.deepStrictEqual(combinationsWithRep(math.bignumber(3), math.bignumber(10)), math.bignumber(66))
     assert.deepStrictEqual(combinationsWithRep(math.bignumber(8), math.bignumber(33)), math.bignumber(18643560))
     assert.deepStrictEqual(combinationsWithRep(math.bignumber(63), math.bignumber(7)), math.bignumber(1078897248))
     assert.deepStrictEqual(combinationsWithRep(math.bignumber(25), math.bignumber(6)), math.bignumber(593775))
