Python Random.randrange方法代码示例

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
class Input:
    def __init__(self, dmgr, name):
        self.core = dmgr.get("core")
        self.name = name

        self.prng = Random()

    @kernel
    def gate_rising(self, duration):
        time.manager.event(("gate_rising", self.name, duration))
        delay(duration)

    @kernel
    def gate_falling(self, duration):
        time.manager.event(("gate_falling", self.name, duration))
        delay(duration)

    @kernel
    def gate_both(self, duration):
        time.manager.event(("gate_both", self.name, duration))
        delay(duration)

    @kernel
    def count(self):
        result = self.prng.randrange(0, 100)
        time.manager.event(("count", self.name, result))
        return result

    @kernel
    def timestamp_mu(self):
        result = time.manager.get_time_mu()
        result += self.prng.randrange(100, 1000)
        time.manager.event(("timestamp_mu", self.name, result))
        at_mu(result)
        return result

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
    def __init__(self, context, key=None, counter=None, seed=None):
        int32_info = np.iinfo(np.int32)
        from random import Random

        rng = Random(seed)

        if key is not None and counter is not None and seed is not None:
            raise TypeError("seed is unused and may not be specified "
                    "if both counter and key are given")

        if key is None:
            key = [
                    rng.randrange(
                        int(int32_info.min), int(int32_info.max)+1)
                    for i in range(self.key_length-1)]
        if counter is None:
            counter = [
                    rng.randrange(
                        int(int32_info.min), int(int32_info.max)+1)
                    for i in range(4)]

        self.context = context
        self.key = key
        self.counter = counter

        self.counter_max = int32_info.max

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
 def test_set_item_existing_random(self):
     for i in (10, 20, 30, 40, 50, 60, 70):
         rnd = Random(i)
         for j in range(len(self.keys)):
             k = self.keys[rnd.randrange(0, len(self.keys), 1)]
             v = rnd.randrange(self.values[0], self.values[-1], 1)
             self.skipdict[k] = v
             self.assertEqual(self.skipdict[k], v)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
def test_pickle():
    g = Gauge(0, 10, at=0)
    r = Random(17171771)
    for x in range(10000):
        since = r.randrange(1000)
        until = since + 1 + r.randrange(1000)
        g.add_momentum(r.uniform(-10, +10), since=since, until=until)
    data = pickle.dumps(g)
    g2 = pickle.loads(data)
    assert g.determination == g2.determination

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
class Vizhash:

    def __init__(self, data, square_size=16, n=16):
        self.square_size = square_size
        self.n = n
        # Use the sha256 digest of the data to avoid collision on the
        # random generator
        seed = hashlib.sha256(data.encode("utf-8")).hexdigest()
        self.random = Random(seed)

    def explore(self, i, j, cases, colors):
        """Maze generation algorithm"""
        cases[i][j] = True

        cells = [(i - 1, j), (i, j + 1), (i + 1, j), (i, j - 1)]
        self.random.shuffle(cells)
        for (x, y) in cells:
            if cases[x][y]: continue
            color = copy.copy(colors[i][j])
            for k in range(3):
                color[k] += self.random.gauss(0, self.random.randint(3,20))
                color[k] = int(max(0, min(color[k], 255)))
            colors[x][y] = color
            self.explore(x, y, cases, colors)

    def identicon(self):
        n = self.n
        size = (self.square_size * n, self.square_size * n)

        im = Image.new('RGB',size)
        d = ImageDraw.Draw(im)

        cases = [[False] * n + [True] for _ in range(n)] + [[True] * (n + 1)]
        colors = [[None] * n for _ in range(n)]

        i, j = self.random.randrange(n), self.random.randrange(n)
        colors[i][j] = [
            self.random.randint(0, 255),
            self.random.randint(0, 255),
            self.random.randint(0,255)
        ]
        self.explore(i, j, cases, colors)

        for i in range(n):
            for j in range(n):
                coordinates = [
                    i * self.square_size,
                    j * self.square_size,
                    (i + 1) * self.square_size,
                    (j + 1) * self.square_size
                ]
                d.rectangle(coordinates, tuple(colors[i][j]))
        return im

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
def make(i):
    """
    Input:  {
              (pipeline)      - update pipeline with new values
              (random_module) - global random module (to set global seed)
              ck_kernel       - CK kernel
            }

    Output: {
              return       - return code =  0, if successful
                                         >  0, if error
              (error)      - error text if return > 0
              finish       - if True, stop autotuner
            }

    """

    # Init global random
    from random import Random

    mr=i.get('random_module',None)
    if mr==None: mr=Random()

    ck=i['ck_kernel']

    o=i.get('out','')

    finish=False

    pipeline=i.get('pipeline',{})

    keys={}

    # Setting dimensions X,Y,Z
    x=mr.randrange(128, 1024, 128)
    y=mr.randrange(128, 1024, 128)
    z=mr.randrange(128, 1024, 128)

    keys['##env#MTX_A']=str(x)+','+str(y)
    keys['##env#MTX_B']=str(y)+','+str(z)

    # Setting LWS
    lx=mr.randrange(2,32,2)
    keys['##env#CK_LWS_X']=lx
    keys['##env#CK_LWS_Y']=mr.randrange(2,128/lx,2)

    # GEMM TYPE
    keys['##env#GEMM_TYPE']=mr.randrange(0,2)

    # CK_SKIP_PADDING"
#    keys['##env#CK_SKIP_PADDING']=mr.randrange(0,1)

    return {'return':0, 'keys':keys, 'finish':finish}

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
def random_eyes():
    from random import Random

    r = Random()

    for x in range(100000):
        Left.move(r.randrange(cfg.eye.left.hmin, cfg.eye.left.hmax), 
                  r.randrange(cfg.eye.left.vmin, cfg.eye.left.vmax))

        Right.move(r.randrange(cfg.eye.right.hmin, cfg.eye.right.hmax),
                   r.randrange(cfg.eye.right.vmin, cfg.eye.right.vmax))
        sleep(0.25)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
def drawrandline():
    rand=Random()
    img=cv.CreateImage((700,1000),8,3)
    cv.SetZero(img)
    cv.NamedWindow("RandomViewer",1)
    for i in range(100):
        cv.Line(img,(rand.randrange(0,700),rand.randrange(0,1000)),(300,200),(rand.randrange(0,256),rand.randrange(0,256),rand.randrange(0,256)),1,8,0)
        cv.ShowImage("RandomViewer",img)
        cv.WaitKey(5)
    cv.PutText(img,"Hello OpenCV",(100,200),cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX,5,10,0,1,8),(255,255,255))
    cv.ShowImage("RandomViewer",img)
    cv.WaitKey(0)
    cv.DestroyWindow("RandomViewer")

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
def random_focus():
    from random import Random

    hrange = (0, cfg.kinect.x - 1)
    vrange = (0, cfg.kinect.y - 1)
    drange = (0, 3000)
    r = Random()

    for dummy in range(100000):
        h = r.randrange(*hrange)
        v = r.randrange(*vrange)
        d = r.randrange(*drange) / 1000.0
        Left.focus(d, (h, v))
        Right.focus(d, (h, v))
        sleep(0.25)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
 def randrange(self, start, stop=None, step=1, intType=int, default=None, maxWidth=9007199254740992L):
     oldCount = self.count
     result = Random.randrange(self, start, stop, step, intType, default, maxWidth)
     if Debug.random:
         self.game.debug('%d calls to random by Random.randrange(%d,%s) from %s' % (
             self.count - oldCount, start, stop, stack('')[-2]))
     return result

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
class RuleGenerator(object):
    def __init__(self, number_of_states, number_of_symbols):
        if number_of_states < 2 or number_of_symbols < 2:
            raise ValueError(
                    "number of states and symbols must be greater than "
                    "or equal to 2.")
        self.number_of_states = number_of_states
        self.number_of_symbols = number_of_symbols
        self.rand_gen = Random()
        self.possible_rule_options = [
                list(range(self.number_of_states)),
                list(range(self.number_of_symbols)),
                list(range(self.number_of_symbols)),
                [True, False],
                list(range(self.number_of_states))]

    def make_rule(self):
        rule_args = [self.rand_gen.choice(o)
                for o in self.possible_rule_options]
        return Rule(*rule_args)

    def modify_rule(self, rule):
        field_to_modify = self.rand_gen.randrange(5)
        while True:
            new_option = self.rand_gen.choice(
                    self.possible_rule_options[field_to_modify])
            if new_option != rule[field_to_modify]:
                break
        return rule._replace(**{rule._fields[field_to_modify]:new_option})

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
class Granter(Module):
    def __init__(self, req, ack):
        self.req = req
        self.ack = ack
        self.state = 0
        self.prng = Random(92837)

    def do_simulation(self, selfp):
        elts = ["@" + str(selfp.simulator.cycle_counter)]

        if self.state == 0:
            if selfp.req:
                elts.append("Refresher requested access")
                self.state = 1
        elif self.state == 1:
            if self.prng.randrange(0, 5) == 0:
                elts.append("Granted access to refresher")
                selfp.ack = 1
                self.state = 2
        elif self.state == 2:
            if not selfp.req:
                elts.append("Refresher released access")
                selfp.ack = 0
                self.state = 0

        if len(elts) > 1:
            print("\t".join(elts))

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
class MyModelWB(MyModel, wishbone.TargetModel):
	def __init__(self):
		self.prng = Random(763627)

	def can_ack(self, bus):
		# Simulate variable latency.
		return self.prng.randrange(0, 2)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
class Granter:
	def __init__(self, req, ack):
		self.req = req
		self.ack = ack
		self.state = 0
		self.prng = Random(92837)
	
	def do_simulation(self, s):
		elts = ["@" + str(s.cycle_counter)]
		
		if self.state == 0:
			if s.rd(self.req):
				elts.append("Refresher requested access")
				self.state = 1
		elif self.state == 1:
			if self.prng.randrange(0, 5) == 0:
				elts.append("Granted access to refresher")
				s.wr(self.ack, 1)
				self.state = 2
		elif self.state == 2:
			if not s.rd(self.req):
				elts.append("Refresher released access")
				s.wr(self.ack, 0)
				self.state = 0
			
		if len(elts) > 1:
			print("\t".join(elts))
	
	def get_fragment(self):
		return Fragment(sim=[self.do_simulation])

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import randrange [as 别名]
 def wrapped_func(*args):
     result = func(*args)
     random = Random()
     random.seed(time())
     MINTIME, MAXTIME = 3, 8
     sleep_time = random.randrange(MINTIME, MAXTIME)
     print("CALLED {0} WITH ARGS {1} SLEEPING {2} seconds".format(func.__name__, str(args), sleep_time))
     sleep(sleep_time)
     return result