Update the radii inplace
336651
def update_radii(self, radii):
        ''''''
        self.radii = np.array(radii, dtype='float32')
        prim_radii = self._gen_radii(self.radii)
        
        self._radii_vbo.set_data(prim_radii)
        self.widget.update()
1115905
def replace_coord(arr, old_dim, new_dim, new_coord):
    """"""
    new_arr = arr.rename({old_dim: new_dim})
    new_arr[new_dim] = new_coord
    return new_arr
76140
function(r) {
			geo.origin.size.height = r.height,
				geo.origin.windowOffset.left = r.left,
				geo.origin.windowOffset.top = r.top,
				geo.origin.size.width = r.width
		}
99003
def update(self):
        
        # this is not really neccesary because the surface is black after initializing
        self.corners.fill(BLACK)
        self.corners.draw_dot((0, 0), self.colors[0])
        self.corners.draw_dot((self.screen.width - 1, 0), self.colors[0])
        self.corners.draw_dot((self.screen.width - 1, self.screen.height - 1),
                              self.colors[0])
        self.corners.draw_dot((0, self.screen.height - 1), self.colors[0])

        self.lines.fill(BLACK)
        self.lines.draw_line((1, 0), (self.lines.width - 1, 0), self.colors[1])
        self.lines.draw_line((0, 1), (0, self.lines.height - 1), self.colors[3])
        self.lines.draw_line((0, 0), (self.lines.width - 1,
                                      self.lines.height - 1), self.colors[2])

        self.rects.fill(BLACK)
        self.rects.draw_rect((0, 0), (int(self.rects.width / 2) - 1,
                                      self.rects.height),
                             self.colors[2], self.colors[3])
        self.rects.draw_rect((int(self.rects.width / 2) + 1, 0),
                             (int(self.rects.width / 2) - 1,
                              self.rects.height),
                             self.colors[3], self.colors[2])

        self.circle.fill(BLACK)
        radius = int(min(self.circle.width, self.circle.height) / 2) - 1
        self.circle.draw_circle((int(self.circle.width / 2) - 1,
                                 int(self.circle.height / 2) - 1), radius,
                                self.colors[4], self.colors[5])

        self.filled.fill(self.colors[6])
1188717
def resizeToMinimum(self):
        
        offset = self.padding()
        min_size = self.minimumPixmapSize()
        
        if self.position() in (XDockToolbar.Position.East,
                               XDockToolbar.Position.West):
            self.resize(min_size.width() + offset, self.height())
        
        elif self.position() in (XDockToolbar.Position.North,
                                 XDockToolbar.Position.South):
            self.resize(self.width(), min_size.height() + offset)
458554
def _update_cred(self):
        
        ui = self.c[self._inds, self._x] - self._v[self._x]
        self.cred = self.c - ui[:, None] - self._v[None, :]
993214
def resize(self, width, height):
        """"""
        SetWindowPos(self._hwnd, None, 0, 0, width, height, SWP_NOMOVE)
175687
def update_frame(self):
        
        d = self.declaration
        if d.x or d.y or d.width or d.height:
            self.frame = (d.x, d.y, d.width, d.height)
606367
function updateWidth() {
        if (isNaN(attrs.width)) {
          element.css('width', attrs.width);
        } else {
          element.css('width', attrs.width + 'px');
        }
      }
1049277
def fix(h, i):
    """"""
    down(h, i, h.size())
    up(h, i)
968448
public void update() {
        if (settings != null && getWidth() > 0 && getHeight() > 0) {
            // Updating finder area rectangle
            GravityUtils.getMovementAreaPosition(settings, tmpRect);
            rect.set(tmpRect);
            rect.offset(getPaddingLeft(), getPaddingTop());

            // We want to stroke outside of finder rectangle, while by default stroke is centered
            strokeRect.set(rect);
            float halfStroke = 0.5f * paintStroke.getStrokeWidth();
            strokeRect.inset(-halfStroke, -halfStroke);

            invalidate();
        }
    }
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
1081987
def update(self, newinfo):
        ''''''
        self.imgstr = newinfo.imgstr
        self.width = newinfo.width
        self.height = newinfo.height
        if self.imgpanel is not None:
            self.imgpanel.set_image(self.img())
528388
def update(self, other, inplace=True):
        
        return self.append(other, inplace=inplace, resize=False)
565687
def update_rho(self, k, r, s):
        """"""

        if self.opt['AutoRho', 'Enabled']:
            tau = self.rho_tau
            mu = self.rho_mu
            xi = self.rho_xi
            if k != 0 and np.mod(k + 1, self.opt['AutoRho', 'Period']) == 0:
                if self.opt['AutoRho', 'AutoScaling']:
                    if s == 0.0 or r == 0.0:
                        rhomlt = tau
                    else:
                        rhomlt = np.sqrt(r / (s * xi) if r > s * xi else
                                         (s * xi) / r)
                        if rhomlt > tau:
                            rhomlt = tau
                else:
                    rhomlt = tau
                rsf = 1.0
                if r > xi * mu * s:
                    rsf = rhomlt
                elif s > (mu / xi) * r:
                    rsf = 1.0 / rhomlt
                self.rho *= self.dtype.type(rsf)
                self.U /= rsf
                if rsf != 1.0:
                    self.rhochange()
737419
def __update(self):
        

        # I can not set the size attr because it is my property, so I set the width and height separately
        width, height = self.size
        super(BaseWidget, self).__setattr__("width", width)
        super(BaseWidget, self).__setattr__("height", height)
        super(BaseWidget, self).__setattr__(self.anchor, self.pos)
38332
private void updateRadius() {
		if (isPressed()) {
			if (currentRadius <= getEndRippleRadius()) {
				currentRadius += RADIUS_INCREMENT;
			}
		} else {
			if (isDrawingInProgress()) {
				currentRadius = getEndRippleRadius();
			} else if (isDrawingFinished()) {
				currentRadius = 0;
			}
		}
		LOGGER.trace("Updated Ripple Effect radius to: {}", currentRadius);
	}