def _execute_a_render_mission(self, mission):
     """handle Model mission and do the render"""
     if mission['add_rect']:
         with self.canvas:
             Color(r(), 1, 1, mode='hsv')
             Rectangle(pos=(r() * self.width,
                 r() * self.height), size=(20, 20))

 def getValue(self, fraction, interval, value=None, **kw):
     if value is not None:
         if fraction <= 0.0 or fraction >= 1.0:
             return value
         else:
             from random import random as r
             return [value[0]+r(), value[1]+r(), value[2]+r()]

 def add_rects(self, label, wid, count, *largs):
     label.text = str(int(label.text) + count)
     with wid.canvas:
         for x in xrange(count):
             Color(r(), 1, 1, mode='hsv')
             Rectangle(pos=(r() * wid.width + wid.x,
                            r() * wid.height + wid.y), size=(20, 20))

    def loop(self):
        # Input Suggestion

        from random import randint as r
        import os
        while True:
            os.system('clear')

            # Display status
            # print(80 * '/')
            # print(self.solution)
            # for player in self.hidden_players:
            #     self.player_displayer.display_player(player)

            players = [self.players[i] for i in range(
                len(self.players)) if i != self.suggesting_player_index]
            for player in players:
                self.player_displayer.display_player(player)

            suggestion = {
                CardType.SUSPECT: SUSPECTS[r(0, 5)],
                CardType.WEAPON: WEAPONS[r(0, 5)],
                CardType.ROOM: ROOMS[r(0, 8)],
            }
            print('Turn', self.turn_number)

            turn_start_summary = ' '.join([
                'Player',
                str(self.suggesting_player_index + 1),
                'Suggestion:',
                str(suggestion)
            ])
            print(turn_start_summary)

            acting_players = self.get_acting_players(
                self.players[
                    self.suggesting_player_index
                ]
            )
            for player in acting_players:
                ps = None
                while ps not in ['p', 's', 'x']:
                    print(player.name)
                    ps = input('p/s: ')

                if ps == 's':
                    self.analyzer.player_stopped(player, suggestion)
                    break

                if ps == 'p':
                    self.analyzer.player_passed(player, suggestion)

                if ps == 'x':
                    sys.exit()

            self.turn_number += 1
            self.suggesting_player_index += 1
            if self.suggesting_player_index >= len(self.players):
                self.suggesting_player_index = 0

 def add_planet(self,root,x,y,ray,rho=r()*100000.,mass=r(),*largs):
     wid=physObject()
     wid.mass=1.
     wid.pos=[r()*root.width,r()*root.height]
     wid.rho=1000.
     s=math.sqrt(wid.mass/(wid.rho*math.pi))
     wid.size_hint=(s,s)
     root.add_widget(wid)

def run(parent):
	try:
		play(‘happy_otter.mp3’)
  		move_and_wait(RARM=r(0, 10))	
  		move_and wait(RARM=r(90, 100))
  		move_to(RARM=r(0, 10))
	finally:
		parent.exit()

def draw():
    save("pic.jpeg")
    background(255)
    
    noStroke()
    fill(r(255), r(255), r(255))
    #[draw_square(i,j,r(2)) for i in range(n + 1) for j in range(n + 1)] 
    [draw_sim_square(i,j,r(2)) for i in range((n + 1)/2) for j in range((n + 1)/2)] 
    delay(1000)

def confuse(T):
    print 'confusing data...',
    from random import random as r
    size = len(T)
    for i in range(int(size**1.5)):
        x,y = int(size*r()), int(size*r())
        T[x], T[y] = T[y], T[x]
    print 'finish.'
    return T

def gen_scramble(l):
	scramble = ""
	m=b=9
	for u in range(l):
		c=b;b=m
		while c+b-4 and m==c or m==b:
			m=r(0,5)
		scramble += "URFBLD"[m]+" '2"[r(0,2)]+" "
	return scramble.replace("  "," ")[:-1]

def run(parent):
	try:
		play(‘happy_otter.mp3’)
		move_and_wait(LARM=r(0, 10)); 
		move_and_wait(LARM=r(50, 60))
		move_to(LARM=r(0,10))

	finally:
		parent.exit()

def sendFakeBrainwaves():
    brainwaves = ",".join(
    [str(x) for x in \
        [0] +\
        [r(0,100) for x in range(2)] +\
        [r(0,100000) for x in range(8)]
    ])+"\n"
    print brainwaves
    clientsocket.send(brainwaves)

def run(parent):
	try:
		move_to(PUR=100))
		move_and_wait(NECK=r(0,10))
		move_and_wait(NECK=r(50,60))
		move_and_wait(NECK=r(0,10))
		move_and_wait(NECK=r(50,60))
		move_to(NECK=50)
	finally:
		parent.exit()

 def __init__(self):
   # initialize node-activations
   self.ai = [1.0]*ni
   self.ah = [1.0]*nh
   self.ao = [1.0]*no
   self.Aah, self.Ach, self.Aao, self.Aco = [0]*nh, [0]*nh, [0]*no, [0]*no
   self.wi = [ [r() for j in range(nh)] for i in range(ni) ]
   self.wo = [ [r() for k in range(no)] for j in range(nh) ]
   self.ci = [[0.0]*nh]*ni
   self.co = [[0.0]*no]*nh

def test_ray_passes_through_focus():
    location = [0]*100
    for t in arange(100):
        ray = Ray([r()*5e-2,r()*5e-2,0], [0,0,1], op_wavelength)
        aol.propagate_to_distance_past_aol([ray], 0, focal_length)
        location[t] = ray.position
    
    focus_theory = focus_position + concatenate( (aol_simple.base_ray_positions[3], [aod_spacing.sum()]) ) 
    assert allclose(mean(location, axis=0), focus_theory, rtol=0, atol=1e-3) \
            and all(std(location, axis=0) < 5e-5)

 def add_rects(self, *largs):
     print 'adding_rects', '=' * 80
     wid = self.wid
     count = 1000
     print 'adding', count, 'rects'
     with wid.canvas:
         for x in xrange(count):
             Color(r(), 1, 1, mode='hsv')
             Rectangle(pos=(r() * 100. - 50.,
                            r() * 100. - 50.), size=(100 * r(), 200 * r()))

    def handle(self, *args, **options):
	scramble = ""
	m=b=9
	for u in range(20):
		c=b;b=m
		while c+b-4 and m==c or m==b:
			m=r(0,5)
		scramble += "URFBLD"[m]+" '2"[r(0,2)]+" "
	scramble = scramble.replace("  "," ")[:-1]
	s = Scramble(scramble=scramble, pub_date=timezone.now())
	s.save()

def test_ray_scans_correctly():
    t_step = 1e-6
    num_rays = 100
    location = [0]*num_rays
    for t in arange(num_rays):
        ray = Ray([r()*5e-2,r()*5e-2,0], [0,0,1], op_wavelength)
        aol.propagate_to_distance_past_aol([ray], t*t_step, focal_length)
        location[t] = ray.position
    
    focus_theory = focus_position + concatenate( (aol_simple.base_ray_positions[3], [aod_spacing.sum()]) ) + outer(arange(num_rays)*t_step, focus_velocity)
    assert allclose(location, focus_theory, rtol=0, atol=2e-3)

    def calib(self):
        now = datetime.datetime.now()
        date = now.strftime("%Y%m%d")
        TIME = now.strftime('%H%M%S')      

        self.datavault.cd(['', date, 'Calibrations',str(self.channelToCalib) + TIME], True)
        self.datavault.new(str(self.channelToCalib) + TIME,[('digital', '')], [('Analog', 'Volts', 'Volts')])
        self.datavault.add_parameter('plotLive',True)
	
        
        #stepsize = 0b101010101

        #stepsize = 1000
        stepsize = 500
        self.numSteps = (55000-11500)/stepsize        
        self.digVoltages = [ 11500 + r(0, stepsize) + i*stepsize for i in  range(self.numSteps)]
        self.compareVolts = [ 11500 + r(0, stepsize) + i*stepsize for i in  range(self.numSteps)]
            

        #self.digVoltages = range(0, 2**16, stepsize) # digital voltages we're going to iterate over
        self.anaVoltages = [] # corresponding analog voltages in volts
        self.dacserver.set_individual_digital_voltages([(str(self.channelToCalib).zfill(2), self.digVoltages[0])])
        time.sleep(.3)
        for dv in self.digVoltages: # iterate over digital voltages

            self.dacserver.set_individual_digital_voltages([(str(self.channelToCalib).zfill(2), dv)]) 

            time.sleep(.3)
            
            av = self.dmmserver.get_dc_volts()
            #av = 0

            self.anaVoltages.append(av)
            self.datavault.add(dv, av)
            print dv, "; ", av
        
#        plt.figure(1)
#        plt.plot(self.digVoltages, self.anaVoltages, 'ro')
#        plt.show()

        fit = np.polyfit(self.anaVoltages, self.digVoltages, 3) # fit to a second order polynomial
        if self.checksave.isChecked():
            # self.registry.cd(['', 'Calibrations'], True)
            #self.registry.mkdir(str(self.channelToCalib))
            #self.registry.cd(['', 'Calibrations', str(self.channelToCalib)], True)
            print ['', 'Servers', 'CCTDAC Server', 'Calibrations', str(self.channelToCalib)]
            self.registry.cd(['', 'Servers', 'CCTDAC Server', 'Calibrations', str(self.channelToCalib)], True)
            self.registry.set('c0', fit[3])
            self.registry.set('c1', fit[2])
            self.registry.set('c2', fit[1])
            self.registry.set('c3', fit[0])
    
        return fit

def glitch(s, glitchness = 10):
    # for each character, we insert a random amount of diacritic characters
    result = ''
    for c in s:
        if c in let:
            pick_amount = r(0,glitchness)
            picks = [r(0,len(codes)-1) for a in range(pick_amount)]
            for i in picks:
                result+=chr(codes[i])
            result+=c
        else:
            result+=c
    return result

def loto(players, ticket, f=lambda: r()*r()):
	cash = players * ticket
	picks = [f() for a in range(players)]
	distrcoeffs = map(lambda i:i/sum(picks), picks)
	earnings = map(lambda i: i*cash, distrcoeffs)
	diffs = map(lambda i: i*cash-ticket, distrcoeffs)

	print players, "players with $"+str(ticket), "tickets", "total cash is", cash, "check sum", sum(earnings)
	print reduce (lambda i,j:1+i if j>0 else i, diffs,0), "winners"
	print "earnings";flo(earnings,pref='\t$')
	print "diffs";flo(diffs,pref='\t$')
	print stat(earnings)
	flo (map(lambda i: i*100/ticket,diffs),"%")