simple-squiggle

A restricted subset of Squiggle
Log | Files | Refs | README

permutations.js (2701B)

      1 "use strict";
      2 
      3 Object.defineProperty(exports, "__esModule", {
      4   value: true
      5 });
      6 exports.createPermutations = void 0;
      7 
      8 var _number = require("../../utils/number.js");
      9 
     10 var _product = require("../../utils/product.js");
     11 
     12 var _factory = require("../../utils/factory.js");
     13 
     14 var name = 'permutations';
     15 var dependencies = ['typed', 'factorial'];
     16 var createPermutations = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
     17   var typed = _ref.typed,
     18       factorial = _ref.factorial;
     19 
     20   /**
     21    * Compute the number of ways of obtaining an ordered subset of `k` elements
     22    * from a set of `n` elements.
     23    *
     24    * Permutations only takes integer arguments.
     25    * The following condition must be enforced: k <= n.
     26    *
     27    * Syntax:
     28    *
     29    *     math.permutations(n)
     30    *     math.permutations(n, k)
     31    *
     32    * Examples:
     33    *
     34    *    math.permutations(5)     // 120
     35    *    math.permutations(5, 3)  // 60
     36    *
     37    * See also:
     38    *
     39    *    combinations, combinationsWithRep, factorial
     40    *
     41    * @param {number | BigNumber} n   The number of objects in total
     42    * @param {number | BigNumber} [k] The number of objects in the subset
     43    * @return {number | BigNumber}    The number of permutations
     44    */
     45   return typed(name, {
     46     'number | BigNumber': factorial,
     47     'number, number': function numberNumber(n, k) {
     48       if (!(0, _number.isInteger)(n) || n < 0) {
     49         throw new TypeError('Positive integer value expected in function permutations');
     50       }
     51 
     52       if (!(0, _number.isInteger)(k) || k < 0) {
     53         throw new TypeError('Positive integer value expected in function permutations');
     54       }
     55 
     56       if (k > n) {
     57         throw new TypeError('second argument k must be less than or equal to first argument n');
     58       } // Permute n objects, k at a time
     59 
     60 
     61       return (0, _product.product)(n - k + 1, n);
     62     },
     63     'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
     64       var result, i;
     65 
     66       if (!isPositiveInteger(n) || !isPositiveInteger(k)) {
     67         throw new TypeError('Positive integer value expected in function permutations');
     68       }
     69 
     70       if (k.gt(n)) {
     71         throw new TypeError('second argument k must be less than or equal to first argument n');
     72       }
     73 
     74       var one = n.mul(0).add(1);
     75       result = one;
     76 
     77       for (i = n.minus(k).plus(1); i.lte(n); i = i.plus(1)) {
     78         result = result.times(i);
     79       }
     80 
     81       return result;
     82     } // TODO: implement support for collection in permutations
     83 
     84   });
     85 });
     86 /**
     87  * Test whether BigNumber n is a positive integer
     88  * @param {BigNumber} n
     89  * @returns {boolean} isPositiveInteger
     90  */
     91 
     92 exports.createPermutations = createPermutations;
     93 
     94 function isPositiveInteger(n) {
     95   return n.isInteger() && n.gte(0);
     96 }