def solve(self, ns=10, return_eigenvectors=True): """ Solves (i.e. find the low energy eigenstates) of a certain spin system with a given z component of spin. Parameters ---------- ns : int number of states functional : boolean Use functional or matrix representation of the Hamiltonian return_eigenvectors: boolean Return the eigenvectors along with the .. """ # what are trying to deal with? systemsize = (util.choose(self.n, self.nu) * util.choose(self.n, self.nd) * 80) # what resources do we have svmem = psutil.virtual_memory() mcap = np.floor(svmem.free / systemsize) cap = 2 * mcap if self.humo.real else mcap # construct the best solution to the problem functional = False if cap < 2: print('Error. Not enough free virtual memory for \ exact diagonalization of this system') sys.exit('Not enough memory') if cap < ns: # Solve util.message('cap<ns', verbal) ns = np.max(cap - 2, 1) functional = True if cap < 40: util.message('cap40', verbal) functional = True self.lita, H = SzState.hamiltonian(self.humo, self.nu + self.nd, self.nu, functional=functional) if functional: # functional definition Nu, Nd = self.lita.Ns HTu, HTd, HU = H H = slinalg.LinearOperator( (Nu * Nd, Nu * Nd), dtype=HTu.dtype, matvec=lambda v: lanczos.Hv(HTu, HTd, HU, v)) self.w, self.v = diagonalize(H, k=min(ns, np.prod(self.lita.Ns) - 1), return_eigenvectors=return_eigenvectors) return self.w, self.v
def place_actions(state: risk.PlaceState) -> Actions: num_territories = sum(1 for _ in state.territories_owned(state.current_player)) num_reinforcements = state.reinforcements(state.current_player) action_space_len = int( sum( util.choose(num_territories, n) * util.choose(num_reinforcements - 1, n - 1) for n in range(1, min(num_territories, num_reinforcements)))) territories_owned = [t.name for t in state.territories_owned(state.current_player)] reinforcements = state.reinforcements(state.current_player) max_n = min(len(territories_owned), reinforcements) def sample(n): actions = [] while len(actions) < n: n = random.randint(1, max_n) combo_i = random.randint(0, util.choose(len(territories_owned), n) - 1) alloc_i = random.randint(0, util.choose(reinforcements - 1, n - 1) - 1) combo = util.kth_n_combination(territories_owned, n, combo_i) alloc = util.kth_n_integer_composition(reinforcements, n, alloc_i) action = risk.Place(combo, alloc) if action not in actions: yield action actions.append(action) def _iter(): for n in range(1, max_n): for terrs in itertools.combinations(territories_owned, n): for troops in util.integer_compositions(reinforcements, n): yield risk.Place(terrs, troops) return Actions(sample, _iter, action_space_len)
def run_config(): config = {} images = EC2MPI.ec2.get_all_images(owners=USER_ID) # Choose the architecture arch = util.choose(["i386", "x86_64"], "Choose architecture") for image in images: if image.architecture == arch: config["ami"] = image.id # Choose architecture if arch == "i386": config["instance_type"] = util.choose(["m1.small", "c1.medium"], "Choose instance size") elif arch == "x86_64": config["instance_type"] = util.choose(["m1.large", "m1.xlarge", "c1.xlarge"], "Choose instance size") else: print "Sorry, bad arch" sys.exit() # Choose the number of instances config["max_count"] = util.choose([2, 4, 8, 16, 32, 64, 128, 256], "Number of instances") # If this is a large cluster, set the min at 80% of the requested if config["max_count"] > 32: config["min_count"] = int(0.8 * config["count"]) else: config["min_count"] = config["max_count"] # Choose the SSH key to use available_keys = EC2MPI.get_mpi_keys() if len(available_keys) == 0: print "You don't have any keys, creating one now" config["mpi_key"] = EC2MPI.gen_mpi_key() else: available_keys += ["Create a new key"] mpi_key = util.choose(available_keys, "Choose a key to use for MPI communication") if mpi_key == "Create a new key": config["mpi_key"] = EC2MPI.gen_mpi_key() else: config["mpi_key"] = mpi_key rand_name = EC2MPI.rand_name() cluster_name = raw_input("Name this cluster (q to Quit) [%s]: " % rand_name) while 1: if cluster_name == u"q": sys.exit() if cluster_name == u"": cluster_name = rand_name if EC2MPI.domain.get_item(cluster_name): print "Name is already taken" rand_name = EC2MPI.rand_name() cluster_name = raw_input("Name this cluster (q to Quit) [%s]: " % rand_name) else: config["name"] = cluster_name break config["status"] = "config" config["reservation"] = "" config["s3_bucket"] = S3_BUCKET config["mpi_bucket"] = md5.new(config["name"]).hexdigest() config["placement"] = "us-east-1a" return config
def sample(n): actions = [] while len(actions) < n: n = random.randint(1, max_n) combo_i = random.randint(0, util.choose(len(territories_owned), n) - 1) alloc_i = random.randint(0, util.choose(reinforcements - 1, n - 1) - 1) combo = util.kth_n_combination(territories_owned, n, combo_i) alloc = util.kth_n_integer_composition(reinforcements, n, alloc_i) action = risk.Place(combo, alloc) if action not in actions: yield action actions.append(action)
def computeMeanPairwiseHammingDistance(result, clusterIndices, clusterIndexToProfileMap=None): ''' clusterIndices: list of indices for which pairs are created. clusterIndexToProfileMap: a map from cluster index to precomputed cluster profiles. if there are more clusterIndices than the TERM_PROMISCUITY_LIMIT, return None. if there is only one cluster index, return 0. otherwise, return the mean of the hamming distances of every pair of clusterIndices. n choose 2 pairs. ''' numClusters = len(clusterIndices) # ignore terms associated with many clusters on the assumption that they are too general to be interesting. if numClusters > TERM_PROMISCUITY_LIMIT: return None numPairs = 0 totalHammingDistance = 0 for indexPair in util.choose(clusterIndices, 2): numPairs += 1 # hamming distance is the number of differences in two equal length bit strings. if clusterIndexToProfileMap: profile0 = clusterIndexToProfileMap[indexPair[0]] profile1 = clusterIndexToProfileMap[indexPair[1]] else: profile0 = getProfileForCluster(result['rows'][indexPair[0]]) profile1 = getProfileForCluster(result['rows'][indexPair[1]]) totalHammingDistance += hammingDistanceForProfiles(profile0, profile1) if numPairs > 0: meanPairwiseHammingDistance = totalHammingDistance / float(numPairs) else: meanPairwiseHammingDistance = 0 return meanPairwiseHammingDistance
def test_choose_with_known_examples(): examples = { (0, 0): 1, (0, 1): 0, (1, 0): 1, (4, 2): 6, (2, 4): 0, (10, 3): 120 } for ((n, k), expected) in examples.items(): assert util.choose(n, k) == expected
def _react(self, action): state = util.choose( self.P[ action ][ self.state ] ) reward = self.R.get( (self.state, state), 0 ) + self.R_bias # If there is no way to get out of this state, the episode has ended if self.end_set is not None: episode_ended = state in self.end_set else: episode_ended = len( self.Q[ state ] ) == 0 if episode_ended: state = self._start() self.state = state return state, reward, episode_ended
def choose_small_world( path_lengths, s, r ): # Check distances dists = path_lengths[s][1] if s in dists: dists.pop( s ) if not dists: return None neighbours, dists = zip( *dists.items() ) # Create a pr distribution dists = np.power( np.array( dists, dtype=float ), -r ) # Zero out neighbours for i in xrange( len( dists ) ): if dists[i] == 1: dists[i] = 0 if not dists.any(): return None s_ = util.choose( zip( neighbours, dists ) ) return s_
def choose_small_world(path_lengths, s, r): # Check distances dists = path_lengths[s][1] if s in dists: dists.pop(s) if not dists: return None neighbours, dists = zip(*dists.items()) # Create a pr distribution dists = np.power(np.array(dists, dtype=float), -r) # Zero out neighbours for i in xrange(len(dists)): if dists[i] == 1: dists[i] = 0 if not dists.any(): return None s_ = util.choose(zip(neighbours, dists)) return s_
def makePairsForGenomeParams(genome=None, limit_genomes=None, genomes=None): # all genomes allGenomes = [] if genome: allGenomes.append(genome) if genomes: allGenomes.extend(genomes) if limit_genomes: allGenomes.extend(limit_genomes) allGenomes = list(set(allGenomes)) # all pairs of genomes pairs = roundup_common.normalizePairs(util.choose(allGenomes, 2)) if genome: pairs = [pair for pair in pairs if pair[0] == genome or pair[1] == genome] if limit_genomes: pairs = [pair for pair in pairs if pair[0] in limit_genomes or pair[1] in limit_genomes] if genomes: pairs = [pair for pair in pairs if pair[0] in genomes and pair[1] in genomes] return pairs
def get_next_price(self, price, timestep): return choose(self.future_prices_and_probabilities(price, timestep))
def get_next_state(self, state, action, timestep): return choose( self.future_states_probabilities(from_state=state, action=action))
def p15(n=20, m=20): print choose(n+n,n)
import sys from bitarray import bitarray from util import choose, encode_ordinal if __name__ == "__main__": rank_count = int(sys.argv[1]) first_seed = bitarray(endian="little") first_seed.frombytes(bytes.fromhex(sys.argv[2])) second_seed = bitarray(endian="little") second_seed.frombytes(bytes.fromhex(sys.argv[3])) errors = first_seed ^ second_seed ordinal = encode_ordinal(errors) binom = choose(errors.length(), errors.count()) print("First Seed: ", first_seed.tobytes().hex()) print("Second Seed:", second_seed.tobytes().hex()) print("Difference:", errors.tobytes().hex()) print("Difference Count:", errors.count()) print("Combination Ordinal:", ordinal) print("Total Combinations:", binom) print("Rank Responsibility:", (ordinal * rank_count) // binom)
def p15(n=20, m=20): print choose(n + n, n)
def act( self, state ): action = util.choose( self.pi[ state ] ) return action