_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.