Translate.

@param thePath the path to follow.
@param direction is the direction to follow on the path if the path contains only one segment.
@param move where <code>x</code> is the curviline coordinate and <code>y</code> is the shift coordinate.
344435
public void translate(List<? extends S> thePath, Direction1D direction, Tuple2D<?> move) {
		assert move != null : AssertMessages.notNullParameter(2);
		this.path = thePath == null || thePath.isEmpty() ? null : new ArrayList<>(thePath);
		this.firstSegmentDirection = detectFirstSegmentDirection(direction);
		this.curvilineTranslation += move.getX();
		this.shiftTranslation += move.getY();
        this.isIdentity = null;
	}
573916
boolean moveCursor(final INodeReadTrx paramRtx, final ERevision paramRevision) throws TTIOException {
        assert paramRtx != null;

        boolean moved = false;

        final ITreeStructData node = ((ITreeStructData)paramRtx.getNode());
        if (node.hasFirstChild()) {
            if (node.getKind() != ROOT && mDiffKind == EDiffOptimized.HASHED && mHashKind != HashKind.None
                && (mDiff == EDiff.SAMEHASH || mDiff == EDiff.DELETED)) {
                moved = paramRtx.moveTo(((ITreeStructData)paramRtx.getNode()).getRightSiblingKey());

                if (!moved) {
                    moved = moveToFollowingNode(paramRtx, paramRevision);
                }
            } else {
                moved = paramRtx.moveTo(((ITreeStructData)paramRtx.getNode()).getFirstChildKey());
                if (moved) {
                    switch (paramRevision) {
                    case NEW:
                        mDepth.incrementNewDepth();
                        break;
                    case OLD:
                        mDepth.incrementOldDepth();
                        break;
                    }
                }
            }
        } else if (node.hasRightSibling()) {
            if (paramRtx.getNode().getDataKey() == mRootKey) {
                paramRtx.moveTo(ROOT_NODE);
            } else {
                moved = paramRtx.moveTo(((ITreeStructData)paramRtx.getNode()).getRightSiblingKey());
            }
        } else {
            moved = moveToFollowingNode(paramRtx, paramRevision);
        }

        return moved;
    }
984985
private void moveHorizontally(int offset) {
        if (offset < 0) {
            moveLeft(Math.abs(offset));
        } else if (offset > 0) {
            moveRight(offset);
        }
    }
173104
@Override
    public void move(final double dx, final double dy, final boolean midPointsOnly, final boolean moveLinePoints)
    {
        final IControlHandleList handles = m_connector.getPointHandles();

        int start = 0;

        int end = handles.size();

        if (midPointsOnly)
        {
            if (m_connector.getHeadConnection().getMagnet() != null)
            {
                start++;
            }
            if (m_connector.getTailConnection().getMagnet() != null)
            {
                end--;
            }
        }
        final Point2DArray points = m_connector.getLine().getPoint2DArray();

        for (int i = start, j = (start == 0) ? start : 2; i < end; i++, j += 2)
        {
            if (moveLinePoints)
            {
                final Point2D p = points.get(i);

                p.setX(m_startPoints.get(j) + dx);

                p.setY(m_startPoints.get(j + 1) + dy);
            }
            final IControlHandle h = handles.getHandle(i);

            final IPrimitive<?> prim = h.getControl();

            prim.setX(m_startPoints.get(j) + dx);

            prim.setY(m_startPoints.get(j + 1) + dy);
        }
        if (moveLinePoints)
        {
            m_connector.getLine().refresh();
        }
        m_wiresManager.getLayer().getLayer().batch();
    }
1288625
def move(self, x, y):
        
        self._x = int(round(x * 2, 0))
        self._y = int(round(y * 2, 0))
631669
public void moveToLocalFile(Path src, Path dst) throws IOException {
    copyToLocalFile(true, false, src, dst);
  }
1094302
public void translate(Vector3D<?, ?> translation) {
		this.m03 += translation.getX();
		this.m13 += translation.getY();
		this.m23 += translation.getZ();
	}
330012
def move(self, source_path, destination_path):
        
        self.copy(source_path, destination_path)
        self.remove(source_path)
208513
public ListenableFuture<Boolean> moveToTrashFuture(final Path path) {
    return this.executor.submit(new Callable<Boolean>() {
      @Override
      public Boolean call() throws IOException {
        return AsyncTrash.this.innerTrash.moveToTrash(path);
      }
    });
  }
987198
public static <E> void FFTShift2D(E[][] x, Direction direction, int dimension) {

        //Create a copy
        E[][] temp = (E[][]) new Object[x.length][x[0].length];
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[0].length; j++) {
                temp[i][j] = x[i][j];
            }
        }

        if (direction == Direction.Forward) {
            //Perform fftshift in the first dimension
            if (dimension == 1) {
                int move = temp.length / 2;
                for (int i = 0; i < move; i++) {
                    for (int j = 0; j < x[0].length; j++) {
                        x[i][j] = temp[temp.length - move + i][j];
                    }
                }

                for (int i = move; i < x.length; i++) {
                    for (int j = 0; j < x[0].length; j++) {
                        x[i][j] = temp[i - move][j];
                    }
                }

            }

            //Perform fftshift in the second dimension
            if (dimension == 2) {
                for (int i = 0; i < x.length; i++) {
                    FFTShift1D(x[i], Direction.Forward);
                }
            }
        } else {
            if (dimension == 1) {
                int move = temp.length / 2;
                for (int i = 0; i < x.length - move; i++) {
                    for (int j = 0; j < x[0].length; j++) {
                        x[i][j] = temp[move + i][j];
                    }
                }
                for (int i = 0; i < move; i++) {
                    for (int j = 0; j < x[0].length; j++) {
                        x[x.length - move + i][j] = temp[i][j];
                    }
                }

            }
            if (dimension == 2) {
                for (int i = 0; i < x.length; i++) {
                    FFTShift1D(x[i], Direction.Backward);
                }
            }
        }
    }
116423
def move_to(self, destination):
        
        target = self.__get_destination__(destination)
        logger.info("Move %s to %s" % (self, target))
        shutil.move(self.path, unicode(target))
        return target
832426
function move(node, stayWithin, directionIsNext) {
  if (directionIsNext) {
    return NodeTraversal.next(node, stayWithin);
  } else {
    if (node === stayWithin) {
      return null;
    }
    return NodeTraversal.previous(node, null);
  }
}
54774
private boolean moveParserToField(JsonParser parser, String path)
            throws IOException {
        List<String> segments = getFieldPath(path);

        for (String segment : segments) {
            if (parser.getCurrentToken() != JsonToken.START_OBJECT) {
                // Always expect the path to be fields in a JSON map
                return false;
            }

            boolean found = false;

            JsonToken currentToken = parser.nextToken();
            while (!found && currentToken != JsonToken.END_OBJECT) {
                if (currentToken != JsonToken.FIELD_NAME) {
                    // This should always be a field.  Something is amiss.
                    throw new IOException("Field not found at expected location");
                }
                String fieldName = parser.getText();
                if (fieldName.equals(segment)) {
                    // Move to the next token, which is the field value
                    found = true;
                    currentToken = parser.nextToken();
                } else {
                    parser.nextValue();
                    currentToken = skipValue(parser);
                }
            }

            if (!found) {
                // Field was not found
                return false;
            }
        }

        // The current location in the parser is the value.
        return true;
    }
377389
public static Optional<Path> moveDir(Path sourceDirPath,
            Path destinationDirPath, CopyOption... options) {
        return operateDir(sourceDirPath, destinationDirPath, sourceDirPath,
                path -> move(path, destinationDirPath, options));
    }
490833
function ( direction ) {
			var current = F.current;

			if (current) {
				if (!isString(direction)) {
					direction = current.direction.next;
				}

				F.jumpto(current.index + 1, direction, 'next');
			}
		}
1124073
def move(self, direction=0):
        
        direction = int(direction)
        self.position = list(self.position)

        if direction == 0:
            self.position[1] += 1
        elif direction == 1:
            self.position[0] -= 1
        elif direction == 2:
            self.position[1] -= 1
        elif direction == 3:
            self.position[0] += 1
839370
function (path, segment, translatedThreshold) {
		path.push(
			L,
			segment[segment.length - 1].plotX,
			translatedThreshold,
			L,
			segment[0].plotX,
			translatedThreshold
		);
	}