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

A React UI component Library for quiz interaction types.

import combinations from 'mathjs/lib/function/probability/combinations';
import cot from 'mathjs/lib/function/trigonometry/cot';
import csc from 'mathjs/lib/function/trigonometry/csc';
import divide from 'mathjs/lib/function/arithmetic/divide';
import factorial from 'mathjs/lib/function/probability/factorial';
import log from 'mathjs/lib/function/arithmetic/log';
import log10 from 'mathjs/lib/function/arithmetic/log10';
import permutations from 'mathjs/lib/function/probability/permutations';
import random from 'mathjs/lib/function/probability/random';
import Decimal from 'decimal.js';

/* TRIGONOMETRY */

function cosecFactory(type, config, load, typed) {
  return load(csc);
}
function cotanFactory(type, config, load, typed) {
  return load(cot);
}
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);
  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);
  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);
  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);
}

/* 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) return !cond.isZero() ? success : fail;else return cond ? success : fail;
  };
}

/* LOGARITHMIC */

function lnFactory(type, config, load, typed) {
  return load(log);
}
function logFactory(type, config, load, typed) {
  var logL = load(log);
  var log10L = load(log10);
  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);
  return function (a, b) {
    if (!isFinite(a) || !isFinite(b)) {
      return NaN;
    }
    return divideL(a, b);
  };
}

/* EXPORTS */

export 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
}];