Moves the Envelope by given distance.
@param dx
@param dy
490613
public void move(double dx, double dy) {
		if (isEmpty())
			return;
		xmin += dx;
		ymin += dy;
		xmax += dx;
		ymax += dy;
	}
326141
def move_to(self, x, y, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.m.move(x, y)
        self.delay(post_dl)
462448
function (x, y) {
    if (!this.pathStarted) {
      this.context.beginPath();
      this.context.moveTo(x,y);
      this.pathStarted = true;
    } else {
      this.context.lineTo(x,y);
    }
  }
1294884
public final void smoothScrollBy(int dx, int dy) {
        long duration = AnimationUtils.currentAnimationTimeMillis() - mLastScroll;
        if (duration > ANIMATED_SCROLL_GAP) {
            mScroller.startScroll(getScrollX(), getScrollY(), dx, dy);
            awakenScrollBars(mScroller.getDuration());
            invalidate();
        } else {
            if (!mScroller.isFinished()) {
                mScroller.abortAnimation();
            }
            scrollBy(dx, dy);
        }
        mLastScroll = AnimationUtils.currentAnimationTimeMillis();
    }
1238106
private void moveElements(int i)
    {
        if (i >= size)
            return;

        System.arraycopy(starts, i, starts, i+1, size - i);
        System.arraycopy(ends, i, ends, i+1, size - i);
        System.arraycopy(markedAts, i, markedAts, i+1, size - i);
        System.arraycopy(delTimes, i, delTimes, i+1, size - i);
        // we set starts[i] to null to indicate the position is now empty, so that we update boundaryHeapSize
        // when we set it
        starts[i] = null;
    }
288219
function(dx, dy) {

            if (dx === undefined) {
                dx = 0;
            }

            if (dy === undefined) {
                dy = dx;
            }

            this.x -= dx;
            this.y -= dy;
            this.width += 2 * dx;
            this.height += 2 * dy;

            return this;
        }
1174238
public void translate(double dx, double dy, double dz) {
		// Compute the reference point for the plane
    	// (usefull for translation)
    	Point3f refPoint = (Point3f) getPivot();
    	
    	// a.x + b.y + c.z + d = 0
    	// where (x,y,z) is the translation point
    	setPivot(refPoint.getX()+dx,refPoint.getY()+dy,refPoint.getZ()+dz);
	}
118361
def moveToPoint(self, xxx_todo_changeme):
        
        (x,y) = xxx_todo_changeme
        self.set_x(float(self.get_x()) + float(x))
        self.set_y(float(self.get_y()) + float(y))
458175
function(dx, dy) {
            if (dx === undefined) {
                dx = 0;
            }

            if (dy === undefined) {
                dy = dx;
            }

            this.a += 2 * dx;
            this.b += 2 * dy;

            return this;
        }
772422
public void moveColumn(Object columnKey, int newColumnIndex) {
        checkFrozen();

        this.checkColumnIndex(newColumnIndex);

        final int columnIndex = this.getColumnIndex(columnKey);
        final List<C> tmp = new ArrayList<>(columnLength());
        tmp.addAll(_columnKeySet);
        tmp.add(newColumnIndex, tmp.remove(columnIndex));

        _columnKeySet.clear();
        _columnKeySet.addAll(tmp);

        _columnKeyIndexMap = null;

        if (_initialized && _columnList.size() > 0) {
            _columnList.add(newColumnIndex, _columnList.remove(columnIndex));
        }
    }
244871
def move_towards(self, other, beta, alpha):
        """"""
        self.position += beta * (other.position - self.position)
        self.position += alpha * (np.random.uniform(-0.5, 0.5, len(self.position)))
        self.position = np.minimum(self.position, [b[1] for b in self.bounds])
        self.position = np.maximum(self.position, [b[0] for b in self.bounds])
1108764
function (dx, dy) {
        switch (this.draggable) {
            case 'horizontal':
                dy = 0;
                break;
            case 'vertical':
                dx = 0;
                break;
        }

        var m = this.transform;
        if (!m) {
            m = this.transform = [1, 0, 0, 1, 0, 0];
        }
        m[4] += dx;
        m[5] += dy;

        this.decomposeTransform();
        this.dirty(false);
    }
760084
public final void moveInside(Rect bounds) {
	// check the right edge
	int distanceOffRightSide = (x + w) - (bounds.x + bounds.w);
	if (distanceOffRightSide > 0) {
	    x -= distanceOffRightSide;
	}
	// check the left edge (we prefer this to fit)
	int distanceOffLeftSide = bounds.x - x;
	if (distanceOffLeftSide > 0) {
	    x += distanceOffLeftSide;
	}

	// check the bottom edge
	int distanceOffBottom = (y + h) - (bounds.y + bounds.h);
	if (distanceOffBottom > 0) {
	    y -= distanceOffBottom;
	}
	// check the top edge (we prefer this to fit)
	int distanceOffTop = bounds.y - y;
	if (distanceOffTop > 0) {
	    y += distanceOffTop;
	}	
    }
984985
private void moveHorizontally(int offset) {
        if (offset < 0) {
            moveLeft(Math.abs(offset));
        } else if (offset > 0) {
            moveRight(offset);
        }
    }
981507
def move(self, x, y):
        
        self.x = x
        self.y = y
16797
def move(self, d_xyz):
        
        return Space(Place(self)).move(d_xyz, inplace=False)[0].surface
184616
function (dx, dy) {
        var self = this, rect = self.layoutRect();

        self.moveTo(rect.x + dx, rect.y + dy);

        return self;
      }