Reset the nupic random generator. This is necessary to reset random seed to
    generate new sequences.

    @param seed       (int)
        Seed for nupic.bindings.Random.
181218
def setRandomSeed(self, seed):
    
    self.seed = seed
    self._random = Random()
    self._random.setSeed(seed)
771831
static IntersectionImpl initNewHeapInstance(final long seed) {
    final IntersectionImpl impl = new IntersectionImpl(null, seed, false);
    impl.lgArrLongs_ = 0;
    impl.curCount_ = -1;  //Universal Set is true
    impl.thetaLong_ = Long.MAX_VALUE;
    impl.empty_ = false;  //A virgin intersection represents the Universal Set so empty is FALSE!
    impl.hashTable_ = null;
    return impl;
  }
939086
def reset(self):
        """"""
        if self.seq is not None and self.shuffle:
            random.shuffle(self.seq)
        if self.last_batch_handle != 'roll_over' or \
            self._cache_data is None:
            if self.imgrec is not None:
                self.imgrec.reset()
            self.cur = 0
            if self._allow_read is False:
                self._allow_read = True
521778
public final void reset() {
        successfulTests = 0;
        failedTests = 0;
        timeoutTests = 0;
        errorTests = 0;
        individualErrors = 0;

        startTime = null;
        endTime = null;
    }
66231
def set_seed(self, seed):

        

        assert seed.dtype == np.int and seed.shape == (self.samples, self.N)
        self.topic_seed = seed
202143
public void setGenerator(final IdGenerator generator) {
        if (generator != null) {
            this.idGenerator = generator;
            swidTag.setId(idGenerator.nextId());
        }
    }
436334
public function shuffle($seed = null)
    {
        $items = $this->items;

        if (is_null($seed)) {
            shuffle($items);
        } else {
            srand($seed);

            usort($items, function () {
                return rand(-1, 1);
            });
        }

        return new static($items);
    }
283991
public static void seed(long seed) {
        System.out.println("SEED="+seed);
        Prng.seed = seed;
        curRandom.setSeed(seed);
    }
581546
def reset_generation(self):
        """"""
        with self._lock:
            self._generation = Generation.NO_GENERATION
            self.rejoin_needed = True
            self.state = MemberState.UNJOINED
1286240
def reset_input_generators(self, seed):
        
        seed_generator = SeedGenerator().reset(seed=seed)

        for gen in self.input_generators:
            gen.reset(next(seed_generator))
            try:
                # In case `gen` is itself a derived generator,
                # recursively reset its own input generators.
                gen.reset_input_generators(next(seed_generator))
            except AttributeError:
                pass
494070
public Random getNewRandomInstance(long seed, long size) {
        try {
            Class<?> c = randomClass;
            Constructor<?> constructor = c.getConstructor(long.class, long.class);
            Random t = (Random) constructor.newInstance(seed, size);
            return t;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
1340792
public static final void reset(){
		instance.reset();
		String junittest = System.getProperty("JUNITTEST");
		if (junittest!=null && junittest.equalsIgnoreCase("true"))
			return;
		StartBuiltInProducers.restartbuiltin();
	}
446753
public static Random getRNG(long... seed) {
    switch(_rngType) {
    case JavaRNG:      return new H2ORandomRNG(seed[0]);
    case XorShiftRNG:  return new XorShiftRNG (seed[0]);
    case PCGRNG:       return new PCGRNG      (seed[0],seed.length > 1 ? seed[1] : 1);
    case MersenneTwisterRNG:
      // Do not copy the seeds - use them, and initialize the first two ints by
      // seeds based given argument.  The call is locked, and also
      // MersenneTwisterRNG will just copy the seeds into its datastructures
      return new MersenneTwisterRNG(ArrayUtils.unpackInts(seed));
    }
    throw H2O.fail();
  }
645558
private void initRandom() {
        try {
            random = new SecureRandom();
        } catch (Exception e) {
            log.warn("Could not generate SecureRandom for session-id randomness", e);
            random = new Random();
            weakRandom = true;
        }
    }
1145235
def seed_rngs(seed: int) -> None:
    
    np.random.seed(seed)
    random.seed(seed)
    mx.random.seed(seed)
540176
public void reset() {
		Double[] init = null;
		if(resetIndex>-1) init = Arrays.copyOfRange(insertSeq.toArray(new Double[resetIndex+1]), 0, resetIndex);
		insertSeq.clear();
		insertStat.clear();
		observationCount = 0.0;
		average = 0.0;
		minimum = Double.MAX_VALUE;
		maximum = Double.MIN_VALUE;
		expectation = null;
		moments.clear();
		if(init != null)
			for(Double value: init) {
				addValue(value);
			}
	}
297412
public void reset()
    {
        xMin = Double.NaN;
        xMax = Double.NaN;
        yMin = Double.NaN;
        yMax = Double.NaN;
    }