Scale the objects represented by *selections* up to a
        certain *factor*.
549488
def scale(self, selections, factor):
        '''

        '''
        if 'atoms' in selections:
            atms = selections['atoms'].mask
            if factor is None:
                    self.scale_factors[atms] = 1.0
            else:
                self.scale_factors[atms] = factor
    
        self.update_scale_factors(self.scale_factors)
230291
function scaleRow (M, row, scale) {
  const me = M.elements;
  let i = row;
  let alpha = (scale === undefined ? 1.0 : scale);
  me[i] *= alpha;
  me[i + 3] *= alpha;
  me[i + 6] *= alpha;
}
1156507
def scale(input_value, input_min, input_max, out_min, out_max):
    
    # Figure out how 'wide' each range is
    input_span = input_max - input_min
    output_span = out_max - out_min
    # Convert the left range into a 0-1 range (float)
    valuescaled = float(input_value - input_min) / float(input_span)
    # Convert the 0-1 range into a value in the right range.
    return out_min + (valuescaled * output_span)
23539
def Scale(self, factor):
        
        new = self.Copy()
        new.d.clear()

        for val, prob in self.Items():
            new.Set(val * factor, prob)
        return new
837065
def scale_atoms(fac):
    '''

    '''
    rep = current_representation()
    atms = selected_atoms()
    rep.scale_factors[atms] = fac
    
    rep.update_scale_factors(rep.scale_factors)
    viewer.update()
612046
public void scale(double scaleX, double scaleY) {
		this.m00 *= scaleX;
		this.m11 *= scaleY;
		this.m01 *= scaleY;
		this.m10 *= scaleX;
	}
1285508
def _rescale(self, points):
        """"""
        return [(
            x, self._scale_diff + (y - self._scale_min_2nd) * self._scale
            if y is not None else None
        ) for x, y in points]
766988
def scaleY(self, y):
        ''
        return round(self.plotviewBox.ymin+(y-self.visibleBox.ymin)*self.yScaler)
446686
public static void scale( double alpha , DMatrix2 a ) {
        a.a1 *= alpha;
        a.a2 *= alpha;
    }
149605
def widen(self):
        """"""
        t, h = self.time, self.half_duration
        h *= self.scaling_coeff_x
        self.set_interval((t - h, t + h))
211982
def _linearly_scale(inputmatrix, inputmin, inputmax, outputmin, outputmax):
    """"""
    inputrange = inputmax - inputmin
    outputrange = outputmax - outputmin
    delta = outputrange/inputrange  # number of indices per input unit
    inputmin = inputmin + 1.0 / delta / 2.0  # shift to center of index
    outputmax = outputmax - 1  # shift index to zero indexing
    outputmatrix = (inputmatrix - inputmin) * delta + outputmin
    err = IndexError('Input, %g, is out of range (%g, %g).' %
                     (inputmatrix, inputmax - inputrange, inputmax))
    # round down if input is within half an index or else raise index error
    if outputmatrix > outputmax:
        if np.around(outputmatrix - outputmax, 1) <= 0.5:
            outputmatrix = outputmax
        else:
            raise err
    elif outputmatrix < outputmin:
        if np.around(outputmin - outputmatrix, 1) <= 0.5:
            outputmatrix = outputmin
        else:
            raise err
    return outputmatrix
655445
def set_scale(self):
        """"""

        f_min = float(self.lower_freq)
        f_max = float(self.higher_freq)
        y_min = f_min
        y_max = f_max
        for y in range(self.image_height):
            freq = y_min + y / (self.image_height - 1.0) * (y_max - y_min)
            fft_bin = freq / f_max * (self.fft_size / 2 + 1)
            if fft_bin < self.fft_size / 2:
                alpha = fft_bin - int(fft_bin)
                self.y_to_bin.append((int(fft_bin), alpha * 255))
664695
def scale_to_vol(self, vol):
        """"""

        f = (vol / self.vol_ball) ** (1.0 / self.n)  # linear factor
        self.expand *= f
        self.radius *= f
        self.vol_ball = vol
412438
function () {
    this.rings.forEach(function (ringEl) {
      var scale = ringEl.getComputedAttribute('scale');
      ringEl.setAttribute('scale', {
        x: scale.x * 1.06 + .05,
        y: scale.y * 1.06 + .05,
        z: scale.z
      });
    });
  }
773781
@Api
	public void setScales(Double... scales) {
		// Sort decreasing and store the list:
		Arrays.sort(scales, Collections.reverseOrder());
		scaleList = Arrays.asList(scales);
		// Apply the requested scales on the SelectItem. Make sure only available scales are added:
		updateScaleList();
	}
280862
def ScaleLarger(self):
    """"""
    newfactor = self._zoomfactor + 0.1
    if float(newfactor) > 0 and float(newfactor) < self._MAX_ZOOM:
      self._zoomfactor = newfactor
1794
def stretch(self, scale_factor, callback=True):
        
        self.scale_pct *= scale_factor
        self.scale_and_shift(self.scale_pct, 0.0, callback=callback)