Move point between clusters, numerical attributes.
335535
def move_point_num(point, to_clust, from_clust, cl_attr_sum, cl_memb_sum):
    """"""
    # Update sum of attributes in cluster.
    for iattr, curattr in enumerate(point):
        cl_attr_sum[to_clust][iattr] += curattr
        cl_attr_sum[from_clust][iattr] -= curattr
    # Update sums of memberships in cluster
    cl_memb_sum[to_clust] += 1
    cl_memb_sum[from_clust] -= 1
    return cl_attr_sum, cl_memb_sum
762837
def aux_moveTree(offset, tree):
	""""""
	if tree.x1 != None and tree.x2 != None :
		tree.x1, tree.x2 = tree.x1+offset, tree.x2+offset
		
	for c in tree.children:
		aux_moveTree(offset, c)
1086866
def move_to(x_coord, y_coord)
      Selenium::WebDriver::Point.new(Integer(x_coord), Integer(y_coord)).tap do |point|
        use { @driver.manage.window.position = point }
      end
    end
1032636
def move(self, group, cluster_ids=None):
        
        if isinstance(cluster_ids, string_types):
            logger.warn("The list of clusters should be a list of integers, "
                        "not a string.")
            return
        self.label('group', group, cluster_ids=cluster_ids)
154517
void updateClusterXY(int cluster, Point2D pt) {
		int vertexList = getClusterVertices(cluster);
		for (int vh = m_cluster_vertices.getFirst(vertexList); vh != -1; vh = m_cluster_vertices
				.getNext(vh)) {
			int vertex = m_cluster_vertices.getElement(vh);
			m_shape.setXY(vertex, pt);
		}
	}
1034066
def set_points(self, pt1, pt2):
        """"""
        (x1, y1) = pt1.as_tuple()
        (x2, y2) = pt2.as_tuple()
        self.left = min(x1, x2)
        self.top = min(y1, y2)
        self.right = max(x1, x2)
        self.bottom = max(y1, y2)
1338140
def moveTo(self, newX=0, newY=0):
        
        self.x = newX
        self.y = newY
335143
function(g, coords) {
        if (!coords || !coords.length)
            return;
        g.moveTo(coords[0][0], coords[0][1]);
        for (var i = 1; i < coords.length; i++) {
            g.lineTo(coords[i][0], coords[i][1]);
        }
    }
702445
def transform(self, m):
        """"""
        if len(m) != 6:
            raise ValueError("bad sequ. length")
        self.x, self.y = TOOLS._transform_point(self, m)
        return self
636190
def move(self, v):
        """"""

        # rotate movement vector according to the angle of the object
        vx, vy = v
        vx, vy = (
            vx * math.cos(self.angle) - vy * math.sin(self.angle),
            vx * math.sin(self.angle) + vy * math.cos(self.angle),
        )

        def _move(xy):
            x, y = xy
            return x + vx, y + vy

        # TODO: detect other objects in the way, stop movement appropriately

        self.pts = [p for p in map(lambda x: _move(x), self.pts)]
        self.center = _move(self.center)
1285588
def pointm(self, x, y, m=None):
        """"""
        shapeType = POINTM
        pointShape = Shape(shapeType)
        pointShape.points.append([x, y, m])
        self.shape(pointShape)
212992
def apply_move(grid, move):
    ""
    p, q = grid
    bit = 1 << move
    return (q, p | bit) if 0 == (bit & (p | q)) else None
470127
def migrate_cluster(cluster):
    """"""

    for old, new in [('_user_key_public', 'user_key_public'),
                     ('_user_key_private', 'user_key_private'),
                     ('_user_key_name', 'user_key_name'),]:
        if hasattr(cluster, old):
            setattr(cluster, new, getattr(cluster, old))
            delattr(cluster, old)
    for kind, nodes in cluster.nodes.items():
        for node in nodes:
            if hasattr(node, 'image'):
                image_id = getattr(node, 'image_id', None) or node.image
                setattr(node, 'image_id', image_id)
                delattr(node, 'image')

    # Possibly related to issue #129
    if not hasattr(cluster, 'thread_pool_max_size'):
        cluster.thread_pool_max_size = 10
    return cluster
621933
private void adjustApproximatedKNNDistances(MkAppEntry entry, Map<DBID, KNNList> knnLists) {
    MkAppTreeNode<O> node = getNode(entry);

    if(node.isLeaf()) {
      for(int i = 0; i < node.getNumEntries(); i++) {
        MkAppLeafEntry leafEntry = (MkAppLeafEntry) node.getEntry(i);
        // approximateKnnDistances(leafEntry,
        // getKNNList(leafEntry.getRoutingObjectID(), knnLists));
        PolynomialApproximation approx = approximateKnnDistances(getMeanKNNList(leafEntry.getDBID(), knnLists));
        leafEntry.setKnnDistanceApproximation(approx);
      }
    }
    else {
      for(int i = 0; i < node.getNumEntries(); i++) {
        MkAppEntry dirEntry = node.getEntry(i);
        adjustApproximatedKNNDistances(dirEntry, knnLists);
      }
    }

    // PolynomialApproximation approx1 = node.knnDistanceApproximation();
    ArrayModifiableDBIDs ids = DBIDUtil.newArray();
    leafEntryIDs(node, ids);
    PolynomialApproximation approx = approximateKnnDistances(getMeanKNNList(ids, knnLists));
    entry.setKnnDistanceApproximation(approx);
  }
986382
private void moveTo(int posX, int posY) {

        posX = (posX < 0)
        ? 0
        : (((posX + m_currentSelection.getWidth()) >= m_elementWidth)
        ? m_elementWidth - m_currentSelection.getWidth()
        : posX);
        posY = (posY < 0)
        ? 0
        : (((posY + m_currentSelection.getHeight()) >= m_elementHeight)
        ? m_elementHeight - m_currentSelection.getHeight()
        : posY);

        m_markerStyle.setTop(posY, Unit.PX);
        m_markerStyle.setLeft(posX, Unit.PX);

        m_overlayLeftStyle.setWidth(posX, Unit.PX);

        m_overlayTopStyle.setLeft(posX, Unit.PX);
        m_overlayTopStyle.setHeight(posY, Unit.PX);

        m_overlayBottomStyle.setLeft(posX, Unit.PX);
        m_overlayBottomStyle.setHeight(m_elementHeight - posY - m_currentSelection.getHeight(), Unit.PX);

        m_overlayRightStyle.setWidth(m_elementWidth - posX - m_currentSelection.getWidth(), Unit.PX);

        m_currentSelection.setTop(posY);
        m_currentSelection.setLeft(posX);
    }
668954
def move_edge_target(self, edge_id, node_a):
        """"""
        # Grab the edge
        edge = self.get_edge(edge_id)

        # Alter the vertices
        edge['vertices'] = (edge['vertices'][0], node_a)
762428
def move(self, i, lat, lng, change_time=True):
        ''''''
        if i < 0 or i >= self.count():
            print("Invalid fence point number %u" % i)
        self.points[i].lat = lat
        self.points[i].lng = lng
        # ensure we close the polygon
        if i == 1:
                self.points[self.count()-1].lat = lat
                self.points[self.count()-1].lng = lng
        if i == self.count() - 1:
                self.points[1].lat = lat
                self.points[1].lng = lng
        if change_time:
            self.last_change = time.time()