Updates positions using the calculations provided with [[getCalculation]].
195114
private function applyCalculations()
    {
        $currency = Yii::$app->params['currency'];

        foreach ($this->models as $position) {
            $id = $position->id;

            $calculation = $this->getCalculation($id);
            if (!$calculation instanceof Calculation) {
                Yii::error('Cart position "' . $position->getName() . '" was removed from the cart because of failed value calculation. Normally this should never happen.', 'hipanel.cart');
                $this->cart->removeById($position->id);
                break;
            }

            $value = $calculation->forCurrency($currency);
            if (!$value instanceof Value) {
                Yii::error('Cart position "' . $position->getName() . '" was removed from the cart because calculation for currency "' . $currency . '" is not available', 'hipanel.cart');
                $this->cart->removeById($position->id);
                break;
            }

            $position->setPrice($value->price);
            $position->setValue($value->value);
        }
    }
178169
def updateRPYLocations(self):
        ''''''
        # Locations
        self.rollText.set_position((self.leftPos+(self.vertSize/10.0),-0.97+(2*self.vertSize)-(self.vertSize/10.0)))
        self.pitchText.set_position((self.leftPos+(self.vertSize/10.0),-0.97+self.vertSize-(0.5*self.vertSize/10.0)))
        self.yawText.set_position((self.leftPos+(self.vertSize/10.0),-0.97))
        # Font Size
        self.rollText.set_size(self.fontSize)
        self.pitchText.set_size(self.fontSize)
        self.yawText.set_size(self.fontSize)
411330
private void updateStatistics() {
        final PNCounterService service = getService();
        final LocalPNCounterStatsImpl stats = service.getLocalPNCounterStats(name);
        if (delta > 0) {
            stats.incrementIncrementOperationCount();
        } else if (delta < 0) {
            stats.incrementDecrementOperationCount();
        }
        stats.setValue(getBeforeUpdate ? (response.getValue() + delta) : response.getValue());
    }
675193
function () {
            this._calculatePosition();
            this._calculateSize();
            this.setProperty("center", false);
            if (this._popup) {
                this._onDimensionsChanged();
                this._popup.refreshProcessingIndicators();
            }
            this.evalCallback(this._cfg.resizeend);
        }
629062
protected void updateBox ()
    {
        int hmin = _horz.getMinimum();
        int vmin = _vert.getMinimum();
        _hFactor = (_active.width) / (float) (_horz.getMaximum() - hmin);
        _vFactor = (_active.height) / (float) (_vert.getMaximum() - vmin);

        _box.x = _active.x + Math.round((_horz.getValue() - hmin) * _hFactor);
        _box.width = Math.round(_horz.getExtent() * _hFactor);
        _box.y = _active.y + Math.round((_vert.getValue() - vmin) * _vFactor);
        _box.height = Math.round(_vert.getExtent() * _vFactor);
    }
208749
def update(self):
        """"""
        con = self.subpars.pars.control
        self(con.ypoints.shape[0])
644833
@Override
  public void updatePosition(float verticalDragOffset) {
    int right = getViewRightPosition(verticalDragOffset);
    int left = right - layoutParams.width;
    int top = getView().getTop();
    int bottom = top + layoutParams.height;

    getView().layout(left, top, right, bottom);
  }
812136
void updateCount() {
		if (this.hasChanged) {
			this.positionArray = ArrayUtils.toPrimitive(getPositionList()
					.toArray(new Long[0]));
			this.hasChanged = false;
		}
	}
181896
def _update_position(self, change):
        
        if change['type']!='update':
            return
        pt = gp_Pnt(self.x,self.y,self.z)
        if not pt.IsEqual(self.position,self.tolerance):
            self.position = pt
1353318
def _update(self, data):
        """"""
        for k, v in six.iteritems(data):
            new_value = v
            if isinstance(v, dict):
                new_value = type(self)(v)
            elif isinstance(v, list):
                new_value = [(type(self)(e) if isinstance(e, dict) else e)
                             for e in v]
            setattr(self, k, new_value)
685693
def _update(self):
        """"""

        if self.strains.size and self.strains.size == self.values.size:
            x = np.log(self.strains)
            y = self.values

            if x.size < 4:
                self._interpolater = interp1d(
                    x,
                    y,
                    'linear',
                    bounds_error=False,
                    fill_value=(y[0], y[-1]))
            else:
                self._interpolater = interp1d(
                    x,
                    y,
                    'cubic',
                    bounds_error=False,
                    fill_value=(y[0], y[-1]))
1263571
private void update() {
        if (!predefinedPriori) {
            for (int c = 0; c < k; c++) {
                priori[c] = (nc[c] + EPSILON) / (n + k * EPSILON);
            }
        }

        if (model == Model.MULTINOMIAL || model == Model.POLYAURN) {
            for (int c = 0; c < k; c++) {
                for (int t = 0; t < p; t++) {
                    condprob[c][t] = (ntc[c][t] + sigma) / (nt[c] + sigma * p);
                }
            }
        } else {
            for (int c = 0; c < k; c++) {
                for (int t = 0; t < p; t++) {
                    condprob[c][t] = (ntc[c][t] + sigma) / (nc[c] + sigma * 2);
                }
            }
        }
    }
59207
private void performUpdate(final Vec x, final double y, final double yHat)
    {
        for(IndexValue iv : x)
        {
            final int j = iv.getIndex();
            w.set(j, 
                    T(w.get(j)+2*learningRate*(y-yHat)*iv.getValue(), 
                    ((time-t[j])/K)*gravity*learningRate,
                    threshold));
            
            t[j] += ((time-t[j])/K)*K;
        }
    }
918308
public void updatePosition() {

        setPosition(CmsPositionBean.getBoundingClientRect(m_element));
        for (Widget widget : m_buttonPanel) {
            if (widget instanceof CmsInlineEntityWidget) {
                ((CmsInlineEntityWidget)widget).positionWidget();
            }
        }
    }
567211
protected void update() {
        int sz = dataModel.getSize();
        int[] selected = helperList.getSelectedIndices();
        ArrayList sourceItems = new ArrayList(sz);
        ArrayList chosenItems = new ArrayList(selected.length);

        // Start with the source items filled from our data model
        for (int i = 0; i < sz; i++) {
            sourceItems.add(dataModel.getElementAt(i));
        }

        // Now move the selected items to the chosen list
        for (int i = selected.length - 1; i >= 0; i--) {
            chosenItems.add(sourceItems.remove(selected[i]));
        }

        Collections.reverse(chosenItems); // We built it backwards

        // Now install the two new lists
        sourceList.setListData(sourceItems.toArray());
        chosenList.setListData(chosenItems.toArray());
    }
1016250
public function updateTotals()
    {
        if (is_array($this->totals)) {
            foreach ($this->totals as $key => $val) {
                if (is_object($this->current_row[$key])) {
                    continue;
                }
                $this->totals[$key] = $val + $this->current_row[$key];
            }
        }
    }
414235
function (positionChangeData) {
                var _this = this;
                // update positions according to current position change
                this.updatePosition(positionChangeData);
                // for each direction:
                // 1. filter the _points that have a role as the direction's limit
                // 2. for top and left find max x | y values, and min for right and bottom
                this.limitDirections.forEach(function (direction) {
                    /** @type {?} */
                    var relevantPoints = _this._points.filter(function (point) {
                        return point.roles.includes(direction);
                    })
                        .map(function (point) {
                        return point[_this.getDirectionAxis(direction)];
                    });
                    /** @type {?} */
                    var limit;
                    if (direction === 'top' || direction === 'left') {
                        limit = Math.max.apply(Math, __spread(relevantPoints));
                    }
                    if (direction === 'right' || direction === 'bottom') {
                        limit = Math.min.apply(Math, __spread(relevantPoints));
                    }
                    _this._limits[direction] = limit;
                });
                this.limits.next(this._limits);
                this.positions.next(Array.from(this._points));
            }