For backwards compatibility only.
337667
private static function _canonicalizeKey($key_)
    {
        $result = "";
        $key_ = trim($key_);
        $key_ = str_replace("\n", "", $key_);
        $key_ = str_replace("\r", "", $key_);
        for ($i = 0; $i<strlen($key_); $i++) {
            $c = $key_[$i];
            $o = ord($c);
            if ($o < 5 || $o > 127) {
                $result .= 'C<'.$o.'>';
            } else {
                $result .= $c;
            }
        }
        return $result;
    }
174667
@Override
    public void backward() {
        Tensor tmp = new Tensor(yAdj); // copy
        tmp.elemMultiply(y);
        modInX.getOutputAdj().elemAdd(tmp);
    }
480598
def _cmp_version(item1, item2):
    '''
    
    '''
    vers1 = _LooseVersion(item1)
    vers2 = _LooseVersion(item2)

    if vers1 < vers2:
        return -1
    if vers1 > vers2:
        return 1
    return 0
1275620
function _oldStyleShareReplay (bufferSize, windowTime, scheduler) {
  let subject;

  const connectable = multicast(function shareReplaySubjectFactory () {
    if (this._isComplete) {
      return subject;
    } else {
      return (subject = new ReplaySubject(bufferSize, windowTime, scheduler));
    }
  });
  return (source) => refCount()(connectable(source));
}
649189
def backward(self, out_grads=None):
        """"""
        assert self.binded and self.params_initialized
        self._curr_module.backward(out_grads=out_grads)
536082
def backward(self, speed=1):
        
        if isinstance(self.enable_device, DigitalOutputDevice):
            if speed not in (0, 1):
                raise ValueError(
                    'backward speed must be 0 or 1 with non-PWM Motors')
        self.enable_device.off()
        self.phase_device.on()
        self.enable_device.value = speed
1034136
@Override
	protected void horizontal() {
		float[] dataX = derivX.data;
		float[] dataY = derivY.data;

		float[] hXX = horizXX.data;
		float[] hXY = horizXY.data;
		float[] hYY = horizYY.data;

		final int imgHeight = derivX.getHeight();
		final int imgWidth = derivX.getWidth();

		int windowWidth = radius * 2 + 1;

		int radp1 = radius + 1;

		BoofConcurrency.loopFor(0,imgHeight,row->{

			int pix = row * imgWidth;
			int end = pix + windowWidth;

			float totalXX = 0;
			float totalXY = 0;
			float totalYY = 0;

			int indexX = derivX.startIndex + row * derivX.stride;
			int indexY = derivY.startIndex + row * derivY.stride;

			for (; pix < end; pix++) {
				float dx = dataX[indexX++];
				float dy = dataY[indexY++];

				totalXX += dx * dx;
				totalXY += dx * dy;
				totalYY += dy * dy;
			}

			hXX[pix - radp1] = totalXX;
			hXY[pix - radp1] = totalXY;
			hYY[pix - radp1] = totalYY;

			end = row * imgWidth + imgWidth;
			for (; pix < end; pix++, indexX++, indexY++) {

				float dx = dataX[indexX - windowWidth];
				float dy = dataY[indexY - windowWidth];

				// saving these multiplications in an array to avoid recalculating them made
				// the algorithm about 50% slower
				totalXX -= dx * dx;
				totalXY -= dx * dy;
				totalYY -= dy * dy;

				dx = dataX[indexX];
				dy = dataY[indexY];

				totalXX += dx * dx;
				totalXY += dx * dy;
				totalYY += dy * dy;

				hXX[pix - radius] = totalXX;
				hXY[pix - radius] = totalXY;
				hYY[pix - radius] = totalYY;
			}
		});
	}
165240
@Override
    public void backward() {
        Tensor tmp1 = new Tensor(yAdj); // copy
        tmp1.multiply(weightX);
        modInX.getOutputAdj().elemAdd(tmp1);

        Tensor tmp2 = new Tensor(yAdj); // copy
        tmp2.multiply(weightW);
        modInW.getOutputAdj().elemAdd(tmp2);
    }
1166321
def _not16(ins):
    ''' 
    '''
    output = _16bit_oper(ins.quad[2])
    output.append('ld a, h')
    output.append('or l')
    output.append('sub 1')
    output.append('sbc a, a')
    output.append('push af')
    return output
658036
void update()
    {
        mx = x - oldX;
        my = y - oldY;
        oldX = x;
        oldY = y;
    }
635193
@Override
    public int isCompatible(Class<?> target, Object actual) {
        int superCompat = super.isCompatible(target, actual);
        if (superCompat >= 0 && superCompat < 3) {
            return superCompat;
        }

        Class<?> actualClass = actual.getClass();
        if (actualClass == Types.UNDEFINED.getClass() || actualClass == Types.NULL.getClass()) {
            return 3;
        }

        if (JSFunction.class.isAssignableFrom(actualClass)) {
            if (isSingleAbstractMethod(target) != null) {
                return 3;
            }
        }

        return -1;
    }
1200296
def backwards_compatibilize
      config = clone
      # Provide backwards-compatibility
      check_auto(config)
      check_server(config)

      renamed_key "server_port", "port", config
      renamed_key "plugins", "plugins_dir", config
      renamed_key "layouts", "layouts_dir", config
      renamed_key "data_source", "data_dir", config

      check_pygments(config)
      check_include_exclude(config)
      check_coderay(config)
      check_maruku(config)

      config
    end
85509
private void convertToMentsuComp(List<Mentsu> winCandidate) throws IllegalMentsuSizeException {
        //全て0かチェック
        if (isAllZero(handStocks)) {
            canWin = true;
            winCandidate.addAll(inputtedMentsuList);
            MentsuComp mentsuComp = new MentsuComp(winCandidate, last);
            if (!mentsuCompSet.contains(mentsuComp)) {
                mentsuCompSet.add(mentsuComp);
            }
        }
    }
124088
public static void main(String[] args)
  {
    BitmapIterationBenchmark state = new BitmapIterationBenchmark();
    state.bitmapAlgo = "concise";
    state.prob = 0.001;
    state.size = 1000000;
    state.setup();

    BitmapsForIntersection state2 = new BitmapsForIntersection();
    state2.setup(state);
    state.intersectionAndIter(state2);
  }
1353414
function () {
        let _that = this[PRIVATE];
        if (_that.initialized() && _that.running()) {
            _that.gameboy.stopEmulator |= 2;
            _that.frames = 0; //Reset internal variables
        }
    }
1294578
def create(game, settings=None, presets=None):
    
    return ClassicControlEnv(
        envname=game,
        settings=settings,
        presets=presets
    )
144640
def downgrade():
    """"""
    # table ObjectVersionTag
    op.drop_table('files_objecttags')
    # table ObjectVersion: modify primary_key
    if op.get_context().dialect.name == 'mysql':
        op.execute(
            'ALTER TABLE files_object '
            'DROP INDEX uq_files_object_bucket_id, '
            'DROP PRIMARY KEY, '
            'ADD PRIMARY KEY(`bucket_id`, `key`, `version_id`)')
    else:
        op.drop_constraint(
            'pk_files_object', 'files_object', type_='primary')
        op.create_primary_key('pk_files_object', 'files_object',
                              ['bucket_id', 'key', 'version_id'])