Shift the current active cells by a vector.

    @param displacement (pair of floats)
    A translation vector [di, dj].
760819
def movementCompute(self, displacement, noiseFactor = 0):
    

    if noiseFactor != 0:
      displacement = copy.deepcopy(displacement)
      xnoise = np.random.normal(0, noiseFactor)
      ynoise = np.random.normal(0, noiseFactor)
      displacement[0] += xnoise
      displacement[1] += ynoise

    # Calculate delta in the module's coordinates.
    phaseDisplacement = np.matmul(self.A, displacement)

    # Shift the active coordinates.
    np.add(self.bumpPhases, phaseDisplacement[:,np.newaxis], out=self.bumpPhases)

    # In Python, (x % 1.0) can return 1.0 because of floating point goofiness.
    # Generally this doesn't cause problems, it's just confusing when you're
    # debugging.
    np.round(self.bumpPhases, decimals=9, out=self.bumpPhases)
    np.mod(self.bumpPhases, 1.0, out=self.bumpPhases)

    self._computeActiveCells()
    self.phaseDisplacement = phaseDisplacement
1127393
public void setDiffuse(float diffuse[]){
        for(int i = 0; i<diffuse.length;i++)
            this.diffuse[i]=diffuse[i];
        Di = true;
    }
1168036
public static void shift(Atom[] ca, Atom b) {
		for (Atom atom : ca)
			Calc.shift(atom, b);
	}
710279
public void addTranslation(double[] v) {
    assert (v.length == dim);

    // reset inverse transformation - needs recomputation.
    inv = null;

    double[][] homTrans = unitMatrix(dim + 1);
    for(int i = 0; i < dim; i++) {
      homTrans[i][dim] = v[i];
    }
    trans = times(homTrans, trans);
  }
465458
private void moveVertical(int offset) {
        if (offset < 0) {
            moveUp(Math.abs(offset));
        } else if (offset > 0) {
            moveDown(offset);
        }
    }
331051
def shift(self, m: Union[float, pd.Series]) -> Union[int, pd.Series]:
        """"""
        out = m % 1 * self.TEN_DIGIT_MODULUS // 1
        if isinstance(out, pd.Series):
            return out.astype(int)
        return int(out)
1021803
void applyTransformation(Transformation2D transform) {
		m_vertices_mp.applyTransformation(transform);
		if (m_segments != null) {
			for (int i = 0, n = m_segments.size(); i < n; i++) {
				if (m_segments.get(i) != null) {
					m_segments.get(i).applyTransformation(transform);
				}
			}
		}
	}
931176
public void setPosition(float x, float y, float z) {
        getTransform().setPosition(x, y, z);
        if (mTransformCache.setPosition(x, y, z)) {
            onTransformChanged();
        }
    }
1130274
public void setPosition(Vector3f position) {
        setPosition(position.x, position.y, position.z);
    }
649726
protected void shiftLeft(int start, int end)
  {
    for (int i = start; i < end; ++i) {
      positions[i] = positions[i + 1];
      bins[i] = bins[i + 1];
    }
  }
200831
public static final void shift(Structure structure, Atom a ){

		AtomIterator iter = new AtomIterator(structure) ;
		while (iter.hasNext() ) {
			Atom atom = null ;

			atom = iter.next()  ;

			Atom natom = add(atom,a);
			double x = natom.getX();
			double y = natom.getY() ;
			double z = natom.getZ();
			atom.setX(x);
			atom.setY(y);
			atom.setZ(z);

		}
	}
503245
@Override
    public T remove(int index) {
        if (displacement != null) {
            return super.get(index - displacement);
        }
        return super.remove(index);
    }
1223955
public static void moveChildren(Element from, Element to) {
        if (from == null || to == null || from == to) return;
        for (int k = from.getChildCount() - 1; k >= 0; k--) {
            Node node = from.getChild(k);
            from.removeChild(node);
            to.insertFirst(node);
        }
    }
1261406
function shift(b, rowBytes) {
  return Buffer.concat([b.slice(-rowBytes), b.slice(0, -rowBytes)], b.length);
}
1164238
private Node<T> moveRedRight(Node<T> h) {
        // assert (h != null);
        // assert isRed(h) && !isRed(h.right) && !isRed(h.right.left);
        flipColors(h);
        if (h.left.left != null && h.left.left.red) { 
            h = rotateRight(h);
            flipColors(h);
        }
        return h;
    }
185094
public void setPosition(final Object targetObj, final CellPosition position) {
        
        ArgUtils.notNull(targetObj, "targetObj");
        ArgUtils.notNull(position, "position");
        
        positionSetter.ifPresent(setter -> setter.set(targetObj, position));
    }
246365
private Node<T> moveRedLeft(Node<T> h) {
        // assert (h != null);
        // assert isRed(h) && !isRed(h.left) && !isRed(h.left.left);

        flipColors(h);
        if (h.right.left != null && h.right.left.red) { 
            h.right = rotateRight(h.right);
            h = rotateLeft(h);
            flipColors(h);
        }
        return h;
    }