Updates values as if we had iterated over the for
186416
def iterate(self):
        
        self.counter += 1
        self.counter0 += 1
        self.revcounter -= 1
        self.revcounter0 -= 1
        self.first = False
        self.last = (self.revcounter0 == self.len_values - 1)
204104
def update_values!(&b)
            return enum_for(__method__) unless block_given?
            return self.transform_values!(&b) if self.respond_to?(:transform_values!)
            return self.map!(&b) if self.respond_to?(:map!)

            raise NotImplementedError, "This object does not implement this method"
        end
469919
def update(self, other=None, **kwargs):
        ''''''
        copydict = ImmutableDict()
        if other:
            vallist = [(hash(key), (key, other[key])) for key in other]
        else: vallist = []
        if kwargs:
            vallist += [(hash(key), (key, kwargs[key])) for key in kwargs]
        copydict.tree = self.tree.multi_assoc(vallist)
        copydict._length = iter_length(copydict.tree)
        return copydict
791978
def update(self, value):
        
        self.update_internal(value)
        self.emit('changed', self.get_widget_value())
181713
def _update_result(self, result, insertions, dimension_index):
        """"""
        for j, (ind_insertion, value) in enumerate(insertions):
            result = np.insert(
                result, ind_insertion + j + 1, value, axis=dimension_index
            )
        return result
1130794
def _update_nested(key, val, data, allow_overwriting=False):
    
    if isinstance(val, dict):
        for sub_key, sub_val in val.items():
            data = _update_nested(key + [sub_key], sub_val, data, allow_overwriting=allow_overwriting)
    else:
        already_there = tz.get_in(key, data) is not None
        if already_there and val:
            if not allow_overwriting:
                raise ValueError("Duplicated key %s: %s and %s" % (key, val, tz.get_in(key, data)))
            else:
                already_there = False
        if val or not already_there:
            data = tz.update_in(data, key, lambda x: val)
    return data
1062329
def strictly_increasing(values):
    """"""
    return all(x < y for x, y in zip(values, values[1:]))
852464
def update(self, new_vals):
        
        for k, v in six.iteritems(new_vals):
            k = k.strip()
            if k in self.row:
                warnings.warn("Adding history key ({}) that is already set in this step".format(
                    k), wandb.WandbWarning)
            self.row[k] = v
1044381
def update(self, _values=None, **values):
        
        if _values is not None:
            values.update(_values)

        values = OrderedDict(sorted(values.items()))

        bindings = list(values.values()) + self.get_bindings()

        sql = self._grammar.compile_update(self, values)

        return self._connection.update(sql, self._clean_bindings(bindings))
886020
private void updateRemoveR() {
        for( int i = 1; i < n+1; i++ ) {
            for( int j = 0; j < n; j++ ) {
                double sum = 0;
                for( int k = i-1; k <= j; k++ ) {
                    sum += U_tran.data[i*m+k] * R.data[k*n+j];
                }
                R.data[(i-1)*n+j] = sum;
            }
        }
    }
1309558
def _add_updated_at_column(self, values):
        
        if not self._model.uses_timestamps():
            return values

        column = self._model.get_updated_at_column()

        if "updated_at" not in values:
            values.update({column: self._model.fresh_timestamp_string()})

        return values
24085
def difference_update(self, values):
        ''''''
        d = self.value_pickler.dumps
        return self.cache.remove(tuple((d(v) for v in values)))
1294622
def update(self, e=None, **f):
        """"""

        # Handle e first
        if e is not None:
            if hasattr(e, 'keys'):
                for k in e:
                    self[k.title()] = e[k]
            else:
                for (k, v) in e:
                    self[k.title()] = v

        # Now handle f
        if len(f):
            for k in f:
                self[k.title()] = f[k]
222901
def perform_partial_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
837793
private void update(){
        
        int i, n = values.length;

        max = 0;
        min = n;
        total = 0;
        
        int maxVal = -Integer.MAX_VALUE;
        int minVal = Integer.MAX_VALUE;

        // calculate min and max
        for ( i = 0; i < n; i++ )
        {
            if ( values[i] != 0 )
            {
                // max
                if ( i > max )
                    max = i;
                // min
                if ( i < min )
                    min = i;

                maxVal = Math.max(maxVal, values[i]);
                minVal = Math.min(minVal, values[i]);
                total += values[i];
            }
        }
        
        double k = (maxVal - minVal) / (double)bins;
        int[] h = new int[bins];
        
        for (int j = 0; j < values.length; j++) {
            double _min = minVal;
            double _max = _min + k;
            
            //First interval.
            if(values[j] >= _min && values[j] <= _max)
                h[0]++;
            
            _min += k;
            _max += k;
            
            //Others interval.
            for (int l = 1; l < bins; l++) {
                if(values[j] > _min && values[j] <= _max)
                    h[l]++;
                
                _min += k;
                _max += k;
            }
        }
        
        this.values = h;

        mean   = HistogramStatistics.Mean( values );
        stdDev = HistogramStatistics.StdDev( values, mean );
        median = HistogramStatistics.Median( values );
        mode = HistogramStatistics.Mode(values);
        entropy = HistogramStatistics.Entropy(values);
    }
439545
def update_values(self):
        """"""
        self.method = self.idx_method.currentText()
        sw_det = DetectSlowWave(method=self.method)

        self.index['f1'].set_value(sw_det.det_filt['freq'][0])
        self.index['f2'].set_value(sw_det.det_filt['freq'][1])
        self.index['min_trough_dur'].set_value(sw_det.trough_duration[0])
        self.index['max_trough_dur'].set_value(sw_det.trough_duration[1])
        self.index['max_trough_amp'].set_value(sw_det.max_trough_amp)
        self.index['min_ptp'].set_value(sw_det.min_ptp)
        self.index['min_dur'].set_value(sw_det.min_dur)
        self.index['max_dur'].set_value(sw_det.max_dur)
285762
def difference_update(self, other):
		""""""
		other = set(other)
		indices_to_delete = set()
		for i, elem in enumerate(self):
			if elem in other:
				indices_to_delete.add(i)
		if indices_to_delete:
			self._delete_values_by_index(indices_to_delete)