@instructure/quiz-interactions
Version:
A React UI component Library for quiz interaction types.
241 lines (240 loc) • 6.12 kB
JavaScript
/*
TODO: Update mathjs to newer version that exports as ES modules.
*/ 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(x) {
return x * (Math.PI / 180);
}
});
}
function radToDegFactory(type, config, load, typed) {
return typed('rad_to_deg', {
number: function(x) {
return x * (180 / Math.PI);
}
});
}
/* PROBABILITY */ function combFactory(type, config, load, typed) {
var combinationsL = load(combinations);
return typed('fact', {
'number, number': function(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(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(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(arr, i) {
return i >= 0 && i < arr.length ? arr[i] : NaN;
},
'...number': function(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(arr) {
return arr[0];
},
'...any': function(args) {
return args[0];
}
});
}
function lastFactory(type, config, load, typed) {
return typed('last', {
Array: function(arr) {
return arr[arr.length - 1];
},
'...any': function(args) {
return args[args.length - 1];
}
});
}
function lengthFactory(type, config, load, typed) {
return typed('length', {
Array: function(arr) {
return arr.length;
},
'...any': function(args) {
return args.length;
}
});
}
function rangeFactory(type, config, load, typed) {
// max - min value
var range = function(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(arr) {
return arr.reverse();
},
'...any': function(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(x) {
return log10L(x);
},
'any, any': function(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
}
];