_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 52 373k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q52100 | max | train | function max(input) {
if (!Array.isArray(input)) {
throw new Error('input must be an array');
}
if (input.length === 0) {
throw new Error('input must not be empty');
}
var max = input[0];
for (var i = 1; i < input.length; i++) {
if (input[i] > max) max = input[i];
}
return max;
} | javascript | {
"resource": ""
} |
q52101 | min | train | function min(input) {
if (!Array.isArray(input)) {
throw new Error('input must be an array');
}
if (input.length === 0) {
throw new Error('input must not be empty');
}
var min = input[0];
for (var i = 1; i < input.length; i++) {
if (input[i] < min) min = input[i];
}
return min;
} | javascript | {
"resource": ""
} |
q52102 | embed | train | function embed(mat, rows, cols) {
var r = mat.rows;
var c = mat.columns;
if ((r === rows) && (c === cols)) {
return mat;
} else {
var resultat = Matrix.zeros(rows, cols);
resultat = resultat.setSubMatrix(mat, 0, 0);
return resultat;
}
} | javascript | {
"resource": ""
} |
q52103 | mean | train | function mean(input) {
if (!Array.isArray(input)) {
throw new Error('input must be an array');
}
if (input.length === 0) {
throw new Error('input must not be empty');
}
var sum = 0;
for (var i = 0; i < input.length; i++) {
sum += input[i];
}
return sum / input.length;
} | javascript | {
"resource": ""
} |
q52104 | examplesBaggingWithReplacement | train | function examplesBaggingWithReplacement(trainingSet, trainingValue, seed) {
var engine = random.engines.mt19937();
var distribution = random.integer(0, trainingSet.rows - 1);
if (seed === undefined) {
engine = engine.autoSeed();
} else if (Number.isInteger(seed)) {
engine = engine.seed(seed);
} else {
throw new RangeError(`Expected seed must be undefined or integer not ${seed}`);
}
var Xr = new Array(trainingSet.rows);
var yr = new Array(trainingSet.rows);
for (var i = 0; i < trainingSet.rows; ++i) {
var index = distribution(engine);
Xr[i] = trainingSet[index];
yr[i] = trainingValue[index];
}
return {
X: new Matrix$1(Xr),
y: yr
};
} | javascript | {
"resource": ""
} |
q52105 | featureBagging | train | function featureBagging(trainingSet, n, replacement, seed) {
if (trainingSet.columns < n) {
throw new RangeError('N should be less or equal to the number of columns of X');
}
var distribution = random.integer(0, trainingSet.columns - 1);
var engine = random.engines.mt19937();
if (seed === undefined) {
engine = engine.autoSeed();
} else if (Number.isInteger(seed)) {
engine = engine.seed(seed);
} else {
throw new RangeError(`Expected seed must be undefined or integer not ${seed}`);
}
var toRet = new Matrix$1(trainingSet.rows, n);
if (replacement) {
var usedIndex = new Array(n);
for (var i = 0; i < n; ++i) {
var index = distribution(engine);
usedIndex[i] = index;
toRet.setColumn(i, trainingSet.getColumn(index));
}
} else {
usedIndex = new Set();
index = distribution(engine);
for (i = 0; i < n; ++i) {
while (usedIndex.has(index)) {
index = distribution(engine);
}
toRet.setColumn(i, trainingSet.getColumn(index));
usedIndex.add(index);
}
usedIndex = Array.from(usedIndex);
}
return {
X: toRet,
usedIndex: usedIndex
};
} | javascript | {
"resource": ""
} |
q52106 | mode | train | function mode(arr) {
return arr.sort((a, b) =>
arr.filter((v) => v === a).length
- arr.filter((v) => v === b).length
).pop();
} | javascript | {
"resource": ""
} |
q52107 | median | train | function median(input) {
if (!Array.isArray(input)) {
throw new Error('input must be an array');
}
if (input.length === 0) {
throw new Error('input must not be empty');
}
return medianQuickselect_min(input.slice());
} | javascript | {
"resource": ""
} |
q52108 | nearestVector | train | function nearestVector(listVectors, vector, options) {
options = options || defaultOptions$7;
const distanceFunction = options.distanceFunction || defaultOptions$7.distanceFunction;
const similarityFunction = options.similarityFunction || defaultOptions$7.similarityFunction;
const returnVector = options.returnVector || defaultOptions$7.returnVector;
var vectorIndex = -1;
if (typeof similarityFunction === 'function') {
// maximum similarity
var maxSim = Number.MIN_VALUE;
for (var j = 0; j < listVectors.length; j++) {
var sim = similarityFunction(vector, listVectors[j]);
if (sim > maxSim) {
maxSim = sim;
vectorIndex = j;
}
}
} else if (typeof distanceFunction === 'function') {
// minimum distance
var minDist = Number.MAX_VALUE;
for (var i = 0; i < listVectors.length; i++) {
var dist = distanceFunction(vector, listVectors[i]);
if (dist < minDist) {
minDist = dist;
vectorIndex = i;
}
}
} else {
throw new Error('A similarity or distance function it\'s required');
}
if (returnVector) {
return listVectors[vectorIndex];
} else {
return vectorIndex;
}
} | javascript | {
"resource": ""
} |
q52109 | calculateDistanceMatrix | train | function calculateDistanceMatrix(data, distance) {
var distanceMatrix = new Array(data.length);
for (var i = 0; i < data.length; ++i) {
for (var j = i; j < data.length; ++j) {
if (!distanceMatrix[i]) {
distanceMatrix[i] = new Array(data.length);
}
if (!distanceMatrix[j]) {
distanceMatrix[j] = new Array(data.length);
}
const dist = distance(data[i], data[j]);
distanceMatrix[i][j] = dist;
distanceMatrix[j][i] = dist;
}
}
return distanceMatrix;
} | javascript | {
"resource": ""
} |
q52110 | updateClusterID | train | function updateClusterID(data, centers, clusterID, distance) {
for (var i = 0; i < data.length; i++) {
clusterID[i] = src$5(centers, data[i], {distanceFunction: distance});
}
return clusterID;
} | javascript | {
"resource": ""
} |
q52111 | updateCenters | train | function updateCenters(data, clusterID, K) {
const nDim = data[0].length;
// creates empty centers with 0 size
var centers = new Array(K);
var centersLen = new Array(K);
for (var i = 0; i < K; i++) {
centers[i] = new Array(nDim);
centersLen[i] = 0;
for (var j = 0; j < nDim; j++) {
centers[i][j] = 0;
}
}
// add the value for all dimensions of the point
for (var l = 0; l < data.length; l++) {
centersLen[clusterID[l]]++;
for (var dim = 0; dim < nDim; dim++) {
centers[clusterID[l]][dim] += data[l][dim];
}
}
// divides by length
for (var id = 0; id < K; id++) {
for (var d = 0; d < nDim; d++) {
centers[id][d] /= centersLen[id];
}
}
return centers;
} | javascript | {
"resource": ""
} |
q52112 | converged | train | function converged(centers, oldCenters, distanceFunction, tolerance) {
for (var i = 0; i < centers.length; i++) {
if (distanceFunction(centers[i], oldCenters[i]) > tolerance) {
return false;
}
}
return true;
} | javascript | {
"resource": ""
} |
q52113 | clone | train | function clone(arr) {
var newArr = [];
for (var i=0; i<arr.length; i++) {
newArr.push(arr[i]);
}
return newArr;
} | javascript | {
"resource": ""
} |
q52114 | pick | train | function pick() {
if (this._remainingOptions.length === 0) {
this._remainingOptions = clone(this._originalOptions);
}
var index = Math.floor(Math.random() * this._remainingOptions.length);
return this._remainingOptions.splice(index, 1)[0];
} | javascript | {
"resource": ""
} |
q52115 | random$1 | train | function random$1(data, K) {
const rand = new Picker$1(data);
var ans = new Array(K);
for (var i = 0; i < K; ++i) {
ans[i] = rand.pick();
}
return ans;
} | javascript | {
"resource": ""
} |
q52116 | KMeansResult | train | function KMeansResult(clusters, centroids, converged, iterations, distance) {
this.clusters = clusters;
this.centroids = centroids;
this.converged = converged;
this.iterations = iterations;
this[distanceSymbol] = distance;
} | javascript | {
"resource": ""
} |
q52117 | errorCalculation | train | function errorCalculation(
data,
parameters,
parameterizedFunction
) {
var error = 0;
const func = parameterizedFunction(parameters);
for (var i = 0; i < data.x.length; i++) {
error += Math.abs(data.y[i] - func(data.x[i]));
}
return error;
} | javascript | {
"resource": ""
} |
q52118 | gradientFunction | train | function gradientFunction(
data,
evaluatedData,
params,
gradientDifference,
paramFunction
) {
const n = params.length;
const m = data.x.length;
var ans = new Array(n);
for (var param = 0; param < n; param++) {
ans[param] = new Array(m);
var auxParams = params.concat();
auxParams[param] += gradientDifference;
var funcParam = paramFunction(auxParams);
for (var point = 0; point < m; point++) {
ans[param][point] = evaluatedData[point] - funcParam(data.x[point]);
}
}
return new require$$0$2.Matrix(ans);
} | javascript | {
"resource": ""
} |
q52119 | step$1 | train | function step$1(
data,
params,
damping,
gradientDifference,
parameterizedFunction
) {
var identity = require$$0$2.Matrix.eye(params.length).mul(
damping * gradientDifference * gradientDifference
);
var l = data.x.length;
var evaluatedData = new Array(l);
const func = parameterizedFunction(params);
for (var i = 0; i < l; i++) {
evaluatedData[i] = func(data.x[i]);
}
var gradientFunc = gradientFunction(
data,
evaluatedData,
params,
gradientDifference,
parameterizedFunction
);
var matrixFunc = matrixFunction(data, evaluatedData).transposeView();
var inverseMatrix = require$$0$2.inverse(
identity.add(gradientFunc.mmul(gradientFunc.transposeView()))
);
params = new require$$0$2.Matrix([params]);
params = params.sub(
inverseMatrix
.mmul(gradientFunc)
.mmul(matrixFunc)
.mul(gradientDifference)
.transposeView()
);
return params.to1DArray();
} | javascript | {
"resource": ""
} |
q52120 | levenbergMarquardt | train | function levenbergMarquardt(
data,
parameterizedFunction,
options = {}
) {
let {
maxIterations = 100,
gradientDifference = 10e-2,
damping = 0,
errorTolerance = 10e-3,
initialValues
} = options;
if (damping <= 0) {
throw new Error('The damping option must be a positive number');
} else if (!data.x || !data.y) {
throw new Error('The data parameter must have x and y elements');
} else if (
!Array.isArray(data.x) ||
data.x.length < 2 ||
!Array.isArray(data.y) ||
data.y.length < 2
) {
throw new Error(
'The data parameter elements must be an array with more than 2 points'
);
} else {
let dataLen = data.x.length;
if (dataLen !== data.y.length) {
throw new Error('The data parameter elements must have the same size');
}
}
var parameters =
initialValues || new Array(parameterizedFunction.length).fill(1);
if (!Array.isArray(parameters)) {
throw new Error('initialValues must be an array');
}
var error = errorCalculation(data, parameters, parameterizedFunction);
var converged = error <= errorTolerance;
for (
var iteration = 0;
iteration < maxIterations && !converged;
iteration++
) {
parameters = step$1(
data,
parameters,
damping,
gradientDifference,
parameterizedFunction
);
error = errorCalculation(data, parameters, parameterizedFunction);
converged = error <= errorTolerance;
}
return {
parameterValues: parameters,
parameterError: error,
iterations: iteration
};
} | javascript | {
"resource": ""
} |
q52121 | createTree | train | function createTree (X, Y, from, to, minWindow, threshold) {
minWindow = minWindow || 0.16;
threshold = threshold || 0.01;
if ((to - from) < minWindow)
return undefined;
var sum = 0;
for (var i = 0; X[i] < to; i++) {
if (X[i] > from)
sum += Y[i];
}
if (sum < threshold) {
return undefined;
}
var center = 0;
for (var j = 0; X[j] < to; j++) {
if (X[i] > from)
center += X[j] * Y[j];
}
center = center / sum;
if (((center - from) < 10e-6) || ((to - center) < 10e-6)) return undefined;
if ((center - from) < (minWindow /4)) {
return createTree(X, Y, center, to, minWindow, threshold);
}
else {
if ((to - center) < (minWindow / 4)) {
return createTree(X, Y, from, center, minWindow, threshold);
}
else {
return {
'sum': sum,
'center': center,
'left': createTree(X, Y, from, center, minWindow, threshold),
'right': createTree(X, Y, center, to, minWindow, threshold)
};
}
}
} | javascript | {
"resource": ""
} |
q52122 | S | train | function S(a, b, alpha, beta, gamma) {
if (a === undefined || b === undefined) {
return 0;
}
else {
var C = (alpha*Math.min(a.sum, b.sum)/Math.max(a.sum, b.sum)+ (1-alpha)*Math.exp(-gamma*Math.abs(a.center - b.center)));
}
return beta*C + (1-beta)*(S(a.left, b.left, alpha, beta, gamma)+S(a.right, b.right, alpha, beta, gamma));
} | javascript | {
"resource": ""
} |
q52123 | tree | train | function tree(A, B, from, to, options) {
options = options || {};
for (var o in defaultOptions$n)
if (!options.hasOwnProperty(o)) {
options[o] = defaultOptions$n[o];
}
var Atree, Btree;
if (A.sum)
Atree = A;
else
Atree = createTree(A.x, A.y, from, to, options.minWindow, options.threshold);
if (B.sum)
Btree = B;
else
Btree = createTree(B.x, B.y, from, to, options.minWindow, options.threshold);
return S(Atree, Btree, options.alpha, options.beta, options.gamma);
} | javascript | {
"resource": ""
} |
q52124 | matrixCase | train | function matrixCase(data, options) {
var row = data.length;
var col = data[0].length;
if (options.size[0] === undefined)
options.size = [options.size, options.size, options.size, options.size];
throw new Error('matrix not supported yet, sorry');
} | javascript | {
"resource": ""
} |
q52125 | padArray | train | function padArray (data, options) {
options = extend({}, defaultOptions$o, options);
if (Array.isArray(data)) {
if (Array.isArray(data[0]))
return matrixCase(data, options);
else
return arrayCase(data, options);
}
else
throw new TypeError('data should be an array');
} | javascript | {
"resource": ""
} |
q52126 | and | train | function and(arr1, arr2) {
var ans = new Array(arr1.length);
for (var i = 0; i < arr1.length; i++)
ans[i] = arr1[i] & arr2[i];
return ans;
} | javascript | {
"resource": ""
} |
q52127 | or | train | function or(arr1, arr2) {
var ans = new Array(arr1.length);
for (var i = 0; i < arr1.length; i++)
ans[i] = arr1[i] | arr2[i];
return ans;
} | javascript | {
"resource": ""
} |
q52128 | xor | train | function xor(arr1, arr2) {
var ans = new Array(arr1.length);
for (var i = 0; i < arr1.length; i++)
ans[i] = arr1[i] ^ arr2[i];
return ans;
} | javascript | {
"resource": ""
} |
q52129 | not | train | function not(arr) {
var ans = new Array(arr.length);
for (var i = 0; i < ans.length; i++)
ans[i] = ~arr[i];
return ans;
} | javascript | {
"resource": ""
} |
q52130 | getBit | train | function getBit(arr, n) {
var index = n >> 5; // Same as Math.floor(n/32)
var mask = 1 << (31 - n % 32);
return Boolean(arr[index] & mask);
} | javascript | {
"resource": ""
} |
q52131 | setBit | train | function setBit(arr, n, val) {
var index = n >> 5; // Same as Math.floor(n/32)
var mask = 1 << (31 - n % 32);
if (val)
arr[index] = mask | arr[index];
else
arr[index] = ~mask & arr[index];
return arr;
} | javascript | {
"resource": ""
} |
q52132 | toBinaryString | train | function toBinaryString(arr) {
var str = '';
for (var i = 0; i < arr.length; i++) {
var obj = (arr[i] >>> 0).toString(2);
str += '00000000000000000000000000000000'.substr(obj.length) + obj;
}
return str;
} | javascript | {
"resource": ""
} |
q52133 | parseBinaryString | train | function parseBinaryString(str) {
var len = str.length / 32;
var ans = new Array(len);
for (var i = 0; i < len; i++) {
ans[i] = parseInt(str.substr(i*32, 32), 2) | 0;
}
return ans;
} | javascript | {
"resource": ""
} |
q52134 | toHexString | train | function toHexString(arr) {
var str = '';
for (var i = 0; i < arr.length; i++) {
var obj = (arr[i] >>> 0).toString(16);
str += '00000000'.substr(obj.length) + obj;
}
return str;
} | javascript | {
"resource": ""
} |
q52135 | toDebug | train | function toDebug(arr) {
var binary = toBinaryString(arr);
var str = '';
for (var i = 0; i < arr.length; i++) {
str += '0000'.substr((i * 32).toString(16).length) + (i * 32).toString(16) + ':';
for (var j = 0; j < 32; j += 4) {
str += ' ' + binary.substr(i * 32 + j, 4);
}
if (i < arr.length - 1) str += '\n';
}
return str
} | javascript | {
"resource": ""
} |
q52136 | transpose | train | function transpose(matrix) {
var resultMatrix = new Array(matrix[0].length);
for (var i = 0; i < resultMatrix.length; ++i) {
resultMatrix[i] = new Array(matrix.length);
}
for (i = 0; i < matrix.length; ++i) {
for (var j = 0; j < matrix[0].length; ++j) {
resultMatrix[j][i] = matrix[i][j];
}
}
return resultMatrix;
} | javascript | {
"resource": ""
} |
q52137 | applyDotProduct | train | function applyDotProduct(firstVector, secondVector) {
var largestVector, smallestVector;
if (firstVector.length <= secondVector.length) {
smallestVector = firstVector;
largestVector = secondVector;
} else {
smallestVector = secondVector;
largestVector = firstVector;
}
var difference = largestVector.length - smallestVector.length + 1;
var dotProductApplied = new Array(difference);
for (var i = 0; i < difference; ++i) {
var sum = 0;
for (var j = 0; j < smallestVector.length; ++j) {
sum += smallestVector[j] * largestVector[i + j];
}
dotProductApplied[i] = sum;
}
return dotProductApplied;
} | javascript | {
"resource": ""
} |
q52138 | getEquallySpacedSmooth | train | function getEquallySpacedSmooth(x, y, from, to, numberOfPoints) {
var xLength = x.length;
var step = (to - from) / (numberOfPoints - 1);
var halfStep = step / 2;
var output = new Array(numberOfPoints);
var initialOriginalStep = x[1] - x[0];
var lastOriginalStep = x[xLength - 1] - x[xLength - 2];
// Init main variables
var min = from - halfStep;
var max = from + halfStep;
var previousX = Number.MIN_VALUE;
var previousY = 0;
var nextX = x[0] - initialOriginalStep;
var nextY = 0;
var currentValue = 0;
var slope = 0;
var intercept = 0;
var sumAtMin = 0;
var sumAtMax = 0;
var i = 0; // index of input
var j = 0; // index of output
function getSlope(x0, y0, x1, y1) {
return (y1 - y0) / (x1 - x0);
}
main: while (true) {
if (previousX <= min && min <= nextX) {
add = integral(0, min - previousX, slope, previousY);
sumAtMin = currentValue + add;
}
while (nextX - max >= 0) {
// no overlap with original point, just consume current value
var add = integral(0, max - previousX, slope, previousY);
sumAtMax = currentValue + add;
output[j++] = (sumAtMax - sumAtMin) / step;
if (j === numberOfPoints) {
break main;
}
min = max;
max += step;
sumAtMin = sumAtMax;
}
currentValue += integral(previousX, nextX, slope, intercept);
previousX = nextX;
previousY = nextY;
if (i < xLength) {
nextX = x[i];
nextY = y[i];
i++;
} else if (i === xLength) {
nextX += lastOriginalStep;
nextY = 0;
}
slope = getSlope(previousX, previousY, nextX, nextY);
intercept = -slope * previousX + previousY;
}
return output;
} | javascript | {
"resource": ""
} |
q52139 | getEquallySpacedSlot | train | function getEquallySpacedSlot(x, y, from, to, numberOfPoints) {
var xLength = x.length;
var step = (to - from) / (numberOfPoints - 1);
var halfStep = step / 2;
var lastStep = x[x.length - 1] - x[x.length - 2];
var start = from - halfStep;
var output = new Array(numberOfPoints);
// Init main variables
var min = start;
var max = start + step;
var previousX = -Number.MAX_VALUE;
var previousY = 0;
var nextX = x[0];
var nextY = y[0];
var frontOutsideSpectra = 0;
var backOutsideSpectra = true;
var currentValue = 0;
// for slot algorithm
var currentPoints = 0;
var i = 1; // index of input
var j = 0; // index of output
main: while (true) {
if (previousX >= nextX) throw (new Error('x must be an increasing serie'));
while (previousX - max > 0) {
// no overlap with original point, just consume current value
if (backOutsideSpectra) {
currentPoints++;
backOutsideSpectra = false;
}
output[j] = currentPoints <= 0 ? 0 : currentValue / currentPoints;
j++;
if (j === numberOfPoints) {
break main;
}
min = max;
max += step;
currentValue = 0;
currentPoints = 0;
}
if (previousX > min) {
currentValue += previousY;
currentPoints++;
}
if (previousX === -Number.MAX_VALUE || frontOutsideSpectra > 1) {
currentPoints--;
}
previousX = nextX;
previousY = nextY;
if (i < xLength) {
nextX = x[i];
nextY = y[i];
i++;
} else {
nextX += lastStep;
nextY = 0;
frontOutsideSpectra++;
}
}
return output;
} | javascript | {
"resource": ""
} |
q52140 | integral | train | function integral(x0, x1, slope, intercept) {
return (0.5 * slope * x1 * x1 + intercept * x1) - (0.5 * slope * x0 * x0 + intercept * x0);
} | javascript | {
"resource": ""
} |
q52141 | baseRange$1 | train | function baseRange$1(start, end, step, fromRight) {
var index = -1,
length = nativeMax$1(nativeCeil$1((end - start) / (step || 1)), 0),
result = Array(length);
while (length--) {
result[fromRight ? length : ++index] = start;
start += step;
}
return result;
} | javascript | {
"resource": ""
} |
q52142 | coefficientOfCorrelation | train | function coefficientOfCorrelation(actuals = [], estimates = []) {
if (actuals.length !== estimates.length) throw new RangeError('arrays must have the same length');
const sumX = sum(actuals);
const sumY = sum(estimates);
const sumProdXY = actuals.reduce((result, val, index) => {
result = result + (actuals[ index ] * estimates[ index ]);
return result;
}, 0);
const sumXSquared = actuals.reduce((result, val) => {
result = result + (val * val);
return result;
}, 0);
const sumYSquared = estimates.reduce((result, val) => {
result = result + (val * val);
return result;
}, 0);
const N = actuals.length;
const R = (
(N * sumProdXY - sumX * sumY) /
Math.sqrt(
(N * sumXSquared - Math.pow(sumX, 2)) * (N * sumYSquared - Math.pow(sumY, 2))
)
);
return R;
} | javascript | {
"resource": ""
} |
q52143 | pivotVector | train | function pivotVector(vectors=[]) {
return vectors.reduce((result, val, index/*, arr*/) => {
val.forEach((vecVal, i) => {
(index === 0)
? (result.push([vecVal, ]))
: (result[ i ].push(vecVal));
});
return result;
}, []);
} | javascript | {
"resource": ""
} |
q52144 | pivotArrays | train | function pivotArrays(arrays = []) {
return (arrays.length)
? arrays[ 0 ].map((vectorItem, index) => {
const returnArray = [];
arrays.forEach((v, i) => {
returnArray.push(arrays[ i ][ index ]);
});
return returnArray;
})
: arrays;
} | javascript | {
"resource": ""
} |
q52145 | MinMaxScalerTransforms | train | function MinMaxScalerTransforms(vector = [], nan_value = -1, return_nan=false) {
const average = avg$2(vector);
const standard_dev = sd(vector);
const maximum = max$1(vector);
const minimum = min$1(vector);
const scale = (z) => {
const scaledValue = (z - average) / (maximum - minimum);
if (isNaN(scaledValue) && return_nan) return scaledValue;
else if (isNaN(scaledValue) && return_nan === false) return (isNaN(standard_dev)) ? z : standard_dev;
else return scaledValue;
}; // equivalent to MinMaxScaler(z)
const descale = (scaledZ) => {
const descaledValue = (scaledZ * (maximum - minimum)) + average;
if (isNaN(descaledValue) && return_nan) return descaledValue;
else if (isNaN(descaledValue) && return_nan === false) return (isNaN(standard_dev)) ? scaledZ : standard_dev;
else return descaledValue;
};
const values = vector.map(scale)
.map(val => {
if (isNaN(val)) return nan_value;
else return val;
});
return {
components: {
average,
standard_dev,
maximum,
minimum,
},
scale,
descale,
values,
};
} | javascript | {
"resource": ""
} |
q52146 | approximateZPercentile | train | function approximateZPercentile(z, alpha=true) {
// If z is greater than 6.5 standard deviations from the mean
// the number of significant digits will be outside of a reasonable
// range.
if (z < -6.5)
return 0.0;
if (z > 6.5)
return 1.0;
let factK = 1;
let sum = 0;
let term = 1;
let k = 0;
let loopStop = Math.exp(-23);
while (Math.abs(term) > loopStop) {
term = 0.3989422804 * Math.pow(-1, k) * Math.pow(z, k) / (2 * k + 1) /
Math.pow(2, k) * Math.pow(z, k + 1) / factK;
sum += term;
k++;
factK *= k;
}
sum += 0.5;
return (alpha) ? 1 - sum : sum;
} | javascript | {
"resource": ""
} |
q52147 | trackingSignal | train | function trackingSignal(actuals, estimates) {
const runningSumOfForecastErrors = sum(forecastErrors(actuals, estimates));
const MAD = meanAbsoluteDeviation(actuals, estimates);
return runningSumOfForecastErrors / MAD;
} | javascript | {
"resource": ""
} |
q52148 | FPNode | train | function FPNode(item, parent) {
if (item === void 0) { item = null; }
if (parent === void 0) { parent = null; }
this.item = item;
this.parent = parent;
/**
* Support of the FPNode. (a.k.a. "count" as defined by Han).
*/
this.support = 1;
/**
* nextSameItemNode (a.k.a. "Node-link" as defined by Han):
* Links to the next node in the FP-tree carrying the same
* item, or null if there is none.
*/
this.nextSameItemNode = null;
/**
* PUBLIC READONLY. Children of the FPNode in an array. Empty array if there is none.
*/
this._children = [];
} | javascript | {
"resource": ""
} |
q52149 | FPTree | train | function FPTree(supports, _support) {
this.supports = supports;
this._support = _support;
/**
* Whether or not the tree has been built
*/
this._isInit = false;
/**
* Root node of the FPTree
*/
this.root = new fpnode.FPNode();
/**
* All first nodes (of different items) inserted in the FPTree (Heads of node-links).
*/
this._firstInserted = {};
/**
* All last nodes (of different items) inserted in the FPTree (Foots of node-links).
*/
this._lastInserted = {};
} | javascript | {
"resource": ""
} |
q52150 | train | function(len) {
if(len === undefined) len=16;
var entropy = fs.randomBytes(len);
var result = 0;
for(var i=0; i<len; i++) {
result = result + Number(entropy[i])/Math.pow(256,(i+1));
}
return result
} | javascript | {
"resource": ""
} | |
q52151 | train | function(n, loc, scale) {
n = this._v(n, "n");
loc = this._v(loc, "r", 0);
scale = this._v(scale, "nn", 1);
var toReturn = [];
for(var i=0; i<n; i++) {
var core = this.sample([-1,1])[0] * ln(this.prng());
var x = loc - scale * core;
toReturn[i] = x;
}
return toReturn
} | javascript | {
"resource": ""
} | |
q52152 | train | function(x, min, max) {
x = this._v(x, "r");
min = this._v(min, "r", 0);
max = this._v(max, "r", 1);
if(min > max) throw new Error("Minimum value cannot be greater than maximum value");
if(x < min || x > max) return 0;
if(min === max) return Infinity;
return 1/(max-min);
} | javascript | {
"resource": ""
} | |
q52153 | train | function(len, alphabet) {
len = this._v(len, "n");
alphabet = this._v(alphabet, "str", "abcdefghijklmnopqrstuvwxyz");
var lib = alphabet.split("");
var arr = this.sample(lib, len, true);
return arr.join("");
} | javascript | {
"resource": ""
} | |
q52154 | flip | train | function flip(obj) {
var newObj = Object.create(null),
key;
for (key in obj) {
newObj[obj[key]] = key;
}
return newObj;
} | javascript | {
"resource": ""
} |
q52155 | merge | train | function merge(var_args) {
var args = [].slice.call(arguments),
newObj = Object.create(null),
id = 0, key;
while (args[id]) {
for (key in args[id]) {
newObj[key] = args[id][key];
}
id++;
}
return newObj;
} | javascript | {
"resource": ""
} |
q52156 | stemmingProcess | train | function stemmingProcess(){
if(find(current_word))
return
// Confix Stripping
// Try to remove prefixes first before suffixes if the specification is met
if(precedenceAdjustmentSpecification(original_word)){
// Step 4, 5
removePrefixes();
if(find(current_word))
return
// Step 2, 3
removeSuffixes();
if(find(current_word)){
return
}
else{
// if the trial is failed, restore the original word
// and continue to normal rule precedence (suffix first, prefix afterwards)
current_word = original_word;
removals = [];
}
}
// Step 2, 3
removeSuffixes();
if(find(current_word))
return
// Step 4, 5
removePrefixes();
if(find(current_word))
return
//ECS Loop Restore Prefixes
loopRestorePrefixes();
} | javascript | {
"resource": ""
} |
q52157 | createPredicateIndexFinder | train | function createPredicateIndexFinder(dir) {
return function(array, predicate, context) {
predicate = cb(predicate, context);
var length = getLength(array);
var index = dir > 0 ? 0 : length - 1;
for (; index >= 0 && index < length; index += dir) {
if (predicate(array[index], index, array)) return index;
}
return -1;
};
} | javascript | {
"resource": ""
} |
q52158 | train | function(sourceFunc, boundFunc, context, callingContext, args) {
if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
var self = baseCreate(sourceFunc.prototype);
var result = sourceFunc.apply(self, args);
if (_.isObject(result)) return result;
return self;
} | javascript | {
"resource": ""
} | |
q52159 | svdJs | train | function svdJs() {
var A = this;
var V = Matrix$b.I(A.rows());
var S = A.transpose();
var U = Matrix$b.I(A.cols());
var err = Number.MAX_VALUE;
var i = 0;
var maxLoop = 100;
while(err > 2.2737e-13 && i < maxLoop) {
var qr = S.transpose().qrJs();
S = qr.R;
V = V.x(qr.Q);
qr = S.transpose().qrJs();
U = U.x(qr.Q);
S = qr.R;
var e = S.triu(1).unroll().norm();
var f = S.diagonal().norm();
if(f == 0)
f = 1;
err = e / f;
i++;
}
var ss = S.diagonal();
var s = [];
for(var i = 1; i <= ss.cols(); i++) {
var ssn = ss.e(i);
s.push(Math.abs(ssn));
if(ssn < 0) {
for(var j = 0; j < U.rows(); j++) {
V.elements[j][i - 1] = -(V.elements[j][i - 1]);
}
}
}
return {U: U, S: $V(s).toDiagonalMatrix(), V: V};
} | javascript | {
"resource": ""
} |
q52160 | svdPack | train | function svdPack() {
var result = lapack$1.sgesvd('A', 'A', this.elements);
return {
U: $M(result.U),
S: $M(result.S).column(1).toDiagonalMatrix(),
V: $M(result.VT).transpose()
};
} | javascript | {
"resource": ""
} |
q52161 | qrJs | train | function qrJs() {
var m = this.rows();
var n = this.cols();
var Q = Matrix$b.I(m);
var A = this;
for(var k = 1; k < Math.min(m, n); k++) {
var ak = A.slice(k, 0, k, k).col(1);
var oneZero = [1];
while(oneZero.length <= m - k)
oneZero.push(0);
oneZero = $V(oneZero);
var vk = ak.add(oneZero.x(ak.norm() * Math.sign(ak.e(1))));
var Vk = $M(vk);
var Hk = Matrix$b.I(m - k + 1).subtract(Vk.x(2).x(Vk.transpose()).div(Vk.transpose().x(Vk).e(1, 1)));
var Qk = identSize(Hk, m, n, k);
A = Qk.x(A);
// slow way to compute Q
Q = Q.x(Qk);
}
return {Q: Q, R: A};
} | javascript | {
"resource": ""
} |
q52162 | qrPack | train | function qrPack() {
var qr = lapack$1.qr(this.elements);
return {
Q: $M(qr.Q),
R: $M(qr.R)
};
} | javascript | {
"resource": ""
} |
q52163 | train | function(k, U) {
var U = U || pca$1(this).U;
var Ureduce= U.slice(1, U.rows(), 1, k);
return {Z: this.x(Ureduce), U: U};
} | javascript | {
"resource": ""
} | |
q52164 | train | function(U) {
var k = this.cols();
var Ureduce = U.slice(1, U.rows(), 1, k);
return this.x(Ureduce.transpose());
} | javascript | {
"resource": ""
} | |
q52165 | train | function(k) {
if(!k)
k = 0;
return this.map(function(x, i, j) {
return j - i >= k ? x : 0;
});
} | javascript | {
"resource": ""
} | |
q52166 | train | function() {
var v = [];
for(var i = 1; i <= this.cols(); i++) {
for(var j = 1; j <= this.rows(); j++) {
v.push(this.e(j, i));
}
}
return $V(v);
} | javascript | {
"resource": ""
} | |
q52167 | train | function(startRow, endRow, startCol, endCol) {
var x = [];
if(endRow == 0)
endRow = this.rows();
if(endCol == 0)
endCol = this.cols();
for(i = startRow; i <= endRow; i++) {
var row = [];
for(j = startCol; j <= endCol; j++) {
row.push(this.e(i, j));
}
x.push(row);
}
return $M(x);
} | javascript | {
"resource": ""
} | |
q52168 | train | function(matrix) {
if(typeof(matrix) == 'number') {
return this.map(function(x, i, j) { return x + matrix});
} else {
var M = matrix.elements || matrix;
if (typeof(M[0][0]) == 'undefined') { M = Matrix$b.create(M).elements; }
if (!this.isSameSizeAs(M)) { return null; }
return this.map(function(x, i, j) { return x + M[i - 1][j - 1]; });
}
} | javascript | {
"resource": ""
} | |
q52169 | train | function() {
var dim = this.dimensions();
var r = [];
for (var i = 1; i <= dim.cols; i++) {
r.push(this.col(i).sum() / dim.rows);
}
return $V(r);
} | javascript | {
"resource": ""
} | |
q52170 | train | function() {
var matrix_rows = [];
var n = this.elements.length;
for (var i = 0; i < n; i++) {
matrix_rows.push(this.elements[i]);
}
return matrix_rows;
} | javascript | {
"resource": ""
} | |
q52171 | train | function() {
var maxes = [];
for(var i = 1; i <= this.rows(); i++) {
var max = null;
var maxIndex = -1;
for(var j = 1; j <= this.cols(); j++) {
if(max === null || this.e(i, j) > max) {
max = this.e(i, j);
maxIndex = j;
}
}
maxes.push(maxIndex);
}
return $V(maxes);
} | javascript | {
"resource": ""
} | |
q52172 | train | function() {
var mins = [];
for(var i = 1; i <= this.rows(); i++) {
var min = null;
var minIndex = -1;
for(var j = 1; j <= this.cols(); j++) {
if(min === null || this.e(i, j) < min) {
min = this.e(i, j);
minIndex = j;
}
}
mins.push(minIndex);
}
return $V(mins);
} | javascript | {
"resource": ""
} | |
q52173 | train | function(k, j, P, A, L) {
var maxIndex = 0;
var maxValue = 0;
for(var i = k; i <= A.rows(); i++) {
if(Math.abs(A.e(i, j)) > maxValue) {
maxValue = Math.abs(A.e(k, j));
maxIndex = i;
}
}
if(maxIndex != k) {
var tmp = A.elements[k - 1];
A.elements[k - 1] = A.elements[maxIndex - 1];
A.elements[maxIndex - 1] = tmp;
P.elements[k - 1][k - 1] = 0;
P.elements[k - 1][maxIndex - 1] = 1;
P.elements[maxIndex - 1][maxIndex - 1] = 0;
P.elements[maxIndex - 1][k - 1] = 1;
}
return P;
} | javascript | {
"resource": ""
} | |
q52174 | luPack | train | function luPack() {
var lu = lapack$1.lu(this.elements);
return {
L: $M(lu.L),
U: $M(lu.U),
P: $M(lu.P)
// don't pass back IPIV
};
} | javascript | {
"resource": ""
} |
q52175 | luJs | train | function luJs() {
var A = this.dup();
var L = Matrix$b.I(A.rows());
var P = Matrix$b.I(A.rows());
var U = Matrix$b.Zeros(A.rows(), A.cols());
var p = 1;
for(var k = 1; k <= Math.min(A.cols(), A.rows()); k++) {
P = A.partialPivot(k, p, P, A, L);
for(var i = k + 1; i <= A.rows(); i++) {
var l = A.e(i, p) / A.e(k, p);
L.elements[i - 1][k - 1] = l;
for(var j = k + 1 ; j <= A.cols(); j++) {
A.elements[i - 1][j - 1] -= A.e(k, j) * l;
}
}
for(var j = k; j <= A.cols(); j++) {
U.elements[k - 1][j - 1] = A.e(k, j);
}
if(p < A.cols())
p++;
}
return {L: L, U: U, P: P};
} | javascript | {
"resource": ""
} |
q52176 | train | function(fn) {
var elements = [];
this.each(function(x, i) {
elements.push(fn(x, i));
});
return Vector.create(elements);
} | javascript | {
"resource": ""
} | |
q52177 | train | function(vector) {
var angle = this.angleFrom(vector);
return (angle === null) ? null : (Math.abs(angle - Math.PI) <= sylvester.precision);
} | javascript | {
"resource": ""
} | |
q52178 | train | function(v) {
if (typeof(v) == 'number')
return this.map(function(k) { return k - v; });
var V = v.elements || v;
if (this.elements.length != V.length) { return null; }
return this.map(function(x, i) { return x - V[i - 1]; });
} | javascript | {
"resource": ""
} | |
q52179 | train | function(vector) {
var B = vector.elements || vector;
if (this.elements.length != 3 || B.length != 3) { return null; }
var A = this.elements;
return Vector.create([
(A[1] * B[2]) - (A[2] * B[1]),
(A[2] * B[0]) - (A[0] * B[2]),
(A[0] * B[1]) - (A[1] * B[0])
]);
} | javascript | {
"resource": ""
} | |
q52180 | train | function(x) {
var index = null, n = this.elements.length;
for (var i = 0; i < n; i++) {
if (index === null && this.elements[i] == x) {
index = i + 1;
}
}
return index;
} | javascript | {
"resource": ""
} | |
q52181 | train | function() {
var rows = this.elements.length;
var elements = [];
for (var i = 0; i < rows; i++) {
elements.push([this.elements[i]]);
}
return matrix$2.create(elements);
} | javascript | {
"resource": ""
} | |
q52182 | train | function(t, obj) {
var V, R = null, x, y, z;
if (t.determinant) { R = t.elements; }
switch (this.elements.length) {
case 2:
V = obj.elements || obj;
if (V.length != 2) { return null; }
if (!R) { R = matrix$2.Rotation(t).elements; }
x = this.elements[0] - V[0];
y = this.elements[1] - V[1];
return Vector.create([
V[0] + R[0][0] * x + R[0][1] * y,
V[1] + R[1][0] * x + R[1][1] * y
]);
break;
case 3:
if (!obj.direction) { return null; }
var C = obj.pointClosestTo(this).elements;
if (!R) { R = matrix$2.Rotation(t, obj.direction).elements; }
x = this.elements[0] - C[0];
y = this.elements[1] - C[1];
z = this.elements[2] - C[2];
return Vector.create([
C[0] + R[0][0] * x + R[0][1] * y + R[0][2] * z,
C[1] + R[1][0] * x + R[1][1] * y + R[1][2] * z,
C[2] + R[2][0] * x + R[2][1] * y + R[2][2] * z
]);
break;
default:
return null;
}
} | javascript | {
"resource": ""
} | |
q52183 | train | function() {
var V = this.dup();
switch (V.elements.length) {
case 3: break;
case 2: V.elements.push(0); break;
default: return null;
}
return V;
} | javascript | {
"resource": ""
} | |
q52184 | train | function(obj) {
var theta;
if (obj.normal) {
// obj is a plane
theta = this.normal.angleFrom(obj.normal);
return (Math.abs(theta) <= sylvester.precision || Math.abs(Math.PI - theta) <= sylvester.precision);
} else if (obj.direction) {
// obj is a line
return this.normal.isPerpendicularTo(obj.direction);
}
return null;
} | javascript | {
"resource": ""
} | |
q52185 | train | function(plane) {
var theta = this.normal.angleFrom(plane.normal);
return (Math.abs(Math.PI/2 - theta) <= sylvester.precision);
} | javascript | {
"resource": ""
} | |
q52186 | train | function(obj) {
if (obj.normal) { return null; }
if (obj.direction) {
return (this.contains(obj.anchor) && this.contains(obj.anchor.add(obj.direction)));
} else {
var P = obj.elements || obj;
var A = this.anchor.elements, N = this.normal.elements;
var diff = Math.abs(N[0]*(A[0] - P[0]) + N[1]*(A[1] - P[1]) + N[2]*(A[2] - (P[2] || 0)));
return (diff <= sylvester.precision);
}
} | javascript | {
"resource": ""
} | |
q52187 | train | function(point) {
var P = point.elements || point;
var A = this.anchor.elements, N = this.normal.elements;
var dot = (A[0] - P[0]) * N[0] + (A[1] - P[1]) * N[1] + (A[2] - (P[2] || 0)) * N[2];
return vector.create([P[0] + N[0] * dot, P[1] + N[1] * dot, (P[2] || 0) + N[2] * dot]);
} | javascript | {
"resource": ""
} | |
q52188 | train | function(obj) {
if (obj.normal) {
// obj is a plane
var A = this.anchor.elements, N = this.normal.elements;
var A1 = A[0], A2 = A[1], A3 = A[2], N1 = N[0], N2 = N[1], N3 = N[2];
var newA = this.anchor.reflectionIn(obj).elements;
// Add the plane's normal to its anchor, then mirror that in the other plane
var AN1 = A1 + N1, AN2 = A2 + N2, AN3 = A3 + N3;
var Q = obj.pointClosestTo([AN1, AN2, AN3]).elements;
var newN = [Q[0] + (Q[0] - AN1) - newA[0], Q[1] + (Q[1] - AN2) - newA[1], Q[2] + (Q[2] - AN3) - newA[2]];
return Plane$1.create(newA, newN);
} else if (obj.direction) {
// obj is a line
return this.rotate(Math.PI, obj);
} else {
// obj is a point
var P = obj.elements || obj;
return Plane$1.create(this.anchor.reflectionIn([P[0], P[1], (P[2] || 0)]), this.normal);
}
} | javascript | {
"resource": ""
} | |
q52189 | train | function(anchor, v1, v2) {
anchor = vector.create(anchor);
anchor = anchor.to3D(); if (anchor === null) { return null; }
v1 = vector.create(v1);
v1 = v1.to3D(); if (v1 === null) { return null; }
if (typeof(v2) == 'undefined') {
v2 = null;
} else {
v2 = vector.create(v2);
v2 = v2.to3D(); if (v2 === null) { return null; }
}
var A1 = anchor.elements[0], A2 = anchor.elements[1], A3 = anchor.elements[2];
var v11 = v1.elements[0], v12 = v1.elements[1], v13 = v1.elements[2];
var normal, mod;
if (v2 !== null) {
var v21 = v2.elements[0], v22 = v2.elements[1], v23 = v2.elements[2];
normal = vector.create([
(v12 - A2) * (v23 - A3) - (v13 - A3) * (v22 - A2),
(v13 - A3) * (v21 - A1) - (v11 - A1) * (v23 - A3),
(v11 - A1) * (v22 - A2) - (v12 - A2) * (v21 - A1)
]);
mod = normal.modulus();
if (mod === 0) { return null; }
normal = vector.create([normal.elements[0] / mod, normal.elements[1] / mod, normal.elements[2] / mod]);
} else {
mod = Math.sqrt(v11*v11 + v12*v12 + v13*v13);
if (mod === 0) { return null; }
normal = vector.create([v1.elements[0] / mod, v1.elements[1] / mod, v1.elements[2] / mod]);
}
this.anchor = anchor;
this.normal = normal;
return this;
} | javascript | {
"resource": ""
} | |
q52190 | train | function(obj) {
if (obj.start && obj.end) { return this.contains(obj.start) && this.contains(obj.end); }
var dist = this.distanceFrom(obj);
return (dist !== null && dist <= sylvester.precision);
} | javascript | {
"resource": ""
} | |
q52191 | train | function(point) {
if (!this.contains(point)) { return null; }
var P = point.elements || point;
var A = this.anchor.elements, D = this.direction.elements;
return (P[0] - A[0]) * D[0] + (P[1] - A[1]) * D[1] + ((P[2] || 0) - A[2]) * D[2];
} | javascript | {
"resource": ""
} | |
q52192 | train | function(obj) {
if (obj.normal || (obj.start && obj.end)) { return obj.intersectionWith(this); }
if (!this.intersects(obj)) { return null; }
var P = this.anchor.elements, X = this.direction.elements,
Q = obj.anchor.elements, Y = obj.direction.elements;
var X1 = X[0], X2 = X[1], X3 = X[2], Y1 = Y[0], Y2 = Y[1], Y3 = Y[2];
var PsubQ1 = P[0] - Q[0], PsubQ2 = P[1] - Q[1], PsubQ3 = P[2] - Q[2];
var XdotQsubP = - X1*PsubQ1 - X2*PsubQ2 - X3*PsubQ3;
var YdotPsubQ = Y1*PsubQ1 + Y2*PsubQ2 + Y3*PsubQ3;
var XdotX = X1*X1 + X2*X2 + X3*X3;
var YdotY = Y1*Y1 + Y2*Y2 + Y3*Y3;
var XdotY = X1*Y1 + X2*Y2 + X3*Y3;
var k = (XdotQsubP * YdotY / XdotX + XdotY * YdotPsubQ) / (YdotY - XdotY * XdotY);
return vector.create([P[0] + k*X1, P[1] + k*X2, P[2] + k*X3]);
} | javascript | {
"resource": ""
} | |
q52193 | train | function(segment) {
return (this.start.eql(segment.start) && this.end.eql(segment.end)) ||
(this.start.eql(segment.end) && this.end.eql(segment.start));
} | javascript | {
"resource": ""
} | |
q52194 | train | function() {
var A = this.start.elements, B = this.end.elements;
var C1 = B[0] - A[0], C2 = B[1] - A[1], C3 = B[2] - A[2];
return Math.sqrt(C1*C1 + C2*C2 + C3*C3);
} | javascript | {
"resource": ""
} | |
q52195 | train | function() {
var A = this.start.elements, B = this.end.elements;
return vector.create([B[0] - A[0], B[1] - A[1], B[2] - A[2]]);
} | javascript | {
"resource": ""
} | |
q52196 | train | function(obj) {
var P = this.pointClosestTo(obj);
return (P === null) ? null : P.distanceFrom(obj);
} | javascript | {
"resource": ""
} | |
q52197 | train | function(obj) {
if (obj.start && obj.end) { return this.contains(obj.start) && this.contains(obj.end); }
var P = (obj.elements || obj).slice();
if (P.length == 2) { P.push(0); }
if (this.start.eql(P)) { return true; }
var S = this.start.elements;
var V = vector.create([S[0] - P[0], S[1] - P[1], S[2] - (P[2] || 0)]);
var vect = this.toVector();
return V.isAntiparallelTo(vect) && V.modulus() <= vect.modulus();
} | javascript | {
"resource": ""
} | |
q52198 | train | function(obj) {
if (!this.line.intersects(obj)) { return null; }
var P = this.line.intersectionWith(obj);
return (this.contains(P) ? P : null);
} | javascript | {
"resource": ""
} | |
q52199 | train | function(obj) {
if (obj.normal) {
// obj is a plane
var V = this.line.intersectionWith(obj);
if (V === null) { return null; }
return this.pointClosestTo(V);
} else {
// obj is a line (segment) or point
var P = this.line.pointClosestTo(obj);
if (P === null) { return null; }
if (this.contains(P)) { return P; }
return (this.line.positionOf(P) < 0 ? this.start : this.end).dup();
}
} | javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.