random Value is written.
424198
public final AutoBuffer write_impl( AutoBuffer ab ) {
    _write_lock = true;
    try {
      if (map().size() == 0) return ab.put1(0); // empty map
      Entry<K, V> entry = map().entrySet().iterator().next();
      K key = entry.getKey();
      V val = entry.getValue();
      assert key != null && val != null;
      int mode;
      if (key instanceof String) {
        if (val instanceof String) {
          mode = 1;
        } else {
          assert (val instanceof Freezable || val instanceof Freezable[]):"incompatible class " + val.getClass();
          mode = val instanceof Freezable ? 2 : 5;
        }
      } else {
        assert key instanceof Iced;
        if (val instanceof String) {
          mode = 3;
        } else {
          assert (val instanceof Freezable || val instanceof Freezable[]);
          mode = val instanceof Freezable ? 4 : 6;
        }
      }
      ab.put1(mode);              // Type of hashmap being serialized
      writeMap(ab, mode);          // Do the hard work of writing the map
      return isStringKey(mode) ? ab.putStr(null) : ab.put(null);
    } catch(Throwable t){
      System.err.println("Iced hash map serialization failed! " + t.toString() + ", msg = " + t.getMessage());
      t.printStackTrace();
      throw H2O.fail("Iced hash map serialization failed!" + t.toString() + ", msg = " + t.getMessage());
    } finally {
      _write_lock = false;
    }
  }
442149
def rand_str(allowed, length):
    
    if (not isinstance(length, int)) or (length <= 0):
        raise Exception("length parameter has to be an integer greater than 0!")
    
    res = list()
    for _ in range(length):
        res.append(random.choice(allowed))
    return "".join(res)
967819
public static String randomString( char[] values, int len )
    {
        Random rnd = new SecureRandom();
        StringBuilder sb = new StringBuilder( len );
        for ( int i = 0; i < len; i++ ) {
            sb.append( values[ rnd.nextInt( values.length )] );
        }
        return sb.toString();
    }
1193658
protected String randomValue(List<String> values) {
		if (values == null || values.isEmpty()) {
			throw new InvalidFunctionUsageException("No values to choose from");
		}
		
		final int idx = random.nextInt(values.size());
		
		return values.get(idx);
	}
555007
public static int randbetween(EvaluationContext ctx, Object bottom, Object top) {
        int _bottom = Conversions.toInteger(bottom, ctx);
        int _top = Conversions.toInteger(top, ctx);

        return (int)(Math.random() * (_top + 1 - _bottom)) + _bottom;
    }
1254818
function random (arg, used) {
	var n;

	do {
		n = Math.floor(Math.random() * arg);
	} while (used[n]);

	used[n] = 1;

	return n;
}
1319760
private static int unrandomize255State(int randomizedBase256Codeword,
                                          int base256CodewordPosition) {
    int pseudoRandomNumber = ((149 * base256CodewordPosition) % 255) + 1;
    int tempVariable = randomizedBase256Codeword - pseudoRandomNumber;
    return tempVariable >= 0 ? tempVariable : tempVariable + 256;
  }
1083284
def rand_article(num_p=(4, 10), num_s=(2, 15), num_w=(5, 40)):
    
    article = list()
    for _ in range(random.randint(*num_p)):
        p = list()
        for _ in range(random.randint(*num_s)):
            s = list()
            for _ in range(random.randint(*num_w)):
                s.append(
                    rand_str(random.randint(1, 15), string.ascii_lowercase))
            p.append(" ".join(s))
        article.append(". ".join(p))
    return "\n\n".join(article)
384409
private static void possiblyFail(float chanceFailure, Random random) {
    float value = random.nextFloat();
    if (value < chanceFailure) {
      LOG.fatal("shouldFail: Failing with value " + value +
          " < " + chanceFailure);
      System.exit(-1);
    }
  }
1316049
function random (utxos, outputs, feeRate) {
  utxos = shuffle(utxos)

  return accumulative(utxos, outputs, feeRate)
}
401673
function randomString() {
      var possibilities = ['Frequency', 'Population', 'Alpha', 'Beta'],
          i = Math.round(Math.random() * possibilities.length);
      return possibilities[i];
    }
1044286
def randomize(value)
      case value
      when Array then value[rand(value.size)]
      when Range then rand((value.last+1) - value.first) + value.first
      else value
      end
    end
611699
function randc() {
	var num,
		c, i;

	// [1] Use bitwise `not` to convert the random number to a 32-bit integer, effectively flooring the float.
	// [2] Convert to a hexadecimal string.
	c = (~~( lcg()*MAX ) ).toString( 16 );

	// [3] If need be, pad with zeros.
	num = 6 - c.length;
	for ( i = 0; i < num; i++ ) {
		c = '0' + c;
	}
	return c;
}
389001
function _inc() {
        if (_status() >= 1) {
          return;
        }

        var rnd = 0;

        // TODO: do this mathmatically instead of through conditions

        var stat = _status();
        if (stat >= 0 && stat < 0.25) {
          // Start out between 3 - 6% increments
          rnd = (Math.random() * (5 - 3 + 1) + 3) / 100;
        } else if (stat >= 0.25 && stat < 0.65) {
          // increment between 0 - 3%
          rnd = (Math.random() * 3) / 100;
        } else if (stat >= 0.65 && stat < 0.9) {
          // increment between 0 - 2%
          rnd = (Math.random() * 2) / 100;
        } else if (stat >= 0.9 && stat < 0.99) {
          // finally, increment it .5 %
          rnd = 0.005;
        } else {
          // after 99%, don't increment:
          rnd = 0;
        }

        var pct = _status() + rnd;
        _set(pct);
      }
1044060
private static char randomize253State(char ch, int codewordPosition) {
    int pseudoRandom = ((149 * codewordPosition) % 253) + 1;
    int tempVariable = ch + pseudoRandom;
    return (char) (tempVariable <= 254 ? tempVariable : tempVariable - 254);
  }
528827
def random_int(maximum_value):
	
	if maximum_value == 0:
		return 0
	elif maximum_value == 1:
		return random_bits(1)

	bits = math.floor(math.log2(maximum_value))
	result = random_bits(bits) + random_int(maximum_value - ((2 ** bits) - 1))
	return result
108835
def random(self: 'ErrorValue') -> np.ndarray:
        
        if isinstance(self.val, np.ndarray):
            # IGNORE:E1103
            return np.random.randn(self.val.shape) * self.err + self.val
        else:
            return np.random.randn() * self.err + self.val