Returns the next random long.
772318
public static long getRandomLong()
  {
    Random random = getRandom();

    long value = random.nextLong();

    if (! _isTest) {
      _freeRandomList.free(random);
    }

    return value;
  }
924821
public long next() {
    long x = xorshift(this.x);
    this.x = y;
    y = z;
    z = this.x ^ x ^ y;
    return z;
  }
96646
public static long randomLong(final long min, final long max) {

        return Math.round(Math.random() * (max - min) + min);
    }
467167
def next(self):
        
        # need new iterable?
        if self.r == self.repeats:
            self.i = (self.i + 1) % self.lenght
            self.r = 0

        self.r += 1
        if self.stopping and self.i == 0 and self.r == 1:
            self.stopped = True
        if self.i == 0 and self.stopped:
            raise StopIteration
        else:
            iterator = self.iterators[self.i]
            return iterator.next()
87293
public static long random(long min, long max) {
        return Math.round(ThreadLocalRandom.current().nextDouble()
                * (max - min) + min);
    }
34772
def _next_sample_index(self):
        """"""
        return self.rng.choice(self.n_active,
                               p=(self.stream_weights_ /
                                  self.weight_norm_))
1247155
def _get_next_obj(self, length):
        """"""
        data = b''
        while len(data) < length:
            data += self.sock.recv(length - len(data))

        return pickle.loads(data)
1266531
def next(self):
    "  "

    char = self.char
    if char == '\n':
      self.lineno += 1
      self.colno = 0
    else:
      self.colno += 1
    self.index += 1
    return self.char
556655
def select(self, **kws):
        '''
            
        '''
        lst = [i for i in self.values() if i.select(**kws)]

        random.shuffle(lst)

        return lst
821619
public String nextString() {
        char[] buffer = new char[length];
        for (int index = 0; index < length; index++) {
            buffer[index] = SYMBOL[random.nextInt(SYMBOL.length)];
        }
        return new String(buffer);
    }
675128
def get_next_batch(self):
        
        number_of_items = self.read_option('number_of_items')
        for i in range(0, self.batch_size):
            to_read = self.last_read + 1
            if to_read >= number_of_items:
                self.finished = True
                break
            else:
                item = BaseRecord()
                self.last_read = to_read
                item['key'] = self.last_read
                item['country_code'] = random.choice(self.country_codes)
                item['state'] = random.choice(self.states)
                item['city'] = random.choice(self.cities)
                item['value'] = random.randint(0, 10000)
                self.increase_read()
                self.last_position['last_read'] = self.last_read
                yield item
        self.logger.debug('Done reading batch')
540349
public static long nextLong(Random random, long min, long max) {
		Validate.isTrue(max >= min, "Start value must be smaller or equal to end value.");
		MoreValidate.nonNegative("min", min);

		if (min == max) {
			return min;
		}

		return (long) (min + ((max - min) * random.nextDouble()));
	}
809591
public static double nextDouble()
  {
    Random random = getRandom();

    double value = random.nextDouble();

    if (! _isTest)
      _freeRandomList.free(random);

    return value;
  }
60129
def next_trials(self):
        
        trials = list(self._trial_generator)
        if self._shuffle:
            random.shuffle(trials)
        self._finished = True
        return trials
201487
def randstring(l):
    
    return b"".join(struct.pack('B', random.randint(0, 255)) for _ in range(l))
466913
@SuppressWarnings("NumericOverflow")
    private static long nextLong(long n) {
        long bits, val;
        do {
            bits = ThreadLocalRandom.current().nextLong() & (~(1L << BITS_PER_LONG));
            val = bits % n;
        } while (bits - val + (n - 1) < 0L);
        return val;
    }
1153182
public long nextLong() {
    Delta d = ranges.get();
    if (d.start <= d.stop) {
      mutex.lock();
      value = d.update(value);
      mutex.unlock();
    }
    return d.start++;
  }