Set new minuend & subtrahend.
@param {basis.data.ReadOnlyDataset=} minuend
@param {basis.data.ReadOnlyDataset=} subtrahend
@return {object|boolean} Delta if changes happend
499671
function(minuend, subtrahend){
    var delta;
    var operandsChanged = false;
    var oldMinuend = this.minuend;
    var oldSubtrahend = this.subtrahend;

    minuend = resolveDataset(this, this.setMinuend, minuend, 'minuendRA_');
    subtrahend = resolveDataset(this, this.setSubtrahend, subtrahend, 'subtrahendRA_');

    // set new minuend if changed
    if (oldMinuend !== minuend)
    {
      operandsChanged = true;
      this.minuend = minuend;

      var listenHandler = this.listen.minuend;
      if (listenHandler)
      {
        if (oldMinuend)
          oldMinuend.removeHandler(listenHandler, this);

        if (minuend)
          minuend.addHandler(listenHandler, this);
      }

      this.emit_minuendChanged(oldMinuend);
    }

    // set new subtrahend if changed
    if (oldSubtrahend !== subtrahend)
    {
      operandsChanged = true;
      this.subtrahend = subtrahend;

      var listenHandler = this.listen.subtrahend;
      if (listenHandler)
      {
        if (oldSubtrahend)
          oldSubtrahend.removeHandler(listenHandler, this);

        if (subtrahend)
          subtrahend.addHandler(listenHandler, this);
      }

      this.emit_subtrahendChanged(oldSubtrahend);
    }

    if (!operandsChanged)
      return false;

    /** @cut */ basis.dev.setInfo(this, 'sourceInfo', {
    /** @cut */   type: 'Subtract',
    /** @cut */   source: [minuend, subtrahend]
    /** @cut */ });

    // apply changes
    if (!minuend || !subtrahend)
    {
      if (this.itemCount)
        this.emit_itemsChanged(delta = {
          deleted: this.getItems()
        });
    }
    else
    {
      var deleted = [];
      var inserted = [];

      for (var key in this.items_)
        if (!minuend.items_[key] || subtrahend.items_[key])
          deleted.push(this.items_[key]);

      for (var key in minuend.items_)
        if (!this.items_[key] && !subtrahend.items_[key])
          inserted.push(minuend.items_[key]);

      if (delta = getDelta(inserted, deleted))
        this.emit_itemsChanged(delta);
    }

    return delta;
  }
620567
void setValue(SubProgressionModel subTask, double newValue, String comment) {
		setProperties(newValue, this.min, this.max, this.isAdjusting,
				comment == null ? this.comment : comment, true, true, false,
				subTask);
	}
810163
public static int delta(int[] data, int start, int length, int init) {
                final int nextinit = data[start + length - 1];
                for (int i = length - 1; i > 0; --i) {
                        data[start + i] -= data[start + i - 1];
                }
                data[start] -= init;
                return nextinit;
        }
1039665
def update(self, deltat=1.0):
        ''''''
        DNFZ.update(self, deltat)
        self.lifetime -= deltat
        if self.lifetime <= 0:
            self.randpos()
            self.lifetime = random.uniform(300,600)
186249
@Override
	public void setY(double min, double max) {
		if (min <= max) {
			this.miny = min;
			this.maxy = max;
		} else {
			this.miny = max;
			this.maxy = min;
		}
	}
860488
def _setextra(self, extradata):
        '''
        
        '''
        current = self
        while hasattr(current, '_sub'):
            current = current._sub
        _set(current, '_extra', extradata)
943041
public void setMin(Double min) {
        String minStr = doubleToNiceStr(min);
        JQMCommon.setAttribute(input, "min", minStr);
        refreshMin(input.getElement().getId(), minStr);
        validateValue();
    }
126098
public void setMinValue(final double MIN_VALUE) {
        // check min-max values
        if (Double.compare(MIN_VALUE, maxValue) == 0) {
            throw new IllegalArgumentException("Min value cannot be equal to max value");
        }

        if (Double.compare(MIN_VALUE, maxValue) > 0) {
            minValue = maxValue;
            maxValue = MIN_VALUE;
        } else {
            minValue = MIN_VALUE;
        }
        calculate();
        validate();
        calcAngleStep();
        fireStateChanged();
    }
280725
function( min, startFunc ) {
		var self = this;

		if ( min > self.state ) {
			self._stateError( startFunc || self.requireMinState );
		}

		return self;
	}
797337
def set(self, value, samples=0):
        '''
        
        '''
        if self.params.length > self.pos and samples > 0:
            l = min(samples, self.params.length-self.pos)
            self.data[self.pos:self.pos+l] = np.full(l, value, dtype=np.float)
            self.pos += l
        self.latest = value
        return self
661990
private static BigDecimal doSubtract(final BigDecimal v1, final BigDecimal v2) {
        BigDecimal diff = v1;
        if (v1 != null && v2 != null) {
            diff = v1.subtract(v2);
        } else if (v2 != null) {
            diff = v2.negate();
        }
        return diff;
    }
971492
function deltaReverse(arg, increment) {
  let newIdx = arg.idx + arg.direction * increment;
  if (newIdx >= arg.values.length) {
    arg.direction *= -1; // Reverse direction
    newIdx = arg.values.length - 2;
  }

  if (newIdx < 0) {
    arg.direction *= -1; // Reverse direction
    newIdx = 1;
  }

  if (newIdx >= 0 && newIdx < arg.values.length) {
    arg.idx = newIdx;
  }

  return true;
}
1344751
function(offset, limit){
    var oldOffset = this.offset;
    var oldLimit = this.limit;
    var delta = false;

    if (oldOffset != offset || oldLimit != limit)
    {
      this.offset = offset;
      this.limit = limit;

      delta = this.applyRule();

      this.emit_rangeChanged(oldOffset, oldLimit);
    }

    return delta;
  }
395899
function deltaNone(arg, increment) {
  let newIdx = arg.idx + increment;

  if (newIdx >= arg.values.length) {
    newIdx = arg.values.length - 1;
  }

  if (newIdx < 0) {
    newIdx = 0;
  }

  if (arg.idx !== newIdx) {
    arg.idx = newIdx;
    return true;
  }

  return false;
}
768203
public AABBf setMin(float minX, float minY, float minZ) {
        this.minX = minX;
        this.minY = minY;
        this.minZ = minZ;
        return this;
    }
246556
function reduce() {
		var delta = 0;
		/**
		* FUNCTION: reduce( acc, data )
		*	Defines the data reduction.
		*
		* @private
		* @param {object} acc - accumulation object containing three properties: N, mean, sos. 'N' is the observation number accumulator; 'mean' is the mean accumulator; 'sos' is the sum of squared differences accumulator
		* @param {number} data - numeric stream data
		* @returns {object} accumulation object
		*/
		return function reduce( acc, x ) {
			// SOS = Sum of Squared Differences
			acc.N += 1;
			delta = x - acc.mean;
			acc.mean += delta / acc.N;
			acc.sos += delta * ( x-acc.mean );
			return acc;
		};
	}
109635
private float MIN(float first, float second, float third) {

        float min = Integer.MAX_VALUE;
        if (first < min) {
            min = first;
        }
        if (second < min) {
            min = second;
        }
        if (third < min) {
            min = third;
        }
        return min;
    }