A single PPU tick.
769701
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 ] &&
					!this.sprite0Hit
				) {
					this.sprite0Hit = !!background.scanlineColors[ this.lineCycle - 1 ];
				}
			}

			this.incrementRenderCycle();
		} else {
			this.incrementIdleCycle();
		}
	}
1276809
def one(self):
        
        return self.element(np.ones(self.shape, dtype=self.dtype,
                                    order=self.default_order))
1215801
public void process(FastQueue<PositionPatternNode> pps , T gray ) {
		gridReader.setImage(gray);
		storageQR.reset();
		successes.clear();
		failures.clear();

		for (int i = 0; i < pps.size; i++) {
			PositionPatternNode ppn = pps.get(i);

			for (int j = 3,k=0; k < 4; j=k,k++) {
				if( ppn.edges[j] != null && ppn.edges[k] != null ) {
					QrCode qr = storageQR.grow();
					qr.reset();

					setPositionPatterns(ppn, j, k, qr);
					computeBoundingBox(qr);

					// Decode the entire marker now
					if( decode(gray,qr)) {
						successes.add(qr);
					} else {
						failures.add(qr);
					}

				}
			}
		}
	}
993216
def sighash_single(self, index, script=None,
                       anyone_can_pay=False):
        '''
        
        '''
        copy_tx = self._sighash_prep(
            index=index,
            script=script)

        try:
            copy_tx_outs = copy_tx.tx_outs[:index + 1]
            copy_tx_outs = [TxOut(value=b'\xff' * 8, output_script=b'')
                            for _ in copy_tx.tx_ins]
            copy_tx_outs[index] = copy_tx.tx_outs[index]
        except IndexError:
            raise NotImplementedError(
                'I refuse to implement the SIGHASH_SINGLE bug.')

        copy_tx_ins = [tx_in.copy(sequence=b'\x00\x00\x00\x00')
                       for tx_in in copy_tx.tx_ins]
        copy_tx_ins[index] = copy_tx.tx_ins[index]
        copy_tx = copy_tx.copy(tx_ins=copy_tx_ins, tx_outs=copy_tx_outs)

        if anyone_can_pay:
            return self._sighash_anyone_can_pay(
                index=index,
                copy_tx=copy_tx,
                sighash_type=shared.SIGHASH_SINGLE)

        return self._sighash_final_hashing(
            index=index,
            copy_tx=copy_tx,
            sighash_type=shared.SIGHASH_SINGLE)
1205183
public void tick() throws InterruptedException {
    if (mPreviousTickMs != 0) {
      long executionTimeMs = mClock.millis() - mPreviousTickMs;
      if (executionTimeMs > mIntervalMs) {
        mLogger.warn("{} last execution took {} ms. Longer than the interval {}", mThreadName,
            executionTimeMs, mIntervalMs);
      } else {
        mSleeper.sleep(Duration.ofMillis(mIntervalMs - executionTimeMs));
      }
    }
    mPreviousTickMs = mClock.millis();
  }
688698
function(tick) {
		var spirits;
		switch (tick.type) {
			case gui.$TICK_INSIDE:
				gui.Guide.$goasync(this._spirits.incoming);
				this._spirits.incoming = [];
				break;
			case gui.$TICK_OUTSIDE:
				spirits = gui.Object.each(this._spirits.outside, function(key, spirit) {
					return spirit;
				});
				/*
				 * TODO: make sure that this happens onexit (but not here)
				spirits.forEach ( function ( spirit ) {
					gui.Spirit.$exit ( spirit );
				});
				*/
				spirits.forEach(function(spirit) {
					gui.Spirit.$destruct(spirit);
				});
				spirits.forEach(function(spirit) {
					gui.Spirit.$dispose(spirit);
				});
				this._spirits.outside = Object.create(null);
				break;
		}
	}
783914
function tick (a) {
			if (isStopped) return

			let playedTime = context.currentTime - initTime;
			let playedCount = playedTime * sampleRate;

			//if offset has changed - notify processor to provide a new piece of data
			if (lastCount - playedCount < samplesPerFrame) {
				let buf = fetch(samplesPerFrame)

				//send queued data chunk to buffer
				util.copy(buf, buffer, lastCount % buffer.length)

				//increase rendered count
				lastCount += samplesPerFrame;

				//if there is a holding pressure control - release it
				consume(samplesPerFrame)

				//call tick extra-time in case if there is a room for buffer
				//it will plan timeout, if none
				tick()
			}
			//else plan tick for the expected time of starving
			else {
				//time of starving is when played time reaches (last count time) - half-duration
				let starvingTime = (lastCount - samplesPerFrame) / sampleRate;
				let remainingTime = starvingTime - playedTime;
				setTimeout(tick, remainingTime * 1000)
			}
		}
790496
def timer_tick(self):
        
        # TODO: should exceptions thrown from this be caught and ignored
        self.process_timers()

        delta = datetime.timedelta(milliseconds=self.base_interval_msec)
        self._timeout = IOLoop.current().add_timeout(delta, self.timer_tick)
736242
def tick(self):
    """"""
    count = self._uncounted.getAndSet(0)
    instantRate = float(count) / self.interval

    if self._initialized:
      self.rate += (self.alpha * (instantRate - self.rate))
    else:
      self.rate = instantRate
      self._initialized = True
237565
public void tick(long duration, TimeUnit unit) {
        this.date = new Date(date.getTime() + unit.toMillis(duration));
    }
348118
function Pulse(pw, iv, drip) {
    var pulse = this;
    plet.merge(pulse, drip.pulse);
    pulse.count = drip.cbCount + 1;
    pulse.event = drip.pulse.event;
}
90305
def _euler_step(self, dt):
        
        self.state = self.state + self.ddt() * dt
1370250
public static void tick() {
        sumFrames++;
        if (startTime == 0) {
            startTime = SystemClock.uptimeMillis();
        }

        ++frames;
        long currentTime = System.currentTimeMillis();
        if (currentTime - startTimeMillis >= interval) {
            int fps = (int) (frames * 1000 / interval);
            Log.v("FPSCounter", "FPS : " + fps);
            frames = 0;
            startTimeMillis = currentTime;
        }
    }
828431
def once(ctx, name):
    """"""
    from kibitzr.app import Application
    app = Application()
    sys.exit(app.run(once=True, log_level=ctx.obj['log_level'], names=name))
1357941
function(curCoord, finalCoord) {
        this.logger.log("getNextX: " + curCoord + ", " + finalCoord);
        var t = this.thumb,
            thresh,
            tmp = [],
            nextCoord = null;

        if (curCoord[0] > finalCoord[0]) {
            thresh = t.tickSize - this.thumbCenterPoint.x;
            tmp = t.getTargetCoord( curCoord[0] - thresh, curCoord[1] );
            nextCoord = [tmp.x, tmp.y];
        } else if (curCoord[0] < finalCoord[0]) {
            thresh = t.tickSize + this.thumbCenterPoint.x;
            tmp = t.getTargetCoord( curCoord[0] + thresh, curCoord[1] );
            nextCoord = [tmp.x, tmp.y];
        } else {
            // equal, do nothing
        }

        return nextCoord;
    }
66863
function(ticks) {
            var key, firstTick;

            // iterate over the ticks, keep track of the lowest 'pos' value
            for(key in ticks) {
                if(ticks.hasOwnProperty(key)) {
                    if(!firstTick || ticks[key].pos < firstTick.pos) {
                        firstTick = ticks[key];
                    }
                }
            }
            return firstTick;
        }
762082
function one (state, eventName, handler) {
  state.emitter.once(eventName, handler)

  return state.api
}