applies an inverse cyclic shift to the last 3 rows of a state matrix.

@returns void
196140
function invShiftRows()
    {
        $temp = "";
        for ($i = 1; $i < 4; $i++) {
            for ($j = 0; $j < $this->Nb; $j++) $temp[($i + $j) % $this->Nb] = $this->s[$i][$j];
            for ($j = 0; $j < $this->Nb; $j++) $this->s[$i][$j] = $temp[$j];
        }
    }
1105523
public void applyMatrix()
	{
		transformMatrix.translate(new Vector3f(-0.5F, -0.5F, -0.5F));

		for (Vertex v : vertexes)
			v.applyMatrix(transformMatrix);

		resetMatrix();

		return;
	}
776849
public function shiftPositions()
    {
        $this->owner->updateAllCounters(
            [$this->positionAttribute => -1],
            ['>', $this->positionAttribute, $this->owner->{$this->positionAttribute}]
        );
    }
748965
private void rotateTwiceOrdered() {
		Point2D_F64 a = ordered[0];
		Point2D_F64 b = ordered[1];
		Point2D_F64 c = ordered[2];
		Point2D_F64 d = ordered[3];

		ordered[0] = c;
		ordered[1] = d;
		ordered[2] = a;
		ordered[3] = b;
	}
452242
@Override
    public void invert(DMatrixRMaj A_inv) {
        blockB.reshape(A_inv.numRows,A_inv.numCols,false);

        alg.invert(blockB);

        MatrixOps_DDRB.convert(blockB,A_inv);
    }
160658
public function correct()
    {
        foreach ($this->delta_matrix as $index => $record) {
            foreach ($record as $key => $val) {
                $this->matrix[$index][$key] += $val;
            }
        }

        $this->delta_matrix = [];
    }
1220842
static void reverse(double[] d, DenseMatrix V) {
        int m = V.nrows();
        int n = d.length;
        int half = n / 2;
        for (int i = 0; i < half; i++) {
            double tmp = d[i];
            d[i] = d[n - i - 1];
            d[n - i - 1] = tmp;
        }
        for (int j = 0; j < half; j++) {
            for (int i = 0; i < m; i++) {
                double tmp = V.get(i, j);
                V.set(i, j, V.get(i, n - j - 1));
                V.set(i, n - j - 1, tmp);
            }
        }
    }
632092
function _rshift($shift)
    {
        if ($shift == 0) {
            return;
        }

        $num_digits = (int) ($shift / MATH_BIGINTEGER_BASE);
        $shift %= MATH_BIGINTEGER_BASE;
        $carry_shift = MATH_BIGINTEGER_BASE - $shift;
        $carry_mask = (1 << $shift) - 1;

        if ($num_digits) {
            $this->value = array_slice($this->value, $num_digits);
        }

        $carry = 0;

        for ($i = count($this->value) - 1; $i >= 0; --$i) {
            $temp = $this->value[$i] >> $shift | $carry;
            $carry = ($this->value[$i] & $carry_mask) << $carry_shift;
            $this->value[$i] = $temp;
        }

        $this->value = $this->_trim($this->value);
    }
1351836
private function adjust_offset_for_shrinking_result_set() {
		if ( empty( $this->count_query ) ) {
			return;
		}

		$row_count = $this->db->get_var( $this->count_query );

		if ( $row_count < $this->row_count ) {
			$this->offset -= $this->row_count - $row_count;
		}

		$this->row_count = $row_count;
	}
472935
public function shift() {
        $e = array_shift($this->elements);
        $this->clean();
        $this->fire(new ListDeleteEvent($e, 0));
        return $e;
    }
40098
public static void shiftCA2(AFPChain afpChain, Atom[] ca2,  Matrix m, Atom shift, Group[] twistedGroups) {

		int i = -1;
		for (Atom a: ca2){
			i++;
			Group g = a.getGroup();

			Calc.rotate(g,m);
			Calc.shift(g, shift);

			if (g.hasAltLoc()){
				for (Group alt: g.getAltLocs()){
					for (Atom alta : alt.getAtoms()){
						if ( g.getAtoms().contains(alta))
							continue;
						Calc.rotate(alta,m);
						Calc.shift(alta,shift);
					}
				}
			}
			twistedGroups[i]=g;
		}
	}
200715
private void rotateShiftAtoms(Atom[] ca){

		for (int i  = 0 ; i < ca.length; i++){
			Atom c = ca[i];

			Calc.rotate(c,currentRotMatrix);
			Calc.shift(c,currentTranMatrix);
			//System.out.println("after " + c);
			ca[i] = c;
		}
		//System.out.println("after " + ca[0]);
	}
936176
protected function shift($state)
    {
        $this->states[] = $state;
        $this->stack[] = array_shift($this->queue);
        $this->current = null;
    }
884066
private static function shiftRow($state,$statePointer,$nbr,$isInv){
		for ($i = 0; $i < $nbr; $i++)
		{
			if($isInv)
			{
				$tmp = $state[$statePointer + 3];
				for ($j = 3; $j > 0; $j--)
					$state[$statePointer + $j] = $state[$statePointer + $j-1];
				$state[$statePointer] = $tmp;
			}
			else
			{
				$tmp = $state[$statePointer];
				for ($j = 0; $j < 3; $j++)
					$state[$statePointer + $j] = $state[$statePointer + $j+1];
				$state[$statePointer + 3] = $tmp;
			}
		}
		return $state;
	}
956698
private void _shift(double[][] state) {
    double[] tmpState = state[0];
    state[0] = state[1];
    state[1] = state[2];
    state[2] = tmpState;
  }
35332
public void reverse() {
		for (int i = 0; i < size / 2; i++) {
			T tmp = data[i];
			data[i] = data[size - i - 1];
			data[size - i - 1] = tmp;
		}
	}
532032
private void shiftBufData() {
    if (bufRead != buf.limit()) {
      throw new IllegalStateException("bufRead should be same as " +
                                      "buf.limit()");
    }
    
    //shift the remaining data on buf to the front
    if (buf.position() > 0) {
      int dataLeft = buf.remaining();
      if (dataLeft > 0) {
        byte[] b = buf.array();
        System.arraycopy(b, buf.position(), b, 0, dataLeft);
      }
      buf.position(0);
      bufRead = dataLeft;
      buf.limit(bufRead);
    }
  }