def neighbor_switch_jumps(state):
    big_jumps = find_big_jumps(state)
    goodTrks = good_tracks(state)
    track1=random.choice(goodTrks)
    track2 = random.choice(goodTrks)


    num_of_jumps = len(big_jumps[track1])
    if num_of_jumps >= 1:
        which_jump = randint(0,num_of_jumps-1)
        time_jump1 = big_jumps[track1][0]
        temp = state[track1][time_jump1:lifetime]
        state[track1][time_jump1:lifetime] = state[track2][time_jump1:lifetime]
        state[track2][time_jump1:lifetime] = temp



    '''elif num_of_jumps>2:
        print('num of jumps' + str(num_of_jumps))
        print('list of big jumps' + str(big_jumps))
        which_jump = randint(0,num_of_jumps-2)
        print('which jump : ' + str(which_jump))
        time_jump1 = big_jumps[track1][which_jump]
        time_jump2= big_jumps[track1][which_jump+1]

        temp = state[track1][time_jump1:time_jump2]
        state[track1][time_jump1:time_jump2] = state[track2][time_jump1:time_jump2]
        state[track2][time_jump1:time_jump2] = temp
    '''

    return state

 def count_helper(diamonds,clubs,hearts,spades):
    random.choice("diamonds","clubs","hearts","spades")
    if random.choice=="diamonds":
       return count_helper(diamonds+1,hand-1)
      elif random.choice=="clubs":
         return count_helper(clubs+1,hand-1)
      elif random.choice=="hearts"
         return count_helper(hearts+1,hand-1)
      else:
         return count_helper(spades+1,hand-1)

def gen_cc_external(merchant,no_trans,count):
	for i in range(no_trans):
		acct=random.choice(python_account_ID.accountid)
		cc_list=python_CC.CC_Dict[acct]
		#7)Set customer credit limit - skew to clients with $1000-$25000 and 10% with $25K - $50K
		limit = max(max((randrange(1,101,1)-99),0)* randrange(25000,50000,1000),randrange(1000,25000,1000))
		#local Amt variable to calculate customer total usage
		usedAmt = 0
		maxDate= datetime(0001,01,01) 
		NoTrans = randrange(100,150,1)
		#loop to generate NoTrans transactions per customer, we can add logic for probabilities of # transactions if neccessary random number generator to avoid the constant value
		for j in range(NoTrans):
			dt = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
			#generate amount for current transaction with 50%-50% distribution on credits and debits
			tmpAmt = max((randrange(1,3,1)-1),0)* randrange(1,limit,100)*(-1)
			#if not credit then generate debit
			if tmpAmt == 0:
				tmpAmt = randrange(1,limit,100)
			#add current amount to client total account usage
			usedAmt = usedAmt + tmpAmt
			#pull value from dictionary for randomly selected merchant category 
			cat = ''
			tranType = ''
			row = [str(count)+'_'+dt] + [acct] + [gen_data.create_company_name()] 
			#set transaction type based on amount
			if tmpAmt < 0:
				tranType = random.choice(Transaction_Type_Credits)
				row.append('Non-BMO Acct')
				row.append('')
			else: 
				tranType = random.choice(Transaction_Type_Debits)
				cat = random.choice(merchant)
				row.append(cat)
				row.append(python_merchant_cat.All_Merchant_Cat[cat])
			#tranType random.choice(Transaction_Type)
			
			#date posted
			date1 = gen_data.create_date(past=True)
			if date1 > maxDate:
				maxDate = date1
			#date of transaction a day later
			date2 = date1-timedelta(days=1)
			row.extend([date1, date2, tranType,random.choice(Country_Red),limit,tmpAmt,usedAmt,cc_list[0],cc_list[1]])
			count = count + 1
			writer.writerow(row)
		#post generating all transactions, check account balance - if overpaid - refund $ and add a refun transaction 
		if usedAmt < limit * (-1):
			row = [str(count)+'_'+dt]+ [acct] + ['']+['']+['']
			date1temp=maxDate+timedelta(days=90)
			date2=date1temp-timedelta(days=1)
			row.extend([date1temp, date2, 'Refund','',limit,abs(limit-abs(usedAmt))*(-1),0,cc_list[0],cc_list[1]])
			count = count + 1
			usedAmt = 0
			maxDate= datetime(0001,01,01)
			writer.writerow(row)

def neighbor(state):
    # make random change in random number of spots
    # swap random range
    timepoint = randint(0, lifetime - 1)
    goodTrks = good_tracks(state)
    track1=random.choice(goodTrks)
    goodTrks.remove(track1)
    track2=random.choice(goodTrks)
    temp = state[track1][timepoint:lifetime]
    state[track1][timepoint:lifetime] = state[track2][timepoint:lifetime]
    state[track2][timepoint:lifetime] = temp

    return state

def detTime():
    #temporary solution
    global currentTime
    global itemn
    global items
    global itemw
    global iteme
    now=getTimeStamp()
    if(now-currentTime>interval):
	itemn=random.choice(item0)
	items=random.choice(item1)
	itemw=random.choice(item2)
	iteme=random.choice(item3)
	currentTime=now

def calc_sim_rec(dist_df,likes,dislikes,n=0,larger_is_closer=True):
	if likes == []:
		return random.choice(dist_df.index)
	else:
		#dists_df = dist_df[dist_df.index.isin(cluster_dict)]
		p = get_sims(list(likes),list(dislikes),dist_df,n,larger_is_closer)
		return p[0:n]

    def __randomInvasionTick(self, task=None):
        """
        Each hour, have a tick to check if we want to start an invasion in
        the current district. This works by having a random invasion
        probability, and each tick it will generate a random float between
        0 and 1, and then if it's less than or equal to the probablity, it
        will spawn the invasion.

        An invasion will not be started if there is an invasion already
        on-going.
        """
        # Generate a new tick delay.
        task.delayTime = randint(1800, 5400)
        if self.getInvading():
            # We're already running an invasion. Don't start a new one.
            self.notify.debug('Invasion tested but already running invasion!')
            return task.again
        if random() <= self.randomInvasionProbability:
            # We want an invasion!
            self.notify.debug('Invasion probability hit! Starting invasion.')
            # We want to test if we get a mega invasion or a normal invasion.
            # Take the mega invasion probability and test it. If we get lucky
            # a second time, spawn a mega invasion, otherwise spawn a normal
            # invasion.
            if config.GetBool('want-mega-invasions', False) and random() <= self.randomInvasionProbability:
                # N.B.: randomInvasionProbability = mega invasion probability.
                suitName = self.megaInvasionCog
                numSuits = randint(2000, 15000)
                specialSuit = random.choice([0, 0, 0, 1, 2])
            else:
                suitName = choice(SuitDNA.suitHeadTypes)
                numSuits = randint(1500, 5000)
                specialSuit = False
            self.startInvasion(suitName, numSuits, specialSuit)
        return task.again

def calc_sim(dist_df,likes,dislikes,cluster_dict=None,cluster_no=None,n=0):
	if likes == []:
		return random.choice(cluster_dict[cluster_no])
	else:
		if cluster_dict != None and cluster_no != None:
			dists_df = dist_df[dist_df.index.isin(cluster_dict[cluster_no])]
		p = get_sims(list(likes),list(dislikes),dists_df,larger_is_closer=True)
		return p[n]

def neighbor_onespot(state):
    # make random change for one random spots
    timepoint = randint(0, lifetime - 2)
    goodTrks = good_tracks(state)
    track1=random.choice(goodTrks)
    goodTrks.remove(track1)
    track2=random.choice(goodTrks)
    temp = state[track1][timepoint]
    state[track1][timepoint] = state[track2][timepoint]
    state[track2][timepoint] = temp


    temp2 = state[track1][timepoint+1]
    state[track1][timepoint+1] = state[track2][timepoint+1]
    state[track2][timepoint+1] = temp2

    return state

 def place_random(self, entity):
     empty = []
     for x in range(0, self.width):
         for y in range(0, self.height):
             if self[x, y] is None:
                 empty.append((x, y))
     if len(empty) == 0:
         raise World.FullRoomException()
     self[random.choice(empty)] = entity

def create_expression():
    """This function takes no arguments and returns an expression that
    generates a number between -1.0 and 1.0, given x and y coordinates."""
    expr1 = lambda x, y: (x + y)/2 * cos(y) * tan(5 ** 4) *cos(pi * sin(pi * cos))
    expr2 = lambda x, y: (x - y)/2 * random()
    expr3 = lambda x, y: x * y/4 * random()
    expr4 = lambda x, y: tan(6 * x) * cos(x)
    expr5 = lambda y, x: (sin(pi)) + tan(y**2)
    return random.choice([expr1, expr2, expr3, expr4, expr5])

def alpha_num_password(wordLen=8):
    import random

    for k in range(200):
        word = ''

        for i in range(wordLen):
            word += random.choice('1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstu')

    print word

def strong_password(wordLen=8):
    import random

    for k in range(200):
        word = ''

        for i in range(wordLen):
            word += random.choice('-+_()*&$#@!<>;?|{}"1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstu')

    print word

def alpha_uppercase(wordLen=8):
    import random

    for k in range(200):
        word = ''

        for i in range(wordLen):
            word += random.choice('abcdefghijklmnopqrstuz')

    print word

 def check(self, val, client_id=None):
     if client_id is None:
         final_set = self.get(random.choice(list(self.client_list)))
     else:
         final_set = self.get(client_id)
     final_set = eval(final_set)
     if val in final_set:
         return True
     else:
         return False

def getItemScanned():
    detTime()
    locat=random.choice(location); 
    if (locat==location[0]):
	tempc=random.choice(item0)
        out=[locat,random.choice(itemn),getTimeStamp()]
    elif (locat==location[1]):
	tempc=random.choice(item1)
        out=[locat,random.choice(items),getTimeStamp()]
    elif (locat==location[2]):
	tempc=random.choice(item2)
        out=[locat,random.choice(itemw),getTimeStamp()]
    elif (locat==location[3]):
	tempc=random.choice(item3)
        out=[locat,random.choice(iteme),getTimeStamp()]
    return out

def gen(filename, start, end, filters):
    
    with open(filename, 'w') as f:
        dt = start
        while dt < end:
            f.write(dt.strftime("%Y%m%d%H%M%S") + ":" + u",".join(map(unicode, random.choice(src))) + "\n")
            dt = dt + tdelta
            if filters is not None and dt < end and filters(dt):
                print 'next ' + dt.strftime("%Y-%m-%d %H:%M:%S")

    print 'finish write to ' + filename + "from " + start.strftime("%Y-%m-%d %H:%M:%S") + " to " + end.strftime("%Y-%m-%d %H:%M:%S")

    def rolloutUniform(self, gameState, history, depth):
        "*** YOUR CODE HERE ***"
        if depth > self.depth or gameState.isWin() or gameState.isLose():
            return 0

        # rollout policy here is to choose an action uniformly from the actions
        bestAction = random.choice(gameState.getLegalPacmanActions())

        nextGameState, observation, reward = gameState.generateStateObservationReward(self, self.ghostAgents, bestAction)
        totalReward = reward + self.gamma * self.rollout(nextGameState, history + (bestAction, observation), depth + 1)

        return totalReward 

def mutate_motif_with_dirty_bits((motif,ics)):
    length = len(motif[0])
    num_sites = len(motif)
    i = random.randrange(num_sites)
    j = random.randrange(length)
    site = motif[i]
    b = site[j]
    new_b = random.choice([c for c in "ACGT" if not c == b])
    new_site = subst(site,new_b,j)
    new_motif = [site if k != i else new_site
                 for k,site in enumerate(motif)]
    jth_column = transpose(new_motif)[j]
    jth_ic = 2-dna_entropy(jth_column)
    new_ics = subst(ics,jth_ic,j)
    return new_motif,new_ics

def selection(pop, parent_chance=0.25, parent_selection_threshold=0.5):
    parents = []
    pop.sort()
    # sorted(pop, key=fitness)  # unfinished
    parents.append(pop[:int(len(pop)*parent_chance)])

    for indiv in pop:
        if indiv in parents:
            pass
        else:
            if (random() > parent_selection_threshold):
                parents.append(indiv)
    if len(parents) == 1:
        parents.append(random.choice(pop))
    return parents