Multiply each value of  avector by a constant value.
426616
void multiply_constant(double x)
    {
        for (Map.Entry<Integer, Double> entry : entrySet())
        {
            entry.setValue(entry.getValue() * x);
        }
    }
528261
def get_val(self, x):
        """"""
        interval, mean, std = self.probability_map[x]
        new_val = norm.rvs(mean, std)
        return new_val
639577
def Increment(self, delta, fields=None):
    """"""
    if delta < 0:
      raise ValueError(
          "Counter increment should not be < 0 (received: %d)" % delta)

    self._metric_values[_FieldsToKey(fields)] = self.Get(fields=fields) + delta
64506
def _rapply(d, func, *args, **kwargs):
    """"""
    if isinstance(d, (tuple, list)):
        return [_rapply(each, func, *args, **kwargs) for each in d]
    if isinstance(d, dict):
        return {
            key: _rapply(value, func, *args, **kwargs) for key, value in iteritems(d)
        }
    else:
        return func(d, *args, **kwargs)
1201617
def increment(self, member, amount=1):
        """"""
        self._dict[member] += amount
        return self._dict[member]
100563
def _multiply(self, x1, x2, out):
        """"""
        self.tspace._multiply(x1.tensor, x2.tensor, out.tensor)
122249
public int multiply(int x , int y ) {
		if( x==0 || y == 0)
			return 0;
		return exp[ log[x] + log[y]];
	}
1307600
def Mult(self, x, factor):
        
        self.d[x] = self.d.get(x, 0) * factor
713460
def increment(self, delta=1, text=None):
        """"""
        return self.update(value=min(self.max, self.value + delta), text=text)
1323136
def increment(self, n=1):
        
        with self.count.get_lock():
            self.count.value += n
730203
def pretty_constants(self):
        

        for i in range(1, len(self.consts)):
            t, v = self.pretty_const(i)
            if t:
                yield (i, t, v)
815111
private void simpleIncrement(TensorBase other, double multiplier) {
    Preconditions.checkArgument(Arrays.equals(other.getDimensionNumbers(), getDimensionNumbers()));
    if (other instanceof DenseTensorBase) {
      double[] otherTensorValues = ((DenseTensorBase) other).values;
      Preconditions.checkArgument(otherTensorValues.length == values.length);
      int length = values.length;
      for (int i = 0; i < length; i++) {
        values[i] += otherTensorValues[i] * multiplier;
      }
    } else {
      int otherSize = other.size();
      for (int i = 0; i < otherSize; i++) {
        long keyNum = other.indexToKeyNum(i);
        double value = other.getByIndex(i);
        values[keyNumToIndex(keyNum)] += value * multiplier;
      }
    }
  }
354658
def frange(start, stop, step, precision):
    """"""
    value = start
    while round(value, precision) < stop:
        yield round(value, precision)
        value += step
786874
def _round(self, multiple=1):
        
        for pair, value in self.items():
            value = int(normalizers.normalizeRounding(
                value / float(multiple))) * multiple
            self[pair] = value
339353
public int multiply(int x, int y) {
    assert(x >= 0 && x < getFieldSize() && y >= 0 && y < getFieldSize());
    return mulTable[x][y];
  }
1024479
private static void scale(double constant, double vector[]) {
        if (constant == 1.0) return;
        for (int i = 0; i < vector.length; i++) {
            vector[i] *= constant;
        }

    }
441032
def mul(self, *args, **kwargs):
        
        return self._apply(operator.mul, *args, **kwargs)