_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q3300
|
train
|
function() {
var me = this;
var connectionOptions = me._connectionOptions;
return promised(function(cb) {
if (me.isConnected || me.status === 'connecting') {
return cb(new Error('Broker client already connected or connecting.'));
}
if (!me.mqttClient) {
var mqttClient = new PahoMQTT.Client(
connectionOptions.host,
connectionOptions.port,
connectionOptions.path,
connectionOptions.clientId
);
_registerPahoClientEventListeners(me, mqttClient);
me.mqttClient = mqttClient;
}
me.status = 'connecting';
me.emit('connecting');
me.mqttClient.connect(
merge(_getPahoCallbacks(cb),
|
javascript
|
{
"resource": ""
}
|
|
q3301
|
train
|
function(args) {
var mqttClient = this.mqttClient;
return promised(function(cb)
|
javascript
|
{
"resource": ""
}
|
|
q3302
|
train
|
function(args) {
var mqttClient = this.mqttClient;
return promised(function(cb)
|
javascript
|
{
"resource": ""
}
|
|
q3303
|
train
|
function(event, handler) {
return events.on({
listeners: this._listeners,
event:
|
javascript
|
{
"resource": ""
}
|
|
q3304
|
train
|
function(event, handler) {
return events.off({
listeners: this._listeners,
|
javascript
|
{
"resource": ""
}
|
|
q3305
|
train
|
function(event, data) {
return events.emit({
listeners: this._listeners,
|
javascript
|
{
"resource": ""
}
|
|
q3306
|
autoSubscribe
|
train
|
function autoSubscribe(args) {
var rtm = args.rtm;
var listSubscriptions = args.listSubscriptions;
var filterFn = args.filterFn || _autoSubscribeDefaultFilterFn;
var subscriptionLoadLimit = 50;
_observeSubscriptionSyncEvents({
rtm: rtm,
filterFn: filterFn
});
return listSubscriptions({limit: subscriptionLoadLimit}).then(function(list) {
return _fetchAllReadSubscriptions({
list: list,
loadMore: listSubscriptions,
batchSize: subscriptionLoadLimit
}).then(function(fetchedSubscriptions) {
var subscriptions = Array.prototype.concat.apply(
[],
fetchedSubscriptions
);
return Promise.all(subscriptions.map(filterFn)).then(function(
filterResults
) {
|
javascript
|
{
"resource": ""
}
|
q3307
|
_observeSubscriptionSyncEvents
|
train
|
function _observeSubscriptionSyncEvents(args) {
var rtm = args.rtm;
var filterFn = args.filterFn;
rtm.on('subscription-created', function(subscription) {
if (subscription.allowRead !== true) return;
filterFn(subscription).then(function(ok) {
if (ok) {
rtm.subscribe({channel: subscription.channelId});
}
});
});
rtm.on('subscription-deleted', function(subscription) {
rtm.unsubscribe({channel: subscription.channelId});
});
rtm.on('subscription-updated', function(subscription) {
|
javascript
|
{
"resource": ""
}
|
q3308
|
createApiError
|
train
|
function createApiError(options) {
return {
name: options.name || 'ApiError',
message: options.message,
status: options.status || 500,
details: options.details,
code: options.code || options.status || 500,
|
javascript
|
{
"resource": ""
}
|
q3309
|
train
|
function(args) {
var baseUrl = this.baseUrl + this.basePath;
var authToken = this.authToken;
var qs = this._buildQueryString(args.params);
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.onreadystatechange = function() {
if (req.readyState === 4) {
try {
var response = JSON.parse(req.responseText);
var status = req.status;
if (status >= 200 && status < 400) {
return resolve(
addShadowProperty({
target: response,
property: 'httpRequest',
value: req
})
);
}
return reject(
createApiError(
|
javascript
|
{
"resource": ""
}
|
|
q3310
|
checkValue
|
train
|
function checkValue(config, res, key, trueVal, falseVal) {
res[key]
|
javascript
|
{
"resource": ""
}
|
q3311
|
checkPlugins
|
train
|
function checkPlugins(pugs) {
var def_pugs_obj = {};
for(var i = 0;i < def_pugs_lst.length;i++)
def_pugs_obj[def_pugs_lst[i]] = {'name': def_pugs_lst[i], 'enable': true};
var _t = [];
for(var i = 0;i < pugs.length;i++) {
if(!(pugs[i] instanceof Object) || !(pugs[i].plugin instanceof Object)) continue;
|
javascript
|
{
"resource": ""
}
|
q3312
|
train
|
function (behavior, attr, define) {
var prop;
var defaultProp;
if (define) {
prop = define[attr];
defaultProp = define["*"];
if (prop && prop[behavior] !== undefined) {
return prop[behavior];
}
|
javascript
|
{
"resource": ""
}
|
|
q3313
|
fromNobleUuid
|
train
|
function fromNobleUuid(uuid) {
if (uuid.length !== 32) return uuid;
return (
uuid.substring(0, 8) +
'-' +
uuid.substring(8, 12) +
'-' +
uuid.substring(12,
|
javascript
|
{
"resource": ""
}
|
q3314
|
removeComplete
|
train
|
function removeComplete(regex, lines, start) {
var matches = lines[start].match(regex);
var i = 0;
var s = lines[start];
matches = s.match(regex);
while (!matches) {
i++;
|
javascript
|
{
"resource": ""
}
|
q3315
|
parseThresholds
|
train
|
function parseThresholds(thresholds = 0) {
let result = thresholds;
if (!Array.isArray(thresholds)) {
result = [thresholds];
} else if (!thresholds.length) {
result = [0];
}
return result.map(threshold => {
// We use Number function instead of parseFloat
// to convert boolean values and null to theirs
// numeric representation. This is done to act
// in the same manner as a native implementation.
threshold = Number(threshold);
if (!window.isFinite(threshold)) {
|
javascript
|
{
"resource": ""
}
|
q3316
|
train
|
function() {
return (
( (!!this.pulse1.lengthCounter) << 0 ) |
( (!!this.pulse2.lengthCounter) <<
|
javascript
|
{
"resource": ""
}
|
|
q3317
|
train
|
function( address, value ) {
if ( address < 0x4 ) {
// pulse 1 registers
this.pulse1.writeRegister( address, value );
} else if ( address < 0x8 ) {
// pulse 2 registers
this.pulse2.writeRegister( address - 0x4, value );
} else if ( address < 0xc ) {
// triangle registers
this.triangle.writeRegister( address - 0x8, value );
} else if ( address < 0x10 ) {
// noise registers
this.noise.writeRegister( address - 0xc, value );
} else if ( address < 0x14 ) {
// DMC registers
this.dmc.writeRegister( address - 0x10, value );
} else if ( address === 0x15 ) {
// enabling / disabling channels
this.writeStatus( value );
} else if ( address === 0x17 ) {
// set framecounter mode
this.frameCounterMode = +!!(value & 0x80);
this.frameCounterInterrupt = !( value & 0x40 );
this.cycles = 0;
|
javascript
|
{
"resource": ""
}
|
|
q3318
|
train
|
function() {
switch( this.cycles ) {
case 3728:
case 7457:
case 11186:
case 14915:
this.doQuarterFrame();
break;
}
switch( this.cycles ) {
case 7457:
case 14915:
this.doHalfFrame();
break;
|
javascript
|
{
"resource": ""
}
|
|
q3319
|
train
|
function() {
var tndOut = 0, // triangle, noise, dmc
pulseOut = 0;
this.pulse1.doTimer();
this.pulse2.doTimer();
this.triangle.doTimer();
this.noise.doTimer();
this.dmc.doTimer();
if ( this.output.enabled ) {
// no need to do calculations if output
|
javascript
|
{
"resource": ""
}
|
|
q3320
|
train
|
function( filename, autorun ) {
var self = this;
utils.readFile( filename, function( data ) {
self.initCartridge( data );
if ( typeof autorun === "function" ) {
|
javascript
|
{
"resource": ""
}
|
|
q3321
|
train
|
function() {
if ( this.interval ) {
// once is enough
return;
}
var self = this;
this.interval = setInterval( function() {
if ( !self.paused) {
self.runFrame();
}
|
javascript
|
{
"resource": ""
}
|
|
q3322
|
doADC
|
train
|
function doADC( value ) {
var t = A + value + flagC;
flagV = !!((A ^ t) & (value ^ t) & 0x80) && 1;
flagN = !!( t & 0x80 );
flagC
|
javascript
|
{
"resource": ""
}
|
q3323
|
branch
|
train
|
function branch( flag ) {
var offset = read(),
prevHigh = PC & HIGH,
curHigh = 0;
if ( flag ) {
// branching burns a cycle
burn(1);
if ( offset & 0x80 ) {
offset = -complement( offset );
}
PC += offset;
curHigh =
|
javascript
|
{
"resource": ""
}
|
q3324
|
xCMP
|
train
|
function xCMP( value ) {
var readValue = read(),
t = ( value - readValue )
|
javascript
|
{
"resource": ""
}
|
q3325
|
peekWord
|
train
|
function peekWord( index ) {
var low = peek( index ),
high = peek( (index +
|
javascript
|
{
"resource": ""
}
|
q3326
|
setFlags
|
train
|
function setFlags() {
flagN = !!( P & 0x80 );
flagV = !!( P & 0x40 );
flagB = !!( P & 0x10 );
flagD = !!( P & 0x08 );
flagI =
|
javascript
|
{
"resource": ""
}
|
q3327
|
train
|
function( value ) {
this.output.setGrayscale( value & 0x1 );
this.output.setIntensity( value & 0x20, value & 0x40, value & 0x80 );
this.sprites.toggle( value & 0x10 );
this.sprites.toggleLeft( value & 0x4 );
this.background.toggle( value & 0x8
|
javascript
|
{
"resource": ""
}
|
|
q3328
|
train
|
function( value ) {
var nametableFlag = value & 0x3,
incrementFlag = value & 0x4,
spriteFlag = value & 0x8,
backgroundFlag = value & 0x10,
sizeFlag = value & 0x20,
nmiFlag = value & 0x80;
this.background.setNameTable( nametableFlag );
this.increment = incrementFlag ? 32 : 1;
this.sprites.baseTable = spriteFlag ? 0x1000
|
javascript
|
{
"resource": ""
}
|
|
q3329
|
train
|
function() {
var sprites = this.sprites,
background = this.background;
if ( this.inRenderScanline ) {
if ( this.enabled ) {
background.evaluate();
sprites.evaluate();
}
if ( this.pixelInRange ) {
if (
this.pixelInRange &&
sprites.sprite0InRange &&
sprites.scanlineSprite0[ this.lineCycle - 1 ] &&
|
javascript
|
{
"resource": ""
}
|
|
q3330
|
debounce
|
train
|
function debounce(callback, delay = 0) {
let timeoutID = false;
return function (...args) {
if (timeoutID !== false) {
clearTimeout(timeoutID);
}
timeoutID = setTimeout(() =>
|
javascript
|
{
"resource": ""
}
|
q3331
|
train
|
function() {
var i, j, item, controls,
config = this.config = this.system.config.input;
for ( i = 0; i < config.length; i++ ) {
item = config[ i ];
this.setController( i, item.type );
controls = item.controls;
if ( !Array.isArray(controls) ) {
|
javascript
|
{
"resource": ""
}
|
|
q3332
|
train
|
function( index, type, config ) {
var currentHandler,
InputHandler = inputHandlerMap[ type ],
controller = this.controllers.get( index );
this.initInputHandlers( index );
currentHandler = this.inputHandlers[ index ][ type ];
if ( currentHandler ) {
currentHandler.disable();
|
javascript
|
{
"resource": ""
}
|
|
q3333
|
train
|
function() {
var cartridge = this.memory.cartridge,
attrAddress = attrAddresses[ this.loopyV ],
attribute = cartridge.readNameTable( attrAddress & 0x1fff ),
nametableAddress = 0x2000 | ( this.loopyV & 0x0fff ),
tileIndex = cartridge.readNameTable( nametableAddress & 0x1fff ),
tile = cartridge.readTile( this.baseTable,
|
javascript
|
{
"resource": ""
}
|
|
q3334
|
initAttrAddresses
|
train
|
function initAttrAddresses() {
var i,
result = new Uint16Array( 0x8000 );
for ( i = 0; i < 0x8000; i++ ) {
result[ i ] = 0x23c0 | (i
|
javascript
|
{
"resource": ""
}
|
q3335
|
initMasks
|
train
|
function initMasks() {
var i, mask,
result = new Uint8Array( 0x10000 );
for ( i = 0; i < 0x10000; i++ ) {
mask = 3;
if ( i & 0x2 ) {
// right
mask <<= 2;
}
if ( i &
|
javascript
|
{
"resource": ""
}
|
q3336
|
initTileCycles
|
train
|
function initTileCycles() {
var i,
result = new Uint8Array( 400 );
for ( i = 7; i < 256; i += 8 ) {
result[ i ] = 1;
|
javascript
|
{
"resource": ""
}
|
q3337
|
train
|
function() {
var spriteIndex = this.currentSprite << 2,
y = this.oam2[ spriteIndex ],
tileIndex = this.oam2[ spriteIndex + 1 ],
attributes = this.oam2[ spriteIndex + 2 ],
x = this.oam2[ spriteIndex + 3 ],
baseTable = this.baseTable,
tile = 0,
flipX = attributes & 0x40,
flipY = 0,
fineY = 0;
flipY = attributes & 0x80;
fineY = ( this.ppu.scanline - y ) & ( this.spriteSize - 1 );
// (the '& spriteSize' is needed because fineY can overflow due
// to uninitialized tiles in secondary OAM)
if ( this.spriteSize === 16 ) {
// big sprite, select proper nametable and handle flipping
baseTable = ( tileIndex & 1 ) ? 0x1000 : 0;
tileIndex = tileIndex & ~1;
if ( fineY > 7 ) {
fineY -=
|
javascript
|
{
"resource": ""
}
|
|
q3338
|
train
|
function( sample ) {
this.bufferData[ this.bufferIndex++ ] = sample;
if ( this.bufferIndex === this.bufferLength ) {
this.bufferIndex = 0;
if ( this.playing ) {
this.playing.stop();
|
javascript
|
{
"resource": ""
}
|
|
q3339
|
train
|
function() {
this.context = new AudioContext();
this.sampleRate = this.context.sampleRate;
this.gainNode =
|
javascript
|
{
"resource": ""
}
|
|
q3340
|
train
|
function() {
this.buffer = this.context.createBuffer(1, this.bufferLength, this.context.sampleRate);
this.bufferData = this.buffer.getChannelData( 0 );
this.bufferSource
|
javascript
|
{
"resource": ""
}
|
|
q3341
|
isDetached
|
train
|
function isDetached(container, target) {
const docElement = document.documentElement;
return (
container !== docElement
|
javascript
|
{
"resource": ""
}
|
q3342
|
computeIntersection
|
train
|
function computeIntersection(rootRect, targetRect) {
const left = Math.max(targetRect.left, rootRect.left);
const right = Math.min(targetRect.right, rootRect.right);
const top = Math.max(targetRect.top, rootRect.top);
|
javascript
|
{
"resource": ""
}
|
q3343
|
getIntersection
|
train
|
function getIntersection(container, target, containterRect, targetRect) {
let intersecRect = targetRect,
parent = target.parentNode,
rootReached = false;
while (!rootReached) {
let parentRect = null;
if (parent === container || parent.nodeType !== 1)
|
javascript
|
{
"resource": ""
}
|
q3344
|
train
|
function() {
if ( !( this.header[0] === 0x4e && // 'N'
this.header[1] === 0x45 && // 'E'
this.header[2] === 0x53 && // 'S'
this.header[3] === 0x1a // ending character
)) {
throw new Error("Invalid ROM!");
}
if ( this.header[7] & 0xe ) {
throw new Error("Bit 1-3 of byte 7
|
javascript
|
{
"resource": ""
}
|
|
q3345
|
train
|
function() {
var flags6 = this.header[6];
this.mirroring = ( flags6 & 0x1 ) ? VERTICAL : HORIZONTAL;
this.battery = ( flags6 & 0x2 );
this.trainer = ( flags6 & 0x4 );
this.mirroring = ( flags6 & 0x8 ) ? FOUR_SCREEN : this.mirroring;
|
javascript
|
{
"resource": ""
}
|
|
q3346
|
train
|
function() {
this.prgRead = new Uint8Array( 0x8000 );
this.prgRead.set( this.prgData.subarray( 0,
|
javascript
|
{
"resource": ""
}
|
|
q3347
|
train
|
function( address, value ) {
if ( address & 0x8000 ) {
this.writeRegister( address, value );
} else if ( address >= 0x6000 ) {
// writing
|
javascript
|
{
"resource": ""
}
|
|
q3348
|
train
|
function( address, bank, size ) {
var offset = bank * size,
bankData
|
javascript
|
{
"resource": ""
}
|
|
q3349
|
train
|
function( address, bank, size ) {
var offset = bank * size,
bankData = this.chrData.subarray( offset, offset
|
javascript
|
{
"resource": ""
}
|
|
q3350
|
train
|
function( address ) {
switch( this.mirroring ) {
case HORIZONTAL:
if ( address >= 0x400 ) {
address -= 0x400;
}
if ( address >= 0x800 ) {
address -= 0x400;
}
break;
case VERTICAL:
address &= 0x07ff;
|
javascript
|
{
"resource": ""
}
|
|
q3351
|
train
|
function() {
this.width = 256;
this.height = 224;
this.data = new Uint8Array( this.width * this.height * 4 );
for ( var i = 0; i < this.data.length; i++ ) {
this.data[ i ] = 0xff;
}
|
javascript
|
{
"resource": ""
}
|
|
q3352
|
train
|
function() {
var color = 0,
i = 0,
address = 0,
view = palette,
buffer = new ArrayBuffer( 0xc0 ),
splitPalette = new Uint8Array( buffer );
// first, re-arrange RGB values in a single array (first reds, then blues, then greens)
for ( color = 0; color
|
javascript
|
{
"resource": ""
}
|
|
q3353
|
train
|
function( background, sprites, priorities ) {
this.bgBuffer.set( background, this.index );
this.spriteBuffer.set( sprites, this.index );
|
javascript
|
{
"resource": ""
}
|
|
q3354
|
train
|
function() {
if ( !this.force2D && WebGLRenderer.isSupported( this.el ) ) {
this.renderer = new WebGLRenderer( this.el );
} else if ( Canvas2DRenderer.isSupported( this.el ) ) {
this.renderer = new
|
javascript
|
{
"resource": ""
}
|
|
q3355
|
train
|
function() {
var gl = this.gl;
var buffer = this.buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.bufferData(
gl.ARRAY_BUFFER,
new Float32Array([
-1.0, -1.0,
|
javascript
|
{
"resource": ""
}
|
|
q3356
|
train
|
function() {
var gl = this.gl,
program = this.program;
// initialize pixel textures
this.bgTexture = createTexture( 0, "bgTexture" );
this.spriteTexture = createTexture( 1, "spriteTexture" );
this.prioTexture = createTexture( 2, "prioTexture" );
// initialize palette texture
this.paletteTexture = createTexture( 3, "paletteTexture" );
gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 64, 1, 0, gl.RGB, gl.UNSIGNED_BYTE, palette );
function createTexture( index, name ) {
var texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER,
|
javascript
|
{
"resource": ""
}
|
|
q3357
|
train
|
function() {
var gl = this.gl;
var fragmentShaderSource = [
"precision mediump float;",
"uniform sampler2D bgTexture;",
"uniform sampler2D spriteTexture;",
"uniform sampler2D prioTexture;",
"uniform sampler2D paletteTexture;",
"uniform vec4 bgColor;",
"varying vec2 texCoord;",
"void main(void) {",
"float bgIndex = texture2D(bgTexture, texCoord).r;",
"float spriteIndex = texture2D(spriteTexture, texCoord).r;",
"float prioIndex = texture2D(prioTexture, texCoord).r;",
"float colorIndex = ((spriteIndex > 0.0 && (prioIndex == 0.0 || bgIndex == 0.0)) ? spriteIndex : bgIndex);",
"vec4 color = texture2D(paletteTexture, vec2( colorIndex * 4.0 + 0.0078, 0.5));", // 0.0078 == ( 0.5 * 3 /
|
javascript
|
{
"resource": ""
}
|
|
q3358
|
train
|
function() {
var gl = this.gl;
var program = gl.createProgram();
gl.attachShader( program, this.vertexShader );
gl.attachShader( program, this.fragmentShader );
|
javascript
|
{
"resource": ""
}
|
|
q3359
|
update
|
train
|
function update(sessionId, info) {
sessionIdCache[sessionId] = info;
db.collection('trackedUsersCache').update({
_id: sessionId,
}, { $set: {
info: info,
}}, {
|
javascript
|
{
"resource": ""
}
|
q3360
|
has
|
train
|
function has(id, cb) {
// Do we have it in the local cache?
if (sessionIdCache[id]) {
cb(true);
}
// Looking in the database
else {
db.collection('trackedUsersCache').find({
_id: id
})
.toArray((err, docs) => {
|
javascript
|
{
"resource": ""
}
|
q3361
|
get
|
train
|
function get(sessionId, cb) {
has(sessionId, (hasId) => {
if (hasId) {
|
javascript
|
{
"resource": ""
}
|
q3362
|
toObjectOrUndefined
|
train
|
function toObjectOrUndefined(input) {
let object = input;
if (typeof input === 'string') {
try {
object = JSON.parse(input);
}
catch (e) {}
|
javascript
|
{
"resource": ""
}
|
q3363
|
toArrayOrUndefined
|
train
|
function toArrayOrUndefined(str) {
if (validation.isArray(str) && str.length < 1) {
return undefined;
}
try {
let parsedArray = str;
if (typeof str !== 'object') {
parsedArray = JSON.parse(str);
}
if (validation.isArray(parsedArray)
|
javascript
|
{
"resource": ""
}
|
q3364
|
fromExtra
|
train
|
function fromExtra(value, type) {
const t = (type + '').toLowerCase();
switch (t) {
case 'number':
return toNumberOrUndefined(value);
break;
case 'boolean':
return toTrueOrUndefined(value);
break;
case 'objectarray':
return toObjectArrayOrUndefined(value);
break;
case 'date':
return toDate(value);
break;
|
javascript
|
{
"resource": ""
}
|
q3365
|
augment
|
train
|
function augment(_opts) {
var opts = _opts || {};
|
javascript
|
{
"resource": ""
}
|
q3366
|
cluster
|
train
|
function cluster(points) {
// number of clusters has to be smaller or equal the number of data points
if (points.length < k) {
throw 'Too many clusters';
}
// create the initial clusters
var clusters = chooseInitialCenters(points);
// create an array containing the latest assignment of a point to a cluster
// no need to initialize the array, as it will be filled with the first assignment
var assignments = new Int32Array(points.length);
assignPointsToClusters(clusters, points, assignments);
// iterate through updating the centers until we're done
var max = (maxIterations < 0) ? Number.MAX_VALUE : maxIterations;
for (var
|
javascript
|
{
"resource": ""
}
|
q3367
|
chooseInitialCenters
|
train
|
function chooseInitialCenters(points) {
// Convert to list for indexed access. Make it unmodifiable, since removal of items
// would screw up the logic of this method.
var pointList = points;
// The number of points in the list.
var numPoints = pointList.length;
// Set the corresponding element in this array to indicate when
// elements of pointList are no longer available.
var taken = new Array(numPoints);
for (var i = 0; i < taken.length; i++) {
taken[i] = false;
}
// The resulting list of initial centers.
var resultSet = [];
// Choose one center uniformly at random from among the data points.
var firstPointIndex = nextInt(numPoints);
var firstPoint = pointList[firstPointIndex];
resultSet.push(new CentroidCluster(firstPoint));
// Must mark it as taken
taken[firstPointIndex] = true;
// To keep track of the minimum distance squared of elements of
// pointList to elements of resultSet.
var minDistSquared = new Float32Array(numPoints);
// Initialize the elements. Since the only point in resultSet is firstPoint,
// this is very easy.
for (var i = 0; i < numPoints; i++) {
if (i !== firstPointIndex) { // That point isn't considered
var d = distance(firstPoint, pointList[i]);
minDistSquared[i] = d * d;
}
}
while (resultSet.length < k) {
// Sum up the squared distances for the points in pointList not
// already taken.
var distSqSum = 0.0;
for (var i = 0; i < numPoints; i++) {
if (!taken[i]) {
distSqSum += minDistSquared[i];
}
}
// Add one new data point as a center. Each point x is chosen with
// probability proportional to D(x)2
var r = nextDouble() * distSqSum;
// The index of the next point to be added to the resultSet.
var nextPointIndex = -1;
// Sum through the squared min distances again, stopping when
// sum >= r.
var sum = 0.0;
for (var i = 0; i < numPoints; i++) {
if (!taken[i]) {
sum += minDistSquared[i];
if (sum >= r) {
nextPointIndex = i;
break;
}
|
javascript
|
{
"resource": ""
}
|
q3368
|
centroidOf
|
train
|
function centroidOf(points, dimension) {
var centroid = new Float32Array(dimension);
for (var i = 0; i < centroid.length; i++) {
var sum = 0;
var count = 0;
for (var pointIndex = 0; pointIndex < points.length; pointIndex++) {
var p = points[pointIndex];
var point = p.getPoint();
var val
|
javascript
|
{
"resource": ""
}
|
q3369
|
createPicker
|
train
|
function createPicker() {
if (pickerApiLoaded && oauthToken) {
var picker = new google.picker.PickerBuilder().addView(google.picker.ViewId.DOCS)
.setOAuthToken(oauthToken)
.setDeveloperKey(developerKey)
.setCallback(pickerCallback)
.build();
|
javascript
|
{
"resource": ""
}
|
q3370
|
train
|
function (evtStr, handler) {
if (!handler) {
throw Error('Handler not specified');
}
if (!this.eventListeners) {
this.eventListeners = {};
}
var events = evtStr.split(' '), len = events.length, n, event, parts, baseEvent, name;
/*
* loop through types and attach event listeners to each one. eg. 'click
* mouseover.namespace mouseout' will create three event bindings
*/
for (n = 0; n < len; n++) {
event = events[n];
parts = event.split('.');
baseEvent = parts[0];
name = parts[1] || '';
|
javascript
|
{
"resource": ""
}
|
|
q3371
|
train
|
function (evtStr, handler) {
if (!this.eventListeners) {
this.eventListeners = {};
}
var events = (evtStr || '').split(' '), len = events.length, n, t, event, parts, baseEvent, name;
if (!evtStr) {
// remove all events
for (t in this.eventListeners) {
this._off(t, null, handler);
}
}
for (n = 0; n < len; n++) {
event = events[n];
parts = event.split('.');
baseEvent = parts[0];
name = parts[1];
if (baseEvent) {
|
javascript
|
{
"resource": ""
}
|
|
q3372
|
train
|
function (dataset, heatMap, isColumns, sets, setSourceFileName) {
var promptTool = {};
var _this = this;
promptTool.execute = function (options) {
var metadataName = options.input.dataset_field_name;
var vector = _this.annotateSets(dataset, isColumns, sets,
metadataName, setSourceFileName);
heatMap.getProject().trigger('trackChanged', {
vectors: [vector],
display: ['text'],
columns: isColumns
});
};
promptTool.toString = function () {
return 'Select Fields To Match On';
};
promptTool.gui = function () {
|
javascript
|
{
"resource": ""
}
|
|
q3373
|
train
|
function (mode) {
this._togglingInfoWindow = true;
this.options.tooltipMode = mode;
this.$tipInfoWindow.html('');
this.toolbar.$tip.html('');
this.$tipFollow.html('').css({
display: 'none'
|
javascript
|
{
"resource": ""
}
|
|
q3374
|
train
|
function (e) {
clipboardData.forEach(function (elem) {
e.clipboardData.setData(elem.format, elem.data);
});
e.preventDefault();
e.stopPropagation();
|
javascript
|
{
"resource": ""
}
|
|
q3375
|
train
|
function (lines) {
var regex = /[ ,]+/;
// header= <num_data> <num_classes> 1
var header = lines[0].split(regex);
if (header.length < 3) {
throw new Error('Header line needs three numbers');
}
var headerNumbers = [];
try {
for (var i = 0; i < 3; i++) {
headerNumbers[i] = parseInt($.trim(header[i]));
}
}
catch (e) {
throw new Error('Header line element ' + i + ' is not a number');
}
if (headerNumbers[0] <= 0) {
throw new Error(
'Header line missing first number, number of data points');
}
if (headerNumbers[1] <= 0) {
throw new Error(
'Header line missing second number, number of classes');
}
var numClasses = headerNumbers[1];
var numItems = headerNumbers[0];
var classDefinitionLine = lines[1];
classDefinitionLine = classDefinitionLine.substring(classDefinitionLine
.indexOf('#') + 1);
|
javascript
|
{
"resource": ""
}
|
|
q3376
|
train
|
function () {
var rowCounts = new Uint32Array(nrows);
var columnCounts = new Uint32Array(ncols);
for (var i = 0; i < nrows; i++) {
var obj = matrix[i];
if (obj.values != null) {
// trim to size
var values = new Uint16Array(obj.length);
var indices = new Uint32Array(obj.length);
values.set(obj.values.slice(0, obj.length));
indices.set(obj.indices.slice(0, obj.length));
matrix[i] = {values: values, indices: indices};
rowCounts[i] = values.length;
for (var j = 0; j < obj.length; j++) {
columnCounts[indices[j]] += 1;
|
javascript
|
{
"resource": ""
}
|
|
q3377
|
train
|
function (seriesIndex) {
this.seriesArrays.splice(seriesIndex, 1);
|
javascript
|
{
"resource": ""
}
|
|
q3378
|
train
|
function (newDatasetMetadataNames,
currentDatasetMetadataNames, heatMap, callback) {
var tool = {};
tool.execute = function (options) {
return options.input;
};
tool.toString = function () {
return 'Select Fields';
};
tool.gui = function () {
var items = [
{
name: 'current_dataset_annotation_name',
options: currentDatasetMetadataNames,
type: 'select',
value: 'id',
required: true
|
javascript
|
{
"resource": ""
}
|
|
q3379
|
train
|
function () {
var items = [];
for (var i = 0, length = this.getFilteredItemCount(); i < length; i++) {
|
javascript
|
{
"resource": ""
}
|
|
q3380
|
train
|
function( obj ){
// read the interaction data
var data = $.data( this, drag.datakey ),
// read any passed options
opts = obj.data || {};
// count another realted event
data.related += 1;
// extend data options bound with this event
// don't iterate "opts" in case it is a node
|
javascript
|
{
"resource": ""
}
|
|
q3381
|
train
|
function(){
// check for related events
if ( $.data( this, drag.datakey ) )
return;
// initialize the drag data with copied defaults
var data = $.extend({ related:0 }, drag.defaults );
// store the interaction data
$.data( this, drag.datakey, data );
// bind the mousedown event, which starts drag interactions
|
javascript
|
{
"resource": ""
}
|
|
q3382
|
train
|
function(){
var data = $.data( this, drag.datakey ) || {};
// check for related events
if ( data.related )
return;
// remove the stored data
$.removeData( this, drag.datakey );
// remove the mousedown event
$event.remove( this, "touchstart mousedown", drag.init );
// enable text selection
|
javascript
|
{
"resource": ""
}
|
|
q3383
|
train
|
function( event ){
// sorry, only one touch at a time
if ( drag.touched )
return;
// the drag/drop interaction data
var dd = event.data, results;
// check the which directive
if ( event.which != 0 && dd.which > 0 && event.which != dd.which )
return;
// check for suppressed selector
if ( $( event.target ).is( dd.not ) )
return;
// check for handle selector
if ( dd.handle && !$( event.target ).closest( dd.handle, event.currentTarget ).length )
return;
drag.touched = event.type == 'touchstart' ? this : null;
dd.propagates = 1;
dd.mousedown = this;
dd.interactions = [ drag.interaction( this, dd ) ];
dd.target = event.target;
dd.pageX = event.pageX;
dd.pageY = event.pageY;
dd.dragging = null;
// handle draginit event...
results = drag.hijack( event, "draginit", dd );
// early cancel
if ( !dd.propagates )
return;
// flatten the result set
results = drag.flatten( results );
// insert new interaction elements
if ( results && results.length ){
dd.interactions = [];
$.each( results, function(){
|
javascript
|
{
"resource": ""
}
|
|
q3384
|
train
|
function( elem, dd ){
var offset = (elem && elem.ownerDocument)
? $( elem )[ dd.relative ? "position" : "offset" ]() || { top:0, left:0 }
: { top: 0, left: 0 };
return {
drag: elem,
|
javascript
|
{
"resource": ""
}
|
|
q3385
|
train
|
function( event, type, dd, x, elem ){
// not configured
if ( !dd )
return;
// remember the original event and type
var orig = { event:event.originalEvent, type:event.type },
// is the event drag related or drog related?
mode = type.indexOf("drop") ? "drag" : "drop",
// iteration vars
result, i = x || 0, ia, $elems, callback,
len = !isNaN( x ) ? x : dd.interactions.length;
// modify the event type
event.type = type;
// protects originalEvent from side-effects
var noop = function(){};
event.originalEvent = new jQuery.Event(orig.event, {
preventDefault: noop,
stopPropagation: noop,
stopImmediatePropagation: noop
});
// initialize the results
dd.results = [];
// handle each interacted element
do if ( ia = dd.interactions[ i ] ){
// validate the interaction
if ( type !== "dragend" && ia.cancelled )
continue;
// set the dragdrop properties on the event object
callback = drag.properties( event, dd, ia );
// prepare for more results
ia.results = [];
// handle each element
$( elem || ia[ mode ] || dd.droppable ).each(function( p, subject ){
// identify drag or drop targets individually
callback.target = subject;
// force propagtion of the custom event
event.isPropagationStopped = function(){ return false; };
// handle the event
result = subject ? $event.dispatch.call( subject, event, callback ) : null;
// stop the drag interaction for this element
if ( result === false ){
if ( mode == "drag" ){
ia.cancelled = true;
dd.propagates -= 1;
}
if ( type == "drop" ){
ia[ mode ][p] = null;
}
}
// assign any dropinit elements
else if ( type == "dropinit" )
|
javascript
|
{
"resource": ""
}
|
|
q3386
|
train
|
function( arr ){
return $.map( arr, function( member ){
return member && member.jquery ?
|
javascript
|
{
"resource": ""
}
|
|
q3387
|
train
|
function (n) {
if (typeof(n) === 'undefined' || isNaN(n)) {
return [];
}
if (typeof ArrayBuffer === 'undefined') {
// lacking browser support
var arr = new Array(n);
for (var i = 0;
|
javascript
|
{
"resource": ""
}
|
|
q3388
|
train
|
function (n, d, s) {
var uses = typeof s !== 'undefined';
var x = [];
for (var i = 0; i < n; i++) {
var xhere = [];
|
javascript
|
{
"resource": ""
}
|
|
q3389
|
train
|
function (x1, x2) {
var D = x1.length;
var d = 0;
for (var i = 0; i < D; i++) {
var x1i = x1[i];
var x2i =
|
javascript
|
{
"resource": ""
}
|
|
q3390
|
train
|
function (X) {
var N = X.length;
var dist = zeros(N * N); // allocate contiguous array
for (var i = 0; i < N; i++) {
for (var j = i + 1; j <
|
javascript
|
{
"resource": ""
}
|
|
q3391
|
train
|
function (X) {
var N = X.length;
var D = X[0].length;
assert(N > 0, " X is empty? You must have some data!");
assert(D > 0, " X[0] is empty? Where is the data?");
var dists = xtod(X); // convert X to distances using gaussian kernel
|
javascript
|
{
"resource": ""
}
|
|
q3392
|
train
|
function (D) {
var N = D.length;
assert(N > 0, " X is empty? You must have some data!");
// convert D to a (fast) typed array version
var dists = zeros(N * N); // allocate contiguous array
for (var i = 0; i < N; i++) {
for (var j = i + 1; j < N; j++) {
var
|
javascript
|
{
"resource": ""
}
|
|
q3393
|
train
|
function () {
this.iter += 1;
var N = this.N;
var cg = this.costGrad(this.Y); // evaluate gradient
var cost = cg.cost;
var grad = cg.grad;
// perform gradient step
var ymean = zeros(this.dim);
for (var i = 0; i < N; i++) {
for (var d = 0; d < this.dim; d++) {
var gid = grad[i][d];
var sid = this.ystep[i][d];
var gainid = this.gains[i][d];
// compute gain update
var newgain = sign(gid) === sign(sid) ? gainid * 0.8 : gainid + 0.2;
if (newgain < 0.01) newgain = 0.01; // clamp
this.gains[i][d] = newgain; // store for next turn
// compute momentum step direction
var momval = this.iter < 250 ? 0.5 : 0.8;
var newsid = momval * sid - this.epsilon * newgain * grad[i][d];
|
javascript
|
{
"resource": ""
}
|
|
q3394
|
train
|
function (Y) {
var N = this.N;
var dim = this.dim; // dim of output space
var P = this.P;
var pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima
// compute current Q distribution, unnormalized first
var Qu = zeros(N * N);
var qsum = 0.0;
for (var i = 0; i < N; i++) {
for (var j = i + 1; j < N; j++) {
var dsum = 0.0;
for (var d = 0; d < dim; d++) {
var dhere = Y[i][d] - Y[j][d];
dsum += dhere * dhere;
}
var qu = 1.0 / (1.0 + dsum); // Student t-distribution
Qu[i * N + j] = qu;
Qu[j * N + i] = qu;
qsum += 2 * qu;
}
}
// normalize Q distribution to sum to 1
var NN = N * N;
var Q = zeros(NN);
for (var q = 0; q < NN; q++) {
Q[q] = Math.max(Qu[q] / qsum, 1e-100);
}
var cost = 0.0;
var grad = [];
for (var i = 0; i < N; i++) {
var gsum = new Array(dim); // init grad for point i
for (var d = 0; d < dim;
|
javascript
|
{
"resource": ""
}
|
|
q3395
|
train
|
function() {
var args = Array.prototype.slice.call(arguments);
args.unshift(null);
var Factory = classFunc.bind.apply(
|
javascript
|
{
"resource": ""
}
|
|
q3396
|
simpleSelector
|
train
|
function simpleSelector(sources, callback) {
var options = crel('select', {
style: 'margin: 0.5rem'
}, sources.map(function(source) {
return crel('option', {id: source.id, value: source.id}, source.name);
}));
var selector = crel('div',
{
style: 'position: absolute; padding: 1rem; z-index: 999999; background: #ffffff; width: 100%; font-family: \'Lucida Sans Unicode\', \'Lucida Grande\', sans-serif; box-shadow: 0px 2px 4px #dddddd;'
},
crel('label', { style: 'margin: 0.5rem' }, 'Share screen:'),
options,
crel('span', { style: 'margin: 0.5rem; display: inline-block' },
button('Share', function() {
close();
var selected = sources.filter(function(source) {
return source && source.id === options.value;
|
javascript
|
{
"resource": ""
}
|
q3397
|
untar
|
train
|
function untar(arrayBuffer) {
if (!(arrayBuffer instanceof ArrayBuffer)) {
throw new TypeError("arrayBuffer is not an instance of ArrayBuffer.");
}
if (!global.Worker) {
throw new Error("Worker implementation is not available in this environment.");
}
return new ProgressivePromise(function(resolve, reject, progress) {
var worker = new Worker(workerScriptUri);
var files = [];
worker.onerror = function(err) {
reject(err);
};
worker.onmessage = function(message) {
message = message.data;
switch (message.type) {
case "log":
console[message.data.level]("Worker: " + message.data.msg);
break;
case "extract":
var file = decorateExtractedFile(message.data);
files.push(file);
progress(file);
break;
case "complete":
worker.terminate();
|
javascript
|
{
"resource": ""
}
|
q3398
|
collectDependencies
|
train
|
function collectDependencies(module) {
let paths = [];
function pathsToAcceptingModules(path, root) {
const requiredMe = parents[root.filename];
if (module.hot._selfAccepted) {
paths.push(path.concat(root.filename));
return;
}
if (module.hot._selfDeclined) {
return;
}
for (let next in requiredMe) {
let parentHotRuntime = requiredMe[next].hot;
if (parentHotRuntime._acceptedDependencies[root.filename]) {
paths.push(path.concat(root.filename));
continue;
}
|
javascript
|
{
"resource": ""
}
|
q3399
|
getFieldState
|
train
|
function getFieldState($ele) {
var val = $ele.val()
// If dependency is a radio group, then filter by `:checked`
if ($ele.attr('type') === 'radio') {
val = $ele.filter(':checked').val()
}
return {
value: val,
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.