Updates current accuracy flag
434954
def updateAccuracy(self, *accuracy):
        
        for acc in accuracy:
            if not isinstance(acc, int):
                acc = self._ACCURACY_REVERSE_MAPPING[acc]
            self.accuracy |= acc
86322
def _update(self, baseNumber, magnification):
        '''
        '''
        interval = int(baseNumber * magnification)
        self.value = [IntegerSingle(interval)]
118058
def update(self, labels, preds):
        
        # get generated multi label from network
        cls_prob = preds[0].asnumpy()
        loc_loss = preds[1].asnumpy()
        cls_label = preds[2].asnumpy()
        valid_count = np.sum(cls_label >= 0)
        # overall accuracy & object accuracy
        label = cls_label.flatten()
        mask = np.where(label >= 0)[0]
        indices = np.int64(label[mask])
        prob = cls_prob.transpose((0, 2, 1)).reshape((-1, cls_prob.shape[1]))
        prob = prob[mask, indices]
        self.sum_metric[0] += (-np.log(prob + self.eps)).sum()
        self.num_inst[0] += valid_count
        # smoothl1loss
        self.sum_metric[1] += np.sum(loc_loss)
        self.num_inst[1] += valid_count
371674
def update_data(self):
        
        if self.sk8 is not None:
            imu = self.spinIMU.value()
            data = self.sk8.get_imu(imu)
            if self.current_imuid in self.calibration_data:
                calib_data = self.calibration_data[self.current_imuid]
            else:
                calib_data = {}
                self.calibration_data[self.current_imuid] = calib_data

            if calib_data is not None and self.ACC_TIMESTAMP in calib_data:
                self.dataAccX.setText(str(int((data.acc[0] * float(calib_data[self.ACCX_SCALE])) - float(calib_data[self.ACCX_OFFSET]))))
                self.dataAccY.setText(str(int((data.acc[1] * float(calib_data[self.ACCY_SCALE])) - float(calib_data[self.ACCY_OFFSET]))))
                self.dataAccZ.setText(str(int((data.acc[2] * float(calib_data[self.ACCZ_SCALE])) - float(calib_data[self.ACCZ_OFFSET]))))
            else:
                self.dataAccX.setText(str(data.acc[0]))
                self.dataAccY.setText(str(data.acc[1]))
                self.dataAccZ.setText(str(data.acc[2]))

            if calib_data is not None and self.GYRO_TIMESTAMP in calib_data:
                self.dataGyroX.setText(str(data.gyro[0] - int(calib_data[self.GYROX_OFFSET])))
                self.dataGyroY.setText(str(data.gyro[1] - int(calib_data[self.GYROY_OFFSET])))
                self.dataGyroZ.setText(str(data.gyro[2] - int(calib_data[self.GYROZ_OFFSET])))
            else:
                self.dataGyroX.setText(str(data.gyro[0]))
                self.dataGyroY.setText(str(data.gyro[1]))
                self.dataGyroZ.setText(str(data.gyro[2]))

            if calib_data is not None and self.MAG_TIMESTAMP in calib_data:
                self.dataAccX.setText(str(int((data.mag[0] * float(calib_data[self.MAGX_SCALE])) - float(calib_data[self.MAGX_OFFSET]))))
                self.dataAccY.setText(str(int((data.mag[1] * float(calib_data[self.MAGY_SCALE])) - float(calib_data[self.MAGY_OFFSET]))))
                self.dataAccZ.setText(str(int((data.mag[2] * float(calib_data[self.MAGZ_SCALE])) - float(calib_data[self.MAGZ_OFFSET]))))
            else:
                self.dataMagX.setText(str(data.mag[0]))
                self.dataMagY.setText(str(data.mag[1]))
                self.dataMagZ.setText(str(data.mag[2]))
623711
public void notifyModified(int flags) {
		if (flags == DirtyFlags.DirtyAll) {
			m_reservedPointCount = -1;// forget the reserved point number
			_notifyModifiedAllImpl();
		}
		m_flagsMask |= flags;

		_clearAccelerators();
		_touch();
	}
1165247
def _update_Prxy(self):
        """"""
        self.Prxy = self.Frxy * self.Qxy
        _fill_diagonals(self.Prxy, self._diag_indices)
1047020
def AddAccuracy(model, softmax, label):
    """"""
    accuracy = brew.accuracy(model, [softmax, label], "accuracy")
    return accuracy
493674
def set_flag(self, info, code=None):
        """"""
        self.flag = True
        self.flag_info += info
        if code is not None:
            self.flag_code = code
88901
def update(self, td):
        """"""
        self.sprite.last_position = self.sprite.position
        self.sprite.last_velocity = self.sprite.velocity
        if self.particle_group != None:
            self.update_particle_group(td)
1124971
def updateCalibration(self):
        """"""
        if self.samplerate() != self._calibration_fs:
            self.setCalibration(self._attenuationVector, self._calFrequencies, self._calFrange)
627827
async def update_flags(self, messages: Sequence[MessageT],
                           flag_set: FrozenSet[Flag], mode: FlagOp) -> None:
        
        ...
514852
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi1*con.tind)
1129456
def refresh(cls):
        
        # clear the old values in _flag_map
        try:
            del cls._flag_map["t"]
        except KeyError:
            pass

        try:
            del cls._flag_map["-"]
        except KeyError:
            pass

        # set the value given the git version
        if Git().version_info[:2] >= (2, 10):
            cls._flag_map["t"] = cls.TAG_UPDATE
        else:
            cls._flag_map["-"] = cls.TAG_UPDATE

        return True
216526
def update_target(self, name, current, total):
        """"""
        self.refresh(self._bar(name, current, total))
1081964
function (oldProps) {
      var didUpdate = updateObject(this.state.chart, oldProps, this.props);

      // TODO make this faster
      if (didUpdate) {
        this.state.chart.validateNow(true);
      }
    }
57546
def update(self, deltat=1.0):
        ''''''
        DNFZ.update(self, deltat)
        self.time_circling += deltat
        self.setheading(self.heading + self.turn_rate * deltat)
        self.move(self.drift_heading, self.drift_speed)
        if self.getalt() > self.max_alt or self.getalt() < self.ground_height():
            if self.getalt() > self.ground_height():
                self.setclimbrate(self.dive_rate)
            else:
                self.setclimbrate(self.climb_rate)
        if self.getalt() < self.ground_height():
            self.setalt(self.ground_height())
        if self.distance_from_home() > gen_settings.region_width:
            self.randpos()
            self.randalt()
337718
def update_status(self, progress):
        

        # interval at which the gui will be updated, if requests come in faster than they will be ignored
        update_interval = 0.2

        now = datetime.datetime.now()

        if not self._last_progress_update is None and now-self._last_progress_update < datetime.timedelta(seconds=update_interval):
            return

        self._last_progress_update = now

        self.progressBar.setValue(progress)

        script = self.current_script

        # Estimate remaining time if progress has been made
        if progress:
            remaining_time = str(datetime.timedelta(seconds=script.remaining_time.seconds))
            self.lbl_time_estimate.setText('time remaining: {:s}'.format(remaining_time))
        if script is not str(self.tabWidget.tabText(self.tabWidget.currentIndex())).lower() in ['scripts', 'instruments']:
            self.plot_script(script)