@instructure/quiz-interactions/lib/components/formula/common/additional_functions.js

A React UI component Library for quiz interaction types.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _combinations = _interopRequireDefault(require("mathjs/lib/function/probability/combinations"));
var _cot = _interopRequireDefault(require("mathjs/lib/function/trigonometry/cot"));
var _csc = _interopRequireDefault(require("mathjs/lib/function/trigonometry/csc"));
var _divide = _interopRequireDefault(require("mathjs/lib/function/arithmetic/divide"));
var _factorial = _interopRequireDefault(require("mathjs/lib/function/probability/factorial"));
var _log = _interopRequireDefault(require("mathjs/lib/function/arithmetic/log"));
var _log2 = _interopRequireDefault(require("mathjs/lib/function/arithmetic/log10"));
var _permutations = _interopRequireDefault(require("mathjs/lib/function/probability/permutations"));
var _random = _interopRequireDefault(require("mathjs/lib/function/probability/random"));
var _decimal = _interopRequireDefault(require("decimal.js"));
/* TRIGONOMETRY */

function cosecFactory(type, config, load, typed) {
  return load(_csc["default"]);
}
function cotanFactory(type, config, load, typed) {
  return load(_cot["default"]);
}
function degToRadFactory(type, config, load, typed) {
  return typed('deg_to_rad', {
    number: function number(x) {
      return x * (Math.PI / 180);
    }
  });
}
function radToDegFactory(type, config, load, typed) {
  return typed('rad_to_deg', {
    number: function number(x) {
      return x * (180 / Math.PI);
    }
  });
}

/* PROBABILITY */

function combFactory(type, config, load, typed) {
  var combinationsL = load(_combinations["default"]);
  return typed('fact', {
    'number, number': function number_number(n, k) {
      if (n >= 0 && k >= 0 && n >= k) {
        return combinationsL(n, k);
      } else {
        return NaN;
      }
    }
  });
}
function permFactory(type, config, load, typed) {
  var permutationsL = load(_permutations["default"]);
  return typed('fact', {
    'number, number': function number_number(n, k) {
      if (n >= 0 && k >= 0 && n >= k) {
        return permutationsL(n, k);
      } else {
        return NaN;
      }
    }
  });
}
function factFactory(type, config, load, typed) {
  var factorialL = load(_factorial["default"]);
  return typed('fact', {
    number: function number(x) {
      if (x >= 0) {
        return factorialL(x);
      } else {
        return NaN;
      }
    }
  });
}
function randFactory(type, config, load, typed) {
  return load(_random["default"]);
}

/* LIST FUNCTIONS */

function atFactory(type, config, load, typed) {
  return typed('at', {
    'Array, number': function Array_number(arr, i) {
      return i >= 0 && i < arr.length ? arr[i] : NaN;
    },
    '...number': function number(args) {
      var i = args[args.length - 1];
      return i >= 0 && i < args.length - 1 ? args[i] : NaN;
    }
  });
}
function firstFactory(type, config, load, typed) {
  return typed('first', {
    Array: function Array(arr) {
      return arr[0];
    },
    '...any': function any(args) {
      return args[0];
    }
  });
}
function lastFactory(type, config, load, typed) {
  return typed('last', {
    Array: function Array(arr) {
      return arr[arr.length - 1];
    },
    '...any': function any(args) {
      return args[args.length - 1];
    }
  });
}
function lengthFactory(type, config, load, typed) {
  return typed('length', {
    Array: function Array(arr) {
      return arr.length;
    },
    '...any': function any(args) {
      return args.length;
    }
  });
}
function rangeFactory(type, config, load, typed) {
  // max - min value
  var range = function range(arr) {
    arr.sort(function (a, b) {
      return a - b;
    }); // sort ascending
    return arr[arr.length - 1] - arr[0];
  };
  return typed('range', {
    Array: range,
    '...any': range
  });
}
function reverseFactory(type, config, load, typed) {
  return typed('reverse', {
    Array: function Array(arr) {
      return arr.reverse();
    },
    '...any': function any(args) {
      return args.reverse();
    }
  });
}

/* LOGICAL */

function ifFactory(type, config, load, typed) {
  return function (cond, success, fail) {
    if (cond.constructor == _decimal["default"]) return !cond.isZero() ? success : fail;else return cond ? success : fail;
  };
}

/* LOGARITHMIC */

function lnFactory(type, config, load, typed) {
  return load(_log["default"]);
}
function logFactory(type, config, load, typed) {
  var logL = load(_log["default"]);
  var log10L = load(_log2["default"]);
  return typed('log', {
    any: function any(x) {
      return log10L(x);
    },
    'any, any': function any_any(x, base) {
      return logL(x, base);
    }
  });
}

/* ARITHMETIC */

/* mathjs.divide returns 0 in some cases where we want
   to return NaN. See QUIZ-9824 for more information. */
function divideFactory(type, config, load, typed) {
  var divideL = load(_divide["default"]);
  return function (a, b) {
    if (!isFinite(a) || !isFinite(b)) {
      return NaN;
    }
    return divideL(a, b);
  };
}

/* EXPORTS */
var _default = exports["default"] = [{
  name: 'cosec',
  factory: cosecFactory
}, {
  name: 'cotan',
  factory: cotanFactory
}, {
  name: 'deg_to_rad',
  factory: degToRadFactory
}, {
  name: 'rad_to_deg',
  factory: radToDegFactory
}, {
  name: 'comb',
  factory: combFactory
}, {
  name: 'perm',
  factory: permFactory
}, {
  name: 'fact',
  factory: factFactory
}, {
  name: 'rand',
  factory: randFactory
}, {
  name: 'at',
  factory: atFactory
}, {
  name: 'first',
  factory: firstFactory
}, {
  name: 'last',
  factory: lastFactory
}, {
  name: 'length',
  factory: lengthFactory
}, {
  name: 'range',
  factory: rangeFactory
}, {
  name: 'reverse',
  factory: reverseFactory
}, {
  name: 'if',
  factory: ifFactory
}, {
  name: 'ln',
  factory: lnFactory
}, {
  name: 'log',
  factory: logFactory
}, {
  name: 'divide',
  factory: divideFactory
}];