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 _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"));

/* 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 * (180 / Math.PI);
    }
  });
}

function radToDegFactory(type, config, load, typed) {
  return typed('rad_to_deg', {
    number: function number(x) {
      return x * (Math.PI / 180);
    }
  });
}
/* PROBABILITY */


function combFactory(type, config, load, typed) {
  var combinationsL = load(_combinations.default);
  return typed('fact', {
    'number, number': function numberNumber(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 numberNumber(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 ArrayNumber(arr, i) {
      return arr[i];
    },
    '...number': function number(args) {
      var i = args[args.length - 1];

      if (i < args.length - 1) {
        return args[i];
      }
    }
  });
}

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) {
    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 anyAny(x, base) {
      return logL(x, base);
    }
  });
}
/* EXPORTS */


var _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
}];
exports.default = _default;