update world matrix and descendants.
483003
function( skipParents ){
    skipParents = !!skipParents;


    this.updateMatrix();
    var invalidWorldMatrix = this._hasInvalidWorldMatrix( skipParents );
    if( invalidWorldMatrix ) {
      this._computeWorldMatrix( skipParents );
    }

    for (var i = 0; i < this._children.length; i++) {
      var c = this._children[i];
      c._invalidW = c._invalidW || invalidWorldMatrix;
      c.updateWorldMatrix( true );
    }

  }
499908
def update_positions(self, r_array):
        ''''''
        self.ar.update_positions(r_array)
        
        if self.has_bonds:
            self.br.update_positions(r_array)
960425
public void update() {
        if (polyline != null) {
            if (isDeleted()) {
                remove();
            } else {
                List<LatLng> points = converter.getPointsFromMarkers(markers);
                polyline.setPoints(points);
            }
        }
    }
43647
protected void updateBoundingRects() {
		float maxX = startX[0];
		float minX = startX[0];
		float maxY = startY[0];
		float minY = startY[0];

		for (int i = 0; i < rayNum; i++) {
			maxX = maxX > startX[i] ? maxX : startX[i];
			maxX = maxX > mx[i] ? maxX : mx[i];
			minX = minX < startX[i] ? minX : startX[i];
			minX = minX < mx[i] ? minX : mx[i];
			maxY = maxY > startY[i] ? maxY : startY[i];
			maxY = maxY > my[i] ? maxY : my[i];
			minY = minY < startY[i] ? minY : startY[i];
			minY = minY < my[i] ? minY : my[i];
		}
		chainLightBounds.set(minX, minY, maxX - minX, maxY - minY);
		rayHandlerBounds.set(
			rayHandler.x1, rayHandler.y1,
			rayHandler.x2 - rayHandler.x1, rayHandler.y2 - rayHandler.y1);
	}
1233975
def updateRasterBounds(self):
        """"""
        yrange = self.viewRange()[1]
        yrange_size = yrange[1] - yrange[0]
        rmax = self.rasterTop*yrange_size + yrange[0]
        rmin = self.rasterBottom*yrange_size + yrange[0]
        self.rasterYslots = np.linspace(rmin, rmax, self.nreps)
        self.rasterBoundsUpdated.emit((self.rasterBottom, self.rasterTop), self.getTitle())
580700
protected void update(float scale) {
        GVRSceneObject owner = getOwnerObject();
        if (isEnabled() && (owner != null) && owner.isEnabled())
        {
            float w = getWidth();
            float h = getHeight();
            mPose.update(mARPlane.getCenterPose(), scale);
            Matrix4f m = new Matrix4f();
            m.set(mPose.getPoseMatrix());
            m.scaleLocal(w * 0.95f, h * 0.95f, 1.0f);
            owner.getTransform().setModelMatrix(m);
        }
    }
672498
protected void updateMatrix(double[][] mat, final double[] evec, double eval) {
    final int size = mat.length;
    for(int i = 0; i < size; i++) {
      final double[] mati = mat[i];
      final double eveci = evec[i];
      for(int j = 0; j < size; j++) {
        mati[j] -= eval * eveci * evec[j];
      }
    }
  }
179023
def update(self):
        """"""
        if self.single_channel:
            self.im.set_data(self.data[self.ind, :, :])
        else:
            self.im.set_data(self.data[self.ind, :, :, :])
        self.ax.set_ylabel('time frame %s' % self.ind)
        self.im.axes.figure.canvas.draw()
360205
def updateShape(self):
        """"""
        x = self.tags['x']
        y = -self.tags['y'] # Neuron y-axis positive = upwards, so assume pia=0 and cortical depth = neg
        z = self.tags['z']
                
        for sec in list(self.secs.values()):
            if 'geom' in sec and 'pt3d' not in sec['geom']:  # only cells that didn't have pt3d before
                sec['geom']['pt3d'] = []
                sec['hObj'].push()
                n3d = int(h.n3d())  # get number of n3d points in each section
                for i in range(n3d):
                    # by default L is added in x-axis; shift to y-axis; z increases 100um for each cell so set to 0
                    pt3d = [h.y3d(i), h.x3d(i), 0, h.diam3d(i)] 
                    sec['geom']['pt3d'].append(pt3d) 
                    h.pt3dchange(i, x+pt3d[0], y+pt3d[1], z+pt3d[2], pt3d[3], sec=sec['hObj'])
                h.pop_section()
156266
def update(self, *names: str) -> 'ListTree':
        
        for name in names:
            parts = name.split(self._delimiter)
            self._root.add(*parts)
        return self
995717
private void updateChildren() {
        axesPanel.setSize(getWidth(), getHeight());
        plotPanel.setSize(getWidth() - X_OFFSET_LEFT - X_OFFSET_RIGHT,
                getHeight() - Y_OFFSET_BOTTOM - Y_OFFSET_TOP);
    }
191277
def update_state(world):
    

    world_size = len(world)

    def wrap(index):
        """Wrap an index around the other end of the array"""
        return index % world_size

    for x in range(world_size):
        for y in range(world_size):
            # Decide if this node cares about the rules right now
            if not world[x][y].allow_change.get():
                continue
            live_neighbor_count = sum([
                world[wrap(x)][wrap(y + 1)].value,
                world[wrap(x + 1)][wrap(y + 1)].value,
                world[wrap(x + 1)][wrap(y)].value,
                world[wrap(x + 1)][wrap(y - 1)].value,
                world[wrap(x)][wrap(y-1)].value,
                world[wrap(x - 1)][wrap(y - 1)].value,
                world[wrap(x - 1)][wrap(y)].value,
                world[wrap(x - 1)][wrap(y + 1)].value
            ])
            if world[x][y].value:
                # Any live cell with fewer than two live neighbours dies
                # Any live cell with more than three live neighbours dies
                # Any live cell with two or three live neighbours lives
                if not (live_neighbor_count == 2 or live_neighbor_count == 3):
                    world[x][y].value = False
            else:
                # Any dead cell with exactly three live neighbours comes alive
                if live_neighbor_count == 3:
                    world[x][y].value = True
859649
def _update(self):
        

        """

        # Calculate gradient for current iteration.
        self._grad.get_grad(self._x_old)

        # Update z values.
        for i in range(self._prox_list.size):
            z_temp = (2 * self._x_old - self._z[i] - self._gamma *
                      self._grad.grad)
            z_prox = self._prox_list[i].op(z_temp, extra_factor=self._gamma /
                                           self._weights[i])
            self._z[i] += self._lambda_param * (z_prox - self._x_old)

        # Update current reconstruction.
        self._x_new = np.sum([z_i * w_i for z_i, w_i in
                              zip(self._z, self._weights)], axis=0)

        # Update old values for next iteration.
        np.copyto(self._x_old, self._x_new)

        # Update parameter values for next iteration.
        self._update_param()

        # Test cost function for convergence.
        if self._cost_func:
            self.converge = self._cost_func.get_cost(self._x_new)
201254
def update_positions(self, positions):
        '''
        '''
        sphs_verts = self.sphs_verts_radii.copy()
        sphs_verts += positions.reshape(self.n_spheres, 1, 3)

        self.tr.update_vertices(sphs_verts)
        self.poslist = positions
852159
def update_all(self):
        
        self.update_points()
        self.update_vertex_list()
        self.update_anchor()

        pyglet.gl.glLoadIdentity()  # reset gl
        pyglet.gl.glLineWidth(self.line_width)
        pyglet.gl.glPointSize(self.point_size)
        self.transform.update_gl()

        # handle shapes click envets
        all_shapes.discard(self)
        if(self._press != None):
            all_shapes.add(self)
792629
public void updateBlocks(World world, MBlockState state)
	{
		AxisAlignedBB[] aabbs = AABBUtils.getCollisionBoundingBoxes(world, state, true);
		for (AxisAlignedBB aabb : aabbs)
		{
			if (aabb == null)
				continue;

			for (BlockPos pos : BlockPosUtils.getAllInBox(aabb))
				world.neighborChanged(pos, state.getBlock(), state.getPos());
		}
	}
768138
def update_all_nodes(self):
        
        item_model_controller = self.item_model_controller
        if item_model_controller:
            if self.__node_counts_dirty:
                for item in self.__mapping.values():
                    if "tree_node" in item.data:  # don't update the root node
                        tree_node = item.data["tree_node"]
                        item.data["display"] = self.__display_for_tree_node(tree_node)
                        item_model_controller.data_changed(item.row, item.parent.row, item.parent.id)
                self.__node_counts_dirty = False