chosen module\n reps = self.representatives\n for rep, (spc_index, module_index) in self.species_module_index_map.items():\n if rep not in reps: # removes reps that no longer exist\n continue\n self.species_module_ref_map[rep] = generation.module_population.species[spc_index][module_index]\n else:\n for spc_index, module_index in self.species_module_index_map.items():\n if isinstance(module_index, tuple):\n \"\"\"this is an override index. this module is found in a different species\"\"\"\n if not Config.allow_cross_species_mappings:\n raise Exception('Cross species mapping disabled, but received tuple as value in map')\n spc, mod = module_index\n self.species_module_ref_map[spc_index] = generation.module_population.species[spc][mod]\n else:\n self.species_module_ref_map[spc_index] = generation.module_population.species[spc_index][\n module_index]","def strainNameHomogene(strain):\n\tstrain = strain.split(\",\")[0]\n\tstrain = strain.split(\"=\")[0]\n\tstrain = strain.split(\"(\")[0]\n\tstrain = strain.split(\"genome\")[0]\n\twords = [\"chromosome \", \"chromosome\", \"genomic island \", \"variant \", \"main \", \"complete \", \"genomic \", \"sequence \", \"sequence\", \"island \", \"Salmonella Genomic Island 1 \", \"genome \", \"strain \", \"plasmid \", \"str. \", \"REU80928 \"]\n\tfor word in words:\n\t\tstrain = strain.replace(word, \"\")\n\tstrain = strain.replace(\":\", \"-\")\n\tstrain = strain.replace(\" \", \"_\")\n\tif strain[-1] == \"_\": strain.rstrip()\n\tif strain[-1] == \"_\": strain.rstrip()\n\treturn strain","def make_synthetic_genome(human, phix, bacteria, size, dir, isfastq):\n \n # generate human reads\n get_human_reads(human, size, dir, isfastq)\n \n # generate phix reads\n get_phix_reads(phix, size, dir, isfastq)\n \n # generate bacteria reads\n get_bacteria_reads(bacteria, size, dir, isfastq)\n \n # generate virus reads\n get_virus_reads(1 - human - phix - bacteria, size, dir, isfastq)","def _add_transform_genes(self):\n pass","def moi(self):\n\n pass","def save(self, *args, **kwargs):\n self.trait_flavor_name = self.set_trait_flavor_name()\n # Call the \"real\" save method.\n super(HarmonizedTrait, self).save(*args, **kwargs)","def __species_annotation__(self,aggregation_so_far,annotation):\n return Survey.__species_annotation__(self,aggregation_so_far,[annotation])","def get_my_mutations(quality_cutoff, coverage_cutoff):\n\n # my_mutations = {}\n # with open('/home/perry/Projects/loh/working/murim.exome.aa_chg.vars') as f:\n # for line in f:\n # my_mutations[line.strip()] = True\n # return my_mutations\n\n bed_file = 'data/nimblegen/2.1M_Human_Exome_Annotation/2.1M_Human_Exome.bed'\n bed_chr2st2end, bed_chr2posLs = bed_tools.load_bed(bed_file, \n 'NimbleGen Tiled Regions')\n # NimbleGen Tiled Regions\n # Target Regions\n\n use_data_dir = '/home/perry/Projects/loh/data/all_non_ref_hg18/'\n all_somatic = {}\n all_inherited = {}\n cancer_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanT.ann')\n normal_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanN.ann')\n for exome in global_settings.exome_types:\n data_file = use_data_dir + exome\n inherited, somatic, murim = mutations.get_mutations(data_file, normal_qualities,\n cancer_qualities, quality_cutoff,\n False, coverage_cutoff)\n # only use the bed_tools NimbleGen\n # restriction for hg18 data\n for s in somatic['yusan']: \n chr, pos = s.split(':')\n if bed_tools.find_location_in_bed(chr, int(pos), \n bed_chr2posLs,\n bed_chr2st2end):\n all_somatic[s] = True\n for i in inherited['yusan']: \n chr, pos = s.split(':')\n if bed_tools.find_location_in_bed(chr, int(pos), \n bed_chr2posLs,\n bed_chr2st2end):\n all_inherited[i] = True\n return (set(all_somatic.keys()) & set(get_murim_covered(quality_cutoff)), set(all_inherited.keys()) & set(get_murim_covered(quality_cutoff)))","def update_entropy(self, save=True):\n\n #min_consensus = self.mturk_assignment.hit.hit_type \\\n #.experiment_settings.min_output_consensus\n min_consensus = 3\n\n # update substance label and entropy\n self.substance = None\n substances = self.substances.filter(invalid=False) \\\n .values_list('substance_id', flat=True)\n if substances:\n self.substance_entropy = compute_entropy(substances)\n hist = Counter(substances).most_common(2)\n substance_id, count = hist[0]\n # must be at least the consensus, and larger than the 2nd choice\n if count >= min_consensus and (len(hist) == 1 or hist[1][1] < count):\n self.substance_id = substance_id\n self.quality_method = 'M'\n\n # update name label and entropy\n self.name = None\n names = self.names.filter(invalid=False) \\\n .values_list('name_id', flat=True)\n if names.exists():\n self.name_entropy = compute_entropy(names)\n hist = Counter(names).most_common(2)\n name_id, count = hist[0]\n # must be at least the consensus, and larger than the 2nd choice\n if count >= min_consensus and (len(hist) == 1 or hist[1][1] < count):\n self.name_id = name_id\n self.quality_method = 'M'\n\n # update rectified normal\n self.rectified_normal = None\n if self.planar:\n for n in self.rectified_normals.all():\n if n.better_than(self.rectified_normal):\n self.rectified_normal = n\n if self.rectified_normal and not self.rectified_normal.correct:\n self.rectified_normal = None\n\n # update bsdf\n self.bsdf_wd = None\n for b in self.bsdfs_wd.all():\n if b.gloss_correct and b.color_correct and b.better_than(self.bsdf_wd):\n self.bsdf_wd = b\n\n if save:\n self.save()","def mutate_snp(genome, var):\n nt_options = {'A':['T','G','C'], 'T':['A','G','C'], 'G':['A','T','C'], 'C':['A','T','G']}\n n = random.randint(0,2)\n nt = nt_options.get(genome.seq[var.start])[n]\n genome.mut_seq[var.start] = nt\n\n var.ref = genome.seq[var.start]\n var.alt = nt","def map_to_mgi(adata, copy = False):\n from pybiomart import Server\n # connest to the biomart server\n server = Server(host='http://www.ensembl.org')\n\n # retrieve the mouse data set we need\n dataset = (server.marts['ENSEMBL_MART_ENSEMBL']\n .datasets['mmusculus_gene_ensembl'])\n\n # recieve the mapping from ensembl to MGI\n conv_table = dataset.query(attributes=['ensembl_gene_id', 'external_gene_name'])\n\n # we first drop duplicates in the first column\n conv_table = conv_table.drop_duplicates(conv_table.columns.values[0])\n\n # convert the gene names from the adata object to a data frame\n adata_table = pd.DataFrame(adata.var_names)\n\n # give the first column a name\n adata_table.columns = ['Gene stable ID']\n\n # change the gene table so that the ensembl names are now the index\n conv_table = conv_table.set_index('Gene stable ID')\n\n # project the names from the conversion table on the corr. names in the\n # adata var names table\n mapping = adata_table.join(conv_table, on='Gene stable ID')\n\n # how many could we not map\n not_found_mgi = sum(pd.isnull(mapping).iloc[:,1])\n\n # how many ensg symbols did we map several times?\n rep_ensg = len(mapping.iloc[:, 0]) - len(set(mapping.iloc[:, 0]))\n\n # how many mgi symbols did we map several times?\n rep_mgi = len(mapping.iloc[:, 1]) - len(set(mapping.iloc[:, 1]))\n\n # print this information\n print('Genes where no MGI annotations where found: {}\\nENSG repetition: {}\\nMGI repetition: {}'.\\\n format(not_found_mgi, rep_ensg, rep_mgi))\n\n # fill nans in mgi column with corresponding ensembl annotations\n mapping['Gene name'].fillna(mapping['Gene stable ID'], inplace = True)\n\n # add the new gene names to the adata object\n adata.var['mgi_symbols'] = mapping['Gene name'].tolist()","def take_control_over(self, other):\n a = self\n if a == other: return\n if util.onechancein(6): #make a master of b\n if other.master is not None:\n if other.master != a and a.master != other: #if b already had master, make a enemy of b.master\n a.history.append('In year %d %s tried to overtake the control over %s, but failed' % (world.year, a.name, other.name))\n other.master.conflict_with(a)\n else:\n if a.master == other: #if we overtook controll\n a.master = None\n try:\n other.minions.remove(a)\n except ValueError: pass\n try:\n other.master.minions.remove(other)\n except Exception : pass\n a.minions.append(other)\n other.master = a\n a.history.append('In year %d %s became boss over %s' %(world.year, a.name, other.name))","def update_module_indexes(self, generation):\n self.species_module_index_map = {}\n\n if Config.blueprint_nodes_use_representatives:\n # For representatives species_module_index_map becomes: representative -> (species index, member index)\n for rep, module in self.species_module_ref_map.items():\n if module is None:\n continue\n\n for species_index, species in enumerate(generation.module_population.species):\n if module in species:\n self.species_module_index_map[rep] = \\\n (species_index, generation.module_population.species[species_index].members.index(module))\n break\n else:\n for spc_index, module in self.species_module_ref_map.items():\n if module is None:\n continue\n\n if spc_index < len(generation.module_population.species) and \\\n module in generation.module_population.species[spc_index]:\n\n self.species_module_index_map[spc_index] = \\\n generation.module_population.species[spc_index].members.index(module)\n\n elif Config.allow_cross_species_mappings:\n for new_species_index, species in enumerate(generation.module_population.species):\n if module in species:\n \"\"\"found module in new species\"\"\"\n self.species_module_index_map[spc_index] = \\\n (new_species_index,\n generation.module_population.species[new_species_index].members.index(module))\n break","def setSharp(self,sharp):\n super(self.__class__, self).setSharp(self, sharp)","def addMaster(self,masterName):\n masterInfo = modInfos[masterName]\n self.masterNames.append(masterName)\n #--Map info\n iMod = len(self.masterNames)\n #--Map masters\n masterMap = self.getMasterMap(masterInfo)\n masterRefs = masterInfo.extras['FileRefs']\n #--Get Refs types and alts\n cellRefIds = self.cellRefIds\n cellRefAlts = self.cellRefAlts\n #--Progress\n cntCells = 0\n progress = self.progress\n progress.setMax(len(masterRefs.cells))\n progress(0.0,_(\"Building \")+masterName)\n for cell,record in masterRefs.lands.items():\n self.lands[cell] = record\n for masterCell in masterRefs.cells:\n cellId = masterCell.getId()\n #--Named exterior cell?\n if not (masterCell.flags & 1) and masterCell.cellName:\n self.extCellNames.add(masterCell.cellName)\n #--New cell id?\n if cellId not in cellRefIds:\n refIds = cellRefIds[cellId] = {}\n refAlts = cellRefAlts[cellId] = {}\n #--Exiting cell id?\n else:\n refIds = cellRefIds[cellId]\n refAlts = cellRefAlts[cellId]\n #--Objects\n for object in masterCell.getObjects().list():\n (iMMod,iObj,objId) = object[:3]\n newIdKey = (iMod,iObj)\n #--Modifies a master reference?\n if iMMod:\n if iMMod >= len(masterMap):\n raise Tes3RefError(masterName,cellId,objId,iObj,iMMod,\n _('NO SUCH MASTER'))\n altKey = (masterMap[iMMod],iObj)\n oldIdKey = altKey\n #--Already modified?\n if altKey in refAlts:\n oldIdKey = refAlts[altKey]\n if oldIdKey not in refIds:\n raise Tes3RefError(masterName,cellId,objId,iObj,iMMod,\n masterInfo.masterNames[iMMod-1])\n del refIds[oldIdKey]\n refAlts[altKey] = newIdKey\n #print cellId, newIdKey, objId\n #--Save it\n refIds[newIdKey] = objId\n #--Progress\n cntCells += 1\n progress(cntCells)\n #--Debris Ids\n for type, ids in masterRefs.debrisIds.items():\n if type not in self.debrisIds:\n self.debrisIds[type] = set()\n self.debrisIds[type].update(ids)\n #--List Masters\n levListMasters = self.levListMasters\n for levList in (masterRefs.debrisIds['LEVC'] + masterRefs.debrisIds['LEVI']):\n if levList not in levListMasters:\n levListMasters[levList] = []\n levListMasters[levList].append(masterName)","def testMakeNewSpecies(self):\n\n # adding 3 unique species:\n cerm = CoreEdgeReactionModel()\n\n spcs = [Species().fromSMILES('[OH]'), \n Species().fromSMILES('CC'),\n Species().fromSMILES('[CH3]')]\n\n for spc in spcs:\n cerm.makeNewSpecies(spc)\n\n self.assertEquals(len(cerm.speciesDict), len(spcs)) \n self.assertEquals(len(cerm.indexSpeciesDict), len(spcs))\n\n # adding 3 unique, and 1 already existing species:\n cerm = CoreEdgeReactionModel()\n\n spcs = [Species().fromSMILES('[OH]'), \n Species().fromSMILES('CC'),\n Species().fromSMILES('[CH3]'),\n Species().fromSMILES('CC')]#duplicate species\n\n for spc in spcs:\n cerm.makeNewSpecies(spc)\n\n self.assertEquals(len(cerm.speciesDict), len(spcs) - 1) \n self.assertEquals(len(cerm.indexSpeciesDict), len(spcs) - 1)","def remap(self,newMasters,modMap,objMaps=[]):\n #--Masters\n self.tes3.masters = newMasters\n #--File mapping\n modMapKeys = modMap.keys()\n #--Remap iObjs\n cells_id = self.cells_id\n reObjNum = re.compile('[0-9A-Z]{8}$')\n for (iMod,objMap) in objMaps:\n cellIds = objMap.keys()\n for cellId in cellIds:\n cellObjMap = objMap[cellId]\n #--Save \n cell = cells_id.get(cellId)\n if not cell: continue\n #--Objects\n objects = cell.getObjects()\n for object in objects.list():\n #--Different mod?\n if object[0] != iMod:\n pass\n #--Cell deleted?\n elif cellObjMap == -1:\n objects.remove(object)\n #--Remapped object?\n elif object[1] in cellObjMap:\n (newIObj,objId) = cellObjMap[object[1]]\n objIdBase = reObjNum.sub('',objId) #--Strip '00001234' id num from object\n #--Mismatched object id?\n if objId != objIdBase:\n #print 'Mismatch:',object[:3]\n pass \n #--Deleted object?\n elif newIObj == -1:\n #print 'Deleted',object[:3]\n objects.remove(object)\n #--Remapped object?\n else:\n #print 'Remapped',object[:3],'to',newIObj\n newObject = self.remapObject(object,iMod,newIObj)\n objects.replace(object,newObject)\n self.updateScptRefs()\n #--Remap iMods\n if not modMapKeys: return\n for cell in self.cells:\n objects = cell.getObjects()\n for object in objects.list():\n #--Remap IMod\n iMod = object[0]\n #--No change?\n if iMod not in modMapKeys: \n pass\n #--Object deleted?\n elif modMap[iMod] == -1:\n objects.remove(object)\n #--Object not deleted?\n else:\n newObject = self.remapObject(object,modMap[iMod])\n objects.replace(object,newObject)\n self.updateScptRefs()","def refine(self): # pylint: disable=R0201\n return True","def __init__(\n self,\n locus_tag: str,\n gene_type: str,\n location: Union[FeatureLocation, CompoundLocation],\n name: str,\n reference_sequence: Seq,\n cog: str = None,\n y_ome: str = None,\n essential: bool = False,\n replication_strand: str = None,\n origin_distance: int = None,\n terminus_distance: int = None\n ):\n\n super().__init__('gene', location=location, reference_sequence=reference_sequence, name=name)\n self.reading_frame = get_reading_frame(self.location, len(reference_sequence))\n\n # if the gene is a coding sequence, it should have a multiple of 3 length; sequence is set by super init\n if gene_type == 'CDS' and len(self.location) % 3 != 0:\n raise ValueError(locus_tag + ': sequence should have multiple of 3 length if gene is coding')\n\n self.locus_tag = locus_tag\n self.gene_type = gene_type\n self.cog = cog\n self.y_ome = y_ome\n self.essential = essential\n self.replication_strand = replication_strand\n self.origin_distance = origin_distance\n self.terminus_distance = terminus_distance\n \n # only set by add_regulon_db_gene_ids\n self.id = None\n\n # only set after calculate_and_add_cai is run\n self.cai = None\n\n # only set after the appropriate linking functions are run\n self.protein = None\n self.trna = None\n self.transcription_units = []\n self.attenuators = []\n self.riboswitches = []\n self.shine_dalgarno = None\n self.i_modulons = []","def fromGenomeRepresentation(self,genome):\n self.clear()\n #print(genome)\n tokens = genome.split(\"||\")\n self.setAxiomFromString(tokens[0])\n self.setIterations(int(tokens[1]))\n for i in range(2,len(tokens)): self.addProductionFromGenomeRepresentation(tokens[i])"],"string":"[\n \"def update_species(self):\\n warn(f\\\"Default Update Species Called for Mechanism = {self.name}.\\\")\\n return []\",\n \"def update_species_frames(self):\\n pass\",\n \"def speciate(self):\\n\\n\\n # Clear out the previous generation\\n for spec in self.species.values():\\n spec.champ = spec.get_champion()\\n spec.flush()\\n\\n for genome in self.all_genomes:\\n if genome.species_hint is not None:\\n spec = self.species.get(genome.species_hint)\\n if spec and spec.is_compatible(genome):\\n spec.add_genome(genome)\\n continue\\n\\n for spec in self.species.values():\\n # check compatibility until found\\n if spec.is_compatible(genome):\\n spec.add_genome(genome)\\n break\\n else: # make a new spec\\n spec_num = self.get_next_species_num()\\n spec = Species(self, spec_num)\\n spec.add_genome(genome)\\n spec.champ = genome\\n self.species[spec_num] = spec\\n\\n # Delete unnecessary species\\n for spec_num, spec in list(self.species.items()):\\n if len(spec)==0:\\n self.species.pop(spec_num)\",\n \"def speciate_genomes(self):\\n for genome in self.genomes:\\n species_found = False\\n\\n for species in self.species:\\n compatibility = genome.compatibility(species.leader)\\n\\n if compatibility < self.config.compatibility_threshold:\\n species.add_genome(genome)\\n species_found = True\\n break\\n\\n if not species_found:\\n new_species = Species(self.species_id, genome, self.config, self.breeder)\\n self.species.append(new_species)\\n self.species_id += 1\",\n \"def set_species(self, species):\\n self.species = species\",\n \"def mutate(genome):\\n mutated_genome = copy.deepcopy(genome) # make a copy of the DNA to mutate\\n seed = random.randint(0,3)\\n if len(mutated_genome) == 0: seed = 0\\n if seed == 0:\\n mutate_chromosome(mutated_genome)\\n elif seed == 1:\\n mutate_point(mutated_genome)\\n elif seed == 2:\\n mutate_color(mutated_genome)\\n else: #seed ==3:\\n mutate_opacity(mutated_genome)\\n return mutated_genome\",\n \"def inherit(self, genome):\\n self.da_scheme = genome.da_scheme\\n self.weight_init = copy.deepcopy(genome.weight_init)\\n self.species_module_ref_map = genome.species_module_ref_map\",\n \"def _fix_genotypes_object(self, genotypes, variant_info):\\n # Checking the name (if there were duplications)\\n if self.has_index and variant_info.name != genotypes.variant.name:\\n if not variant_info.name.startswith(genotypes.variant.name):\\n raise ValueError(\\\"Index file not synced with IMPUTE2 file\\\")\\n genotypes.variant.name = variant_info.name\\n\\n # Trying to set multi-allelic information\\n if self.has_index and self._index_has_location:\\n # Location was in the index, so we can automatically set the\\n # multi-allelic state of the genotypes\\n genotypes.multiallelic = variant_info.multiallelic\\n\\n else:\\n # Location was not in the index, so we check one marker before and\\n # after the one we found\\n logging.warning(\\\"Multiallelic variants are not detected on \\\"\\n \\\"unindexed files.\\\")\",\n \"def update_species(self, mixture, concentration):\\n # Create component specific species\\n # self.product = add_species(model, \\\"Type\\\", name)\\n \\n # Create any other species needed by component mechanisms\\n mechanisms = get_mechanisms(mixture, self)\\n for name in mechanisms:\\n mechanism = mechanisms[name]\\n mechanism.update_species(mixture, self, concentration)\\n \\n # If the default member function gets used, issue a warning\\n warn(\\\"component: default __init__ called for \\\" + name)\",\n \"def mutate(self, organism):\\n mutated_org = organism.copy()\\n \\n gene_choices = mutated_org.genome.alphabet.letters\\n \\n # potentially mutate any gene in the genome\\n for gene_index in range(len(mutated_org.genome)):\\n mutation_chance = self._mutation_rand.random()\\n # if we have a mutation\\n if mutation_chance <= self._mutation_rate:\\n # get a new letter\\n new_letter = self._switch_rand.choice(gene_choices)\\n mutated_org.genome[gene_index] = new_letter\\n\\n return mutated_org\",\n \"def update (self) :\\n for met in self.gene :\\n met(self)\",\n \"def mutate(self, chrom):\\n pass\",\n \"def mutate_chromosome(mutated_genome):\\n seed = random.randint(0,5)\\n if len(mutated_genome) <= 1: seed = 0\\n if seed == 0:\\n insert_chromosome(mutated_genome)\\n elif seed == 1:\\n remove_chromosome(mutated_genome)\\n elif seed == 2:\\n switch_chromosomes(mutated_genome)\\n elif seed == 3:\\n shuffle_chromosomes(mutated_genome)\\n elif seed == 4:\\n increment_chromosome(mutated_genome)\\n else: #seed == 5:\\n decrement_chromosome(mutated_genome)\",\n \"def mutate(self, organism):\\n mutated_org = organism.copy()\\n gene_choices = mutated_org.genome.alphabet.letters\\n\\n mutation_chance = self._mutation_rand.random()\\n if mutation_chance <= self._mutation_rate:\\n # pick a gene position to mutate at\\n mutation_pos = \\\\\\n self._pos_rand.choice(range(len(mutated_org.genome)))\\n \\n # get a new letter to replace the position at\\n new_letter = self._switch_rand.choice(gene_choices)\\n\\n mutated_org.genome[mutation_pos] = new_letter\\n\\n return mutated_org\",\n \"def mutate_seq(genome):\\n for var in genome.get_variants():\\n if var.type == \\\"snp\\\":\\n mutate_snp(genome, var)\\n elif var.type == \\\"indel\\\":\\n mutate_indel(genome, var)\\n elif var.type == \\\"deletion\\\":\\n mutate_deletion(genome, var)\\n elif var.type == \\\"translocation origin\\\":\\n mutate_trans_orig(genome, var)\\n elif var.type == \\\"translocation insert\\\":\\n mutate_trans_ins(genome, var)\",\n \"def inject_genome(self, genome: Genome):\\n self.population[genome.key] = genome\",\n \"def mutate_append(self, gene):\\n gene.chromosome.append(self.tactics.mutate_select())\",\n \"def testExcessiveRamReallocation(self):\\n self.assertEqual(1769, self.c.get_species_richness(1))\\n self.assertEqual(1769, self.c.get_species_richness(2))\",\n \"def switch_chromosomes(mutated_genome):\\n index1 = random.randint(0,max(0,len(mutated_genome)-1))\\n index2 = random.randint(0,max(0,len(mutated_genome)-1))\\n temp = mutated_genome[index1]\\n mutated_genome[index1] = mutated_genome[index2]\\n mutated_genome[index2] = temp\",\n \"def testDispersalMapSimulation(self):\\n self.assertEqual(701, self.c.get_species_richness(1))\",\n \"def test_enlarge_1_add_nonreactive_species(self):\\n m0 = Molecule(smiles='[He]')\\n spc0 = self.rmg.reaction_model.make_new_species(m0, label='He', reactive=False)[0]\\n self.rmg.reaction_model.enlarge(spc0)\\n\\n self.assertEqual(len(self.rmg.reaction_model.core.species), 1)\\n self.assertFalse(self.rmg.reaction_model.core.species[0].reactive)\",\n \"def update_monster(self):\\n\\n\\t\\t# if nothing else gets added to this (no other changes to update) you could delete\\n\\t\\t# this function and simply call self.choose_guard() in its place\\n\\t\\tself.guarded_area = self.choose_guard()\",\n \"def test_enlarge_2_add_reactive_species(self):\\n m1 = Molecule(smiles='CC')\\n spc1 = self.rmg.reaction_model.make_new_species(m1, label='C2H4')[0]\\n self.rmg.reaction_model.enlarge(spc1)\\n\\n self.assertEqual(len(self.rmg.reaction_model.core.species), 2)\\n self.assertTrue(self.rmg.reaction_model.core.species[1].reactive)\\n\\n m2 = Molecule(smiles='[CH3]')\\n spc2 = self.rmg.reaction_model.make_new_species(m2, label='CH3')[0]\\n self.rmg.reaction_model.enlarge(spc2)\\n\\n self.assertEqual(len(self.rmg.reaction_model.core.species), 3)\\n self.assertTrue(self.rmg.reaction_model.core.species[2].reactive)\",\n \"def add_animal(self, animal):\\n try:\\n if animal.saltwater:\\n super().add_animal(animal)\\n except AttributeError:\\n raise AttributeError(\\\"Animal Is Incompatible With Biome\\\")\",\n \"def mutate(self):\\n\\n if len(self.genes) < 250:\\n for g in self.genes:\\n\\n if MUTATION_CHANCE < random.random(): # random.random() gives float in [0,1)\\n g.mutate()\\n\\n else:\\n k = int(MUTATION_CHANCE*len(self.genes))\\n for g in random.sample(self.genes,int(k)): #int(k)\\n g.mutate()\\n\\n #To add random gene\\n if ADD_GENE_CHANCE < random.random():\\n self.genes.append(Gene(self.size)) #Call to Gene to add to genes list\\n\\n #To randomly remove genes\\n\\n if REM_GENE_CHANCE < random.random() and len(self.genes)>0:\\n self.genes.remove(random.choice(self.genes))\",\n \"def exogenous_change(self):\\n pass\",\n \"def exogenous_change(self):\\n pass\",\n \"def exogenous_change(self):\\n pass\",\n \"def species_converter():\\n \\n geneD = gene_list_converter() # dict with keys as human gene IDS, and values as human gene symbols\\n convertD = homologue_parser() # dict with human gene symbols as keys, and mouse gene symbols as values\\n# k = 0\\n# for i,j in geneD.items():\\n# print(i,j)\\n# k += 1\\n# if k == 10000: break\\n# print(\\\"------------------------------------------------\\\")\\n# k = 0\\n# for i,j in convertD.items():\\n# print(i,j)\\n# k += 1\\n# if k == 100: break\\n \\n procD = {} # key is human gene ID, value is a dict with human gene symbol as key, mouse gne symbol as value\\n missL = []\\n missIDL = []\\n \\n for geneK, geneV in geneD.items(): # geneK: human gene ID, geneV = human gene symbol\\n if geneV == \\\"-\\\": # handle missing gene symbols\\n procD[geneK] = {\\\"-\\\": [\\\"-\\\"]}\\n continue\\n \\n if geneV in convertD:\\n if geneK in procD:\\n print(geneK,geneV,procD[geneK])\\n raise ValueError\\n \\n else: procD[geneK] = {geneV: convertD[geneV]}\\n \\n else: \\n missL.append(geneV) # collect gene symbols for which no mouse homologue was found\\n missIDL.append(geneK) # collect matching gene IDs too\\n procD[geneK] = {geneV: [\\\"-\\\"]} # store entries as missing for now\\n \\n missSeqD = prot_sequence_finder(missL) # prepare a dict with keys as missing human gene symbols and values as their sequences in humans where applicable\\n missNameL = []\\n missGIL = []\\n print(\\\"BLASTing \\\" + str(len(missSeqD)) + \\\" sequences...\\\")\\n for keyS, valueS in missSeqD.items():\\n missGIL.append(blaster(valueS)) # blast sequences and get their mouse refseq protein GI. this step will take a lot of time. this list will contain mouse protein genbank accessions\\n missNameL.append(keyS) # the matching human gene symbols\\n \\n missSymbolD = prot_id_converter(missGIL, \\\"10090\\\", \\\"genbankproteinaccession\\\", \\\"genesymbol\\\") # convert protein GIs to gene symbols. keys are mouse protein GIs, values are mouse gene symbols\\n print(missSymbolD)\\n\\n \\n for i in range(len(missIDL)):\\n if missL[i] in missNameL: procD[missIDL[i]] = {missL[i]: [missSymbolD[missGIL[missNameL.index(missL[i])]]]} \\n \\n mouseGeneL = []\\n for keyS in procD.keys():\\n for valueL in procD[keyS].values(): \\n if valueL == [\\\"-\\\"]: continue\\n for valueI in valueL:\\n if valueI in mouseGeneL: continue\\n mouseGeneL.append(valueI)\\n \\n mouseD = prot_id_converter(mouseGeneL, \\\"10090\\\", \\\"genesymbol\\\", \\\"geneid\\\")\\n \\n with file_importer(\\\"data/converted_gene_list.csv\\\", \\\"w\\\") as outF:\\n for keyS in procD.keys():\\n outF.write(keyS + \\\",\\\")\\n for keyN, valueN in procD[keyS].items():\\n outF.write(keyN + \\\",\\\")\\n if keyN == \\\"-\\\":\\n outF.write(\\\"-,-\\\\n\\\")\\n continue\\n valL = []\\n for valueI in valueN:\\n if valueI in mouseD: valL.append(mouseD[valueI])\\n else: valL.append(\\\"-\\\")\\n \\n if valueI is valueN[-1]: outF.write(valueI + \\\",\\\")\\n else: outF.write(valueI + \\\";\\\")\\n \\n for valI in valL:\\n if valI is valL[-1]: \\n if \\\"//\\\" in valI: \\n valIL = valI.split(\\\"//\\\")\\n for valILI in valIL:\\n if valILI is valIL[-1]: outF.write(valILI + \\\"\\\\n\\\")\\n else: outF.write(valILI + \\\";\\\")\\n else: outF.write(valI + \\\"\\\\n\\\")\\n \\n else: \\n if \\\"//\\\" in valI: \\n valIL = valI.split(\\\"//\\\")\\n for valILI in valIL:\\n outF.write(valILI + \\\";\\\")\\n else: outF.write(valI + \\\";\\\")\\n print(\\\"file written\\\")\",\n \"def modifyMastersWithMultipleInstances(self):\\n # Nothing to do\\n pass\",\n \"def test_unique_genome(self):\\n p1 = self.player()\\n p2 = self.player()\\n self.assertTrue(p1.genome is p2.genome)\",\n \"def mutate(self, child):\\n for i in range(0, self.chromosome_length):\\n if random.randint(1, 100) <= self.mutation_chance:\\n child[i] = self.random_gene()\\n return child\",\n \"def try_insert_genome(self, genome):\\n raise Exception(\\\"called abstract insert_genome method\\\")\",\n \"def switch_opacities(mutated_genome):\\n index1 = random.randint(0,max(0,len(mutated_genome)-1))\\n index2 = random.randint(0,max(0,len(mutated_genome)-1))\\n temp = mutated_genome[index1][1]\\n mutated_genome[index1][1] = mutated_genome[index2][1]\\n mutated_genome[index2][1] = temp\",\n \"def set_optimizeable_hydrogens(self):\\n for residue in self.biomolecule.residues:\\n optinstance = self.is_optimizeable(residue)\\n if optinstance is None:\\n continue\\n for atom in residue.atoms:\\n if atom.name in optinstance.map:\\n atom.optimizeable = 1\",\n \"def _update(self, other):\\n # NOTE: detail map properties should NEVER be overridden. NEVER. EVER. kthx.\\n if other.use_alpha:\\n self.use_alpha = True\\n if other.mipmap:\\n self.mipmap = True\",\n \"def fix_chromosome(self, copy=False):\\n region = self.copy() if copy else self\\n if region.chromosome.startswith('chr'):\\n region.chromosome = region.chromosome[3:]\\n else:\\n region.chromosome = 'chr' + region.chromosome\\n return region\",\n \"def adjust_fitness_scores(self):\\n\\n for species in self.species:\\n species.adjust_fitness()\",\n \"def test_migrate_all_herbi_in_cell_new_location(\\n standard_map_peninsula):\\n animals.Herbivores.parameters[\\\"mu\\\"] = 1000\\n mock_ek = {(1, 18): 2}\\n standard_map_peninsula.raster_model[(\\n 1, 19)]._migrate_all_herbivores_in_cell(\\n standard_map_peninsula, (1, 19), mock_ek)\\n animals.Herbivores.parameters[\\\"mu\\\"] = 0.25\\n assert standard_map_peninsula.raster_model[(1, 19)].herbivore_list == []\\n assert standard_map_peninsula.raster_model[(1, 18)].herbivore_list != []\",\n \"def save(self, *args, **kwargs):\\n self.chromosome_no = CHROMOSOME_STR_TO_CHROMOSOME_INT.get(self.chromosome, 0)\\n super().save(*args, **kwargs)\",\n \"def save(self, *args, **kwargs):\\n self.chromosome_no = CHROMOSOME_STR_TO_CHROMOSOME_INT.get(self.chromosome, 0)\\n super().save(*args, **kwargs)\",\n \"def remove_unimproved_species(self):\\n for spec_num, spec in list(self.species.items()):\\n if self.gen_num - spec.gen_last_improved > self.species_dropoff_age:\\n self.species.pop(spec_num)\",\n \"def family(self):\",\n \"def add_species(self, side='R'): \\n self.unpack_ecosystem()\\n if side == 'L':\\n self.ecosystem.insert(0,Species(self))\\n elif side == \\\"R\\\":\\n self.ecosystem.append(Species(self))\\n self.num_species+=1\\n self.pack_ecosystem()\\n self.request_payment(\\\"discard\\\")\",\n \"def replaceLoser(self, parents, newoffspring): \\n\\n loser = min(parents, key=self.applyFitness)\\n\\n for index, individual in enumerate(self.currentGeneration):\\n if (individual == loser):\\n self.currentGeneration[index] = newoffspring\",\n \"def test_patch_bios_unit(self):\\n pass\",\n \"def test_big_family(self):\\n\\n self.taxon_tester('Staphylinidae')\",\n \"def reindex_subcomponent_taxa(self):\\n ti_mutable = self.taxon_set._is_mutable\\n self.taxon_set._is_mutable = True\\n new_map = CharacterDataMap()\\n for taxon, seq in self.taxon_seq_map.items():\\n taxon = self.taxon_set.require_taxon(label=taxon.label)\\n new_map[taxon] = seq\\n self.taxon_set._is_mutable = ti_mutable\\n self.taxon_seq_map = new_map\",\n \"def adjust_fitness(self):\\n # see genetics.cpp:2668 \\\"Can change the fitness of the organisms in the\\n # species to be higher for very new species (to protect them)\\\"\\n # NOTE I don't believe this is found in the paper\\n # Looks like they used a 1 for this param anyway, so it didn't do\\n # anything\\n\\n cur_max = self.get_champion().fitness\\n if cur_max > self.max_fitness_ever:\\n self.max_fitness_ever = cur_max\\n self.gen_last_improved = self.pop.gen_num\\n\\n for g in self.genomes:\\n g.adj_fitness = g.fitness/len(self)\\n\\n # genetics.cpp:2699 Kill species that haven't progressed for a long\\n # time by dividing fitness of all individuals in spec by 100. Weird way\\n # to do it.\\n if ((self.pop.gen_num - self.gen_last_improved) >\\n self.pop.species_dropoff_age):\\n for g in self.genomes:\\n g.adj_fitness *= .01\",\n \"def mountable(self):\\n return True\",\n \"def pre_modify(self):\\n return 0\",\n \"def clone(self):\\n raise GAError, 'must define clone() in your genome class'\",\n \"def testDispersalSimulation(self):\\n self.assertEqual(1172, self.c.get_species_richness(1))\",\n \"def add_gene(self, human_gene, ortholog):\\n if human_gene not in self.genes:\\n self.genes[human_gene] = list()\\n self.genes[human_gene].append(ortholog)\",\n \"def update_taxon_set(self):\\n assert self.taxon_set is not None\\n for taxon in self.taxon_seq_map:\\n if taxon not in self.taxon_set:\\n self.taxon_set.add(taxon)\",\n \"def mutate(self, mutation_record, attribute_magnitude=1, topological_magnitude=1, module_population=None, gen=-1):\\n if Config.module_retention and random.random() < 0.1 * topological_magnitude and self.species_module_ref_map:\\n # release a module_individual\\n tries = 100\\n\\n while tries > 0:\\n species_no = random.choice(list(self.species_module_ref_map.keys()))\\n if self.species_module_ref_map[species_no] is not None:\\n self.species_module_ref_map[species_no] = None\\n break\\n tries -= 1\\n\\n if Config.evolve_data_augmentations and random.random() < 0.2:\\n self.da_scheme = None\\n\\n if Config.blueprint_nodes_use_representatives:\\n # All representative mutation detailed in Sasha's paper section 3.2.4\\n reps = self.representatives\\n for node in self._nodes.values():\\n if gen == -1:\\n raise Exception('Invalid generation number: -1')\\n\\n # Increase mutation chance early to better explore the space of representatives\\n chance = Config.rep_mutation_chance_early if gen <= 3 else Config.rep_mutation_chance_late\\n if random.random() > chance: # no rep mutation\\n continue\\n\\n old_rep = copy.deepcopy(node.representative)\\n new_rep = node.choose_representative(module_population.individuals, reps)\\n\\n # Chance to mutate all nodes with the same representative\\n if random.random() < Config.similar_rep_mutation_chance:\\n for other_node in self._nodes.values():\\n if other_node.representative == old_rep:\\n other_node.representative = new_rep\\n\\n nodes_before_mutation = set(self._nodes.keys())\\n mutated = super()._mutate(mutation_record, Props.BP_NODE_MUTATION_CHANCE, Props.BP_CONN_MUTATION_CHANCE,\\n attribute_magnitude=attribute_magnitude, topological_magnitude=topological_magnitude)\\n # Check if a node was added and assign it a representative\\n if Config.blueprint_nodes_use_representatives:\\n for node_id in self._nodes.keys():\\n if node_id not in nodes_before_mutation:\\n self._nodes[node_id].choose_representative(module_population.individuals, reps)\\n\\n return mutated\",\n \"def genome(self, genome_id=\\\"hg19\\\"):\\n self.command(\\\"genome %(genome_id)s\\\" % locals())\",\n \"def registeredBy(self, world):\\n self.world = world\\n self._determineSuffix()\\n self.short = \\\"\\\"\\n self.short = self.shortName(3)\",\n \"def inherit_species_module_mapping(self, generation, other, acc, da_scheme=None, inherit_module_mapping=True):\\n if acc > self.max_accuracy:\\n if inherit_module_mapping:\\n other.update_module_refs(generation)\\n self.species_module_ref_map = other.species_module_ref_map\\n\\n self.max_accuracy = acc\\n\\n if da_scheme is not None:\\n self.da_scheme = da_scheme\",\n \"def add_species(self, side='R'): \\n #self.disable_all_buttons() \\n Player.add_species(self, side=side)\",\n \"def test_make_new_species(self):\\n\\n # adding 3 unique species:\\n cerm = CoreEdgeReactionModel()\\n\\n spcs = [Species().from_smiles('[OH]'),\\n Species().from_smiles('CC'),\\n Species().from_smiles('[CH3]')]\\n\\n for spc in spcs:\\n cerm.make_new_species(spc)\\n\\n self.assertEquals(len(cerm.species_dict), len(spcs))\\n self.assertEquals(len(cerm.index_species_dict), len(spcs))\\n\\n # adding 3 unique, and 1 already existing species:\\n cerm = CoreEdgeReactionModel()\\n\\n spcs = [Species().from_smiles('[OH]'),\\n Species().from_smiles('CC'),\\n Species().from_smiles('[CH3]'),\\n Species().from_smiles('CC')] # duplicate species\\n\\n for spc in spcs:\\n cerm.make_new_species(spc)\\n\\n self.assertEquals(len(cerm.species_dict), len(spcs) - 1)\\n self.assertEquals(len(cerm.index_species_dict), len(spcs) - 1)\",\n \"def is_other_chromosome(chromosome_name):\\n if is_cassette_chromosome(chromosome_name): return False\\n if chromosome_name.startswith('chr') or chromosome_name.startswith('scaffold'): return False\\n else: return True\",\n \"def add_genome(self, genome):\\n self.genomes.append(genome)\",\n \"def update(self):\\n self.chromosome_list = self.next_population\\n self.reset_mating_pool()\\n self.reset_next_population()\",\n \"def setAssociatedSpecies(self, *args):\\n return _libsbml.GeneProduct_setAssociatedSpecies(self, *args)\",\n \"def testDispersalSimulation(self):\\n self.assertEqual(715, self.c.get_species_richness(1))\",\n \"def mezclar_bolsa(self):\",\n \"def update(self, species, poscar, sort=True):\\n\\n if sort == False:\\n # for each 'tag' in the IndividualSpecies, create a list in self.tags\\n for key in list(species.values())[0].tags.keys():\\n if key.lower() in (VASP_TAG_INT_LIST + VASP_TAG_FLOAT_LIST):\\n self.tags[key] = 0.\\n for site in poscar.basis:\\n self.tags[key] += float(species[site.occupant].tags[key])\\n if key.lower() in VASP_TAG_INT_LIST:\\n self.tags[key] = int(self.tags[key])\\n else:\\n self.tags[key] = []\\n if key.lower() in (VASP_TAG_SPECF_LIST + VASP_TAG_SPECI_LIST):\\n # add the value of the 'tag' for each species into the self.tags list\\n for spec in poscar.type_atoms_alias:\\n self.tags[key].append(species[spec].tags[key])\\n else:\\n # add the value of the 'tag' for each atom into the self.tags list\\n for site in poscar.basis:\\n self.tags[key].append( species[site.occupant].tags[key] )\\n else:\\n pos = poscar.basis_dict()\\n # for each 'tag' in the IndividualSpecies, create a list in self.tags\\n for key in list(species.values())[0].tags.keys():\\n # for key in species[species.keys()[0]].tags.keys():\\n if key.lower() in (VASP_TAG_INT_LIST + VASP_TAG_FLOAT_LIST):\\n self.tags[key] = 0.\\n for site in poscar.basis:\\n self.tags[key] += float(species[site.occupant].tags[key])\\n if key.lower() in VASP_TAG_INT_LIST:\\n self.tags[key] = int(self.tags[key])\\n else:\\n self.tags[key] = []\\n # add the value of the 'tag' for each atom into the self.tags list\\n for alias in sorted(pos.keys()):\\n if key.lower() in (VASP_TAG_SPECF_LIST + VASP_TAG_SPECI_LIST):\\n # for species-specific tags, use the value specified for the\\n # species whose pseudopotential is being used for this alias\\n for name in species.keys():\\n if species[name].alias == alias and species[name].write_potcar:\\n self.tags[key].append(species[name].tags[key])\\n break\\n else:\\n for name in species.keys():\\n count=0\\n for site in pos[alias]:\\n if site.occupant == name:\\n count += 1\\n if species[name].alias == alias:\\n if count > 0:\\n self.tags[key].append( str(count) + \\\"*\\\" + str(species[name].tags[key]) )\",\n \"def _init_inherit_physical_attributes(self):\\n config = self.person.cosmos.config\\n mother, father = self.person.biological_mother, self.person.biological_father\\n parents = (mother.body, father.body)\\n # Handedness\\n if random.random() < config.heritability_of_handedness:\\n takes_after = random.choice(parents)\\n self.left_handed = Feature(value=takes_after.left_handed, inherited_from=takes_after)\\n self.right_handed = Feature(value=takes_after.right_handed, inherited_from=takes_after)\\n # Hustle\\n if random.random() < config.heritability_of_hustle:\\n takes_after = random.choice(parents)\\n inherited_hustle = takes_after.hustle\\n mutated_hustle = normal(inherited_hustle, config.hustle_mutation_sd)\\n self.hustle = Feature(value=mutated_hustle, inherited_from=takes_after)\\n else:\\n pass # TODO SET UP GENERATING FROM NOTHING\",\n \"def mutate_point(mutated_genome):\\n if phenotype == 'Poly':\\n mutate_point_poly(mutated_genome)\\n elif phenotype == 'Poly3':\\n mutate_point_poly3(mutated_genome)\\n elif phenotype == 'Trig':\\n mutate_point_trig(mutated_genome)\\n elif phenotype == 'Circ':\\n mutate_point_circ(mutated_genome)\\n elif phenotype == 'Ellip':\\n # ellipses points are the same as rectangles\\n mutate_point_rect(mutated_genome)\\n elif phenotype == 'Rect':\\n mutate_point_rect(mutated_genome)\\n elif phenotype == 'Line':\\n # poly3 is same point setup as line\\n mutate_point_poly3(mutated_genome)\\n elif phenotype == 'WLine':\\n mutate_point_wline(mutated_genome)\",\n \"def _set_joint_genome_info(self, gene_annotation_header_values, total_genes_in_genome_values):\\n # Merge any pieces of global information that's not per-dataset\\n self.gene_annotation_header = merge_values_to_unique(gene_annotation_header_values, blank_value=[], convert_for_set=tuple, \\n value_name='gene_annotation_header', context='datasets in multi-dataset')\\n self.total_genes_in_genome = merge_values_to_unique(total_genes_in_genome_values, blank_value=0, \\n value_name='total_genes_in_genome', context='datasets in multi-dataset')\",\n \"def update_gene_info(ensembl_info, word, value):\\n if \\\"gene\\\" in word:\\n if \\\"id\\\" in word:\\n ensembl_info[\\\"ensembl_gene_id\\\"] = value\\n elif \\\"start\\\" in word:\\n ensembl_info[\\\"gene_start\\\"] = int(value)\\n elif \\\"end\\\" in word:\\n ensembl_info[\\\"gene_end\\\"] = int(value)\\n return ensembl_info\",\n \"def set_occupant(self):\\n\\t\\tself.occupant = 1\",\n \"def on_sense_sonar(self, dist):\\n raise NotImplementedError()\",\n \"def gene(self, idx, value):\\r\\n self.genes[idx] = value\",\n \"def set_animal_parameters(species, params):\\n animals = {'Herbivore': Herbivore, 'Carnivore': Carnivore}\\n animals[species].set_params(params)\",\n \"def mutate_opacity(mutated_genome):\\n seed = random.randint(0,2)\\n if seed == 0:\\n new_opacity(mutated_genome)\\n elif seed == 1:\\n change_opacity(mutated_genome)\\n else: #seed == 2:\\n switch_opacities(mutated_genome)\\n #else: #seed == 3: # depricated\\n # shuffle_opacities(mutated_genome)\",\n \"def __init__(self, config: GenedescConfigParser, species: str, go_relations: List[str] = None,\\n do_relations: List[str] = None, use_cache: bool = False):\\n self.config = config\\n raw_files_source = config.get_wb_raw_file_sources()\\n cache_location = config.get_cache_dir()\\n release_version = config.get_wb_release()\\n organisms_info = config.get_wb_organisms_info()\\n project_id = organisms_info[species][\\\"project_id\\\"]\\n self.sister_sp_fullname = \\\"\\\"\\n if \\\"main_sister_species\\\" in organisms_info[species] and \\\"full_name\\\" in \\\\\\n organisms_info[organisms_info[species][\\\"main_sister_species\\\"]]:\\n self.sister_sp_fullname = organisms_info[organisms_info[species][\\\"main_sister_species\\\"]][\\\"full_name\\\"]\\n self.orth_fullnames = \\\"\\\"\\n if \\\"ortholog\\\" in organisms_info[species] and all([\\\"full_name\\\" in organisms_info[ortholog_sp] for ortholog_sp in\\n organisms_info[species][\\\"ortholog\\\"]]):\\n self.orth_fullnames = [organisms_info[ortholog_sp][\\\"full_name\\\"] for ortholog_sp in\\n organisms_info[species][\\\"ortholog\\\"]]\\n expression_cluster_anatomy_prefix = organisms_info[species][\\\"ec_anatomy_prefix\\\"] if \\\\\\n \\\"ec_anatomy_prefix\\\" in organisms_info[species] else None\\n expression_cluster_molreg_prefix = organisms_info[species][\\\"ec_molreg_prefix\\\"] if \\\\\\n \\\"ec_molreg_prefix\\\" in organisms_info[species] else None\\n expression_cluster_genereg_prefix = organisms_info[species][\\\"ec_genereg_prefix\\\"] if \\\\\\n \\\"ec_genereg_prefix\\\" in organisms_info[species] else None\\n super().__init__(go_relations=go_relations, do_relations=do_relations, use_cache=use_cache)\\n self.gene_data_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"species\\\", species,\\n project_id, \\\"annotation\\\", species + '.' + project_id +\\n '.' + release_version + \\\".geneIDs.txt.gz\\\")\\n self.gene_data_url = raw_files_source + '/' + release_version + '/species/' + species + '/' + project_id + \\\\\\n '/annotation/' + species + '.' + project_id + '.' + release_version + '.geneIDs.txt.gz'\\n self.go_ontology_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"ONTOLOGY\\\",\\n \\\"gene_ontology.\\\" + release_version + \\\".obo\\\")\\n self.go_ontology_url = raw_files_source + '/' + release_version + '/ONTOLOGY/gene_ontology.' + \\\\\\n release_version + '.obo'\\n self.go_associations_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"species\\\", species,\\n project_id, \\\"annotation\\\", species + \\\".\\\" + project_id + \\\".\\\" + release_version +\\n \\\".gene_association.wb.gz\\\")\\n self.go_associations_url = raw_files_source + '/' + release_version + '/species/' + species + '/' + project_id + \\\\\\n '/annotation/' + species + '.' + project_id + '.' + release_version + \\\".gene_association.wb.gz\\\"\\n self.do_ontology_url = raw_files_source + '/' + release_version + '/ONTOLOGY/disease_ontology.' + \\\\\\n release_version + '.obo'\\n self.do_ontology_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"ONTOLOGY\\\",\\n \\\"disease_ontology.\\\" + release_version + \\\".obo\\\")\\n self.do_associations_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"ONTOLOGY\\\",\\n \\\"disease_associations.by_orthology.\\\" + release_version +\\n \\\".tsv.txt\\\")\\n self.do_associations_url = raw_files_source + '/' + release_version + \\\\\\n '/ONTOLOGY/disease_association.by_orthology.' + release_version + '.tsv.txt'\\n self.do_associations_new_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, 'ONTOLOGY',\\n 'disease_association.' + release_version + '.daf.txt')\\n self.do_associations_new_url = raw_files_source + '/' + release_version + '/ONTOLOGY/disease_association.' + \\\\\\n release_version + '.daf.txt'\\n self.orthology_url = raw_files_source + '/' + release_version + '/species/' + species + '/' + project_id + \\\\\\n '/annotation/' + species + '.' + project_id + '.' + release_version + '.orthologs.txt.gz'\\n self.orthology_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"species\\\", species,\\n project_id, \\\"annotation\\\", species + '.' + project_id + '.' +\\n release_version + \\\".orthologs.txt.gz\\\")\\n self.orthologs = defaultdict(lambda: defaultdict(list))\\n self.protein_domain_url = raw_files_source + '/' + release_version + '/species/' + species + '/' + \\\\\\n project_id + '/annotation/' + species + '.' + project_id + '.' + release_version + \\\\\\n '.protein_domains.csv.gz'\\n self.protein_domain_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"species\\\", species,\\n project_id, \\\"annotation\\\", species + '.' + project_id +\\n '.' + release_version + \\\".protein_domains.csv.gz\\\")\\n self.protein_domains = defaultdict(list)\\n self.expression_ontology_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"ONTOLOGY\\\",\\n \\\"anatomy_ontology.\\\" + release_version + \\\".obo\\\")\\n self.expression_ontology_url = raw_files_source + '/' + release_version + '/ONTOLOGY/anatomy_ontology.' + \\\\\\n release_version + '.obo'\\n self.expression_associations_cache_path = os.path.join(cache_location, \\\"wormbase\\\", release_version, \\\"ONTOLOGY\\\",\\n \\\"anatomy_association.\\\" + release_version + \\\".wb\\\")\\n self.expression_associations_url = raw_files_source + '/' + release_version + \\\\\\n '/ONTOLOGY/anatomy_association.' + release_version + '.wb'\\n self.expression_cluster_anatomy_url = self._get_expression_cluster_url(\\n prefix=expression_cluster_anatomy_prefix, ec_type=\\\"anatomy\\\", release_version=release_version)\\n self.expression_cluster_anatomy_cache_path = self._get_expression_cluster_cache_path(\\n prefix=expression_cluster_anatomy_prefix, ec_type=\\\"anatomy\\\", release_version=release_version,\\n cache_location=cache_location)\\n self.expression_cluster_anatomy_data = defaultdict(list) if self.expression_cluster_anatomy_url else None\\n self.expression_cluster_molreg_url = self._get_expression_cluster_url(\\n prefix=expression_cluster_molreg_prefix, ec_type=\\\"molReg\\\", release_version=release_version)\\n self.expression_cluster_molreg_cache_path = self._get_expression_cluster_cache_path(\\n prefix=expression_cluster_molreg_prefix, ec_type=\\\"molReg\\\", release_version=release_version,\\n cache_location=cache_location)\\n self.expression_cluster_molreg_data = defaultdict(list) if self.expression_cluster_molreg_url else None\\n self.expression_cluster_genereg_url = self._get_expression_cluster_url(\\n prefix=expression_cluster_genereg_prefix, ec_type=\\\"geneReg\\\", release_version=release_version)\\n self.expression_cluster_genereg_cache_path = self._get_expression_cluster_cache_path(\\n prefix=expression_cluster_genereg_prefix, ec_type=\\\"geneReg\\\", release_version=release_version,\\n cache_location=cache_location)\\n self.expression_cluster_genereg_data = defaultdict(list) if self.expression_cluster_genereg_url else None\",\n \"def surgery(actuation_name,exposed_robot,transform_robot,possibility):\\n goodluck = random.randint(0,100)\\n \\n if goodluck < possibility: # Surgery will transform exposed_robot to transform_robot with base stats of transform_robot.\\n old_name = exposed_robot.name #Store the old name of exposed_robot\\n exposed_robot = transform_robot.__class__() \\n print(\\\"{0} is affected by {2}. It's name is now {1}!\\\".format(old_name,exposed_robot.name,actuation_name))\\n return exposed_robot\\n else:\\n print(\\\"{1} is not succesful on {0}!\\\".format(exposed_robot.name,actuation_name))\\n return exposed_robot\",\n \"def modified(self):\\n raise NotImplementedError\",\n \"def test_species(self):\\n spec = input.species('C2H4', os.path.join(self.directory, 'species', 'C2H4', 'ethene.py'))\\n self.assertTrue(isinstance(spec, Species))\\n self.assertEqual(len(spec.molecule), 0)\",\n \"def update_module_refs(self, generation):\\n self.species_module_ref_map = {}\\n\\n if Config.blueprint_nodes_use_representatives:\\n # For representatives species_module_ref_map becomes: representative -> chosen module\\n reps = self.representatives\\n for rep, (spc_index, module_index) in self.species_module_index_map.items():\\n if rep not in reps: # removes reps that no longer exist\\n continue\\n self.species_module_ref_map[rep] = generation.module_population.species[spc_index][module_index]\\n else:\\n for spc_index, module_index in self.species_module_index_map.items():\\n if isinstance(module_index, tuple):\\n \\\"\\\"\\\"this is an override index. this module is found in a different species\\\"\\\"\\\"\\n if not Config.allow_cross_species_mappings:\\n raise Exception('Cross species mapping disabled, but received tuple as value in map')\\n spc, mod = module_index\\n self.species_module_ref_map[spc_index] = generation.module_population.species[spc][mod]\\n else:\\n self.species_module_ref_map[spc_index] = generation.module_population.species[spc_index][\\n module_index]\",\n \"def strainNameHomogene(strain):\\n\\tstrain = strain.split(\\\",\\\")[0]\\n\\tstrain = strain.split(\\\"=\\\")[0]\\n\\tstrain = strain.split(\\\"(\\\")[0]\\n\\tstrain = strain.split(\\\"genome\\\")[0]\\n\\twords = [\\\"chromosome \\\", \\\"chromosome\\\", \\\"genomic island \\\", \\\"variant \\\", \\\"main \\\", \\\"complete \\\", \\\"genomic \\\", \\\"sequence \\\", \\\"sequence\\\", \\\"island \\\", \\\"Salmonella Genomic Island 1 \\\", \\\"genome \\\", \\\"strain \\\", \\\"plasmid \\\", \\\"str. \\\", \\\"REU80928 \\\"]\\n\\tfor word in words:\\n\\t\\tstrain = strain.replace(word, \\\"\\\")\\n\\tstrain = strain.replace(\\\":\\\", \\\"-\\\")\\n\\tstrain = strain.replace(\\\" \\\", \\\"_\\\")\\n\\tif strain[-1] == \\\"_\\\": strain.rstrip()\\n\\tif strain[-1] == \\\"_\\\": strain.rstrip()\\n\\treturn strain\",\n \"def make_synthetic_genome(human, phix, bacteria, size, dir, isfastq):\\n \\n # generate human reads\\n get_human_reads(human, size, dir, isfastq)\\n \\n # generate phix reads\\n get_phix_reads(phix, size, dir, isfastq)\\n \\n # generate bacteria reads\\n get_bacteria_reads(bacteria, size, dir, isfastq)\\n \\n # generate virus reads\\n get_virus_reads(1 - human - phix - bacteria, size, dir, isfastq)\",\n \"def _add_transform_genes(self):\\n pass\",\n \"def moi(self):\\n\\n pass\",\n \"def save(self, *args, **kwargs):\\n self.trait_flavor_name = self.set_trait_flavor_name()\\n # Call the \\\"real\\\" save method.\\n super(HarmonizedTrait, self).save(*args, **kwargs)\",\n \"def __species_annotation__(self,aggregation_so_far,annotation):\\n return Survey.__species_annotation__(self,aggregation_so_far,[annotation])\",\n \"def get_my_mutations(quality_cutoff, coverage_cutoff):\\n\\n # my_mutations = {}\\n # with open('/home/perry/Projects/loh/working/murim.exome.aa_chg.vars') as f:\\n # for line in f:\\n # my_mutations[line.strip()] = True\\n # return my_mutations\\n\\n bed_file = 'data/nimblegen/2.1M_Human_Exome_Annotation/2.1M_Human_Exome.bed'\\n bed_chr2st2end, bed_chr2posLs = bed_tools.load_bed(bed_file, \\n 'NimbleGen Tiled Regions')\\n # NimbleGen Tiled Regions\\n # Target Regions\\n\\n use_data_dir = '/home/perry/Projects/loh/data/all_non_ref_hg18/'\\n all_somatic = {}\\n all_inherited = {}\\n cancer_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanT.ann')\\n normal_qualities = mutations.get_consensus_qualities(use_data_dir + 'yusanN.ann')\\n for exome in global_settings.exome_types:\\n data_file = use_data_dir + exome\\n inherited, somatic, murim = mutations.get_mutations(data_file, normal_qualities,\\n cancer_qualities, quality_cutoff,\\n False, coverage_cutoff)\\n # only use the bed_tools NimbleGen\\n # restriction for hg18 data\\n for s in somatic['yusan']: \\n chr, pos = s.split(':')\\n if bed_tools.find_location_in_bed(chr, int(pos), \\n bed_chr2posLs,\\n bed_chr2st2end):\\n all_somatic[s] = True\\n for i in inherited['yusan']: \\n chr, pos = s.split(':')\\n if bed_tools.find_location_in_bed(chr, int(pos), \\n bed_chr2posLs,\\n bed_chr2st2end):\\n all_inherited[i] = True\\n return (set(all_somatic.keys()) & set(get_murim_covered(quality_cutoff)), set(all_inherited.keys()) & set(get_murim_covered(quality_cutoff)))\",\n \"def update_entropy(self, save=True):\\n\\n #min_consensus = self.mturk_assignment.hit.hit_type \\\\\\n #.experiment_settings.min_output_consensus\\n min_consensus = 3\\n\\n # update substance label and entropy\\n self.substance = None\\n substances = self.substances.filter(invalid=False) \\\\\\n .values_list('substance_id', flat=True)\\n if substances:\\n self.substance_entropy = compute_entropy(substances)\\n hist = Counter(substances).most_common(2)\\n substance_id, count = hist[0]\\n # must be at least the consensus, and larger than the 2nd choice\\n if count >= min_consensus and (len(hist) == 1 or hist[1][1] < count):\\n self.substance_id = substance_id\\n self.quality_method = 'M'\\n\\n # update name label and entropy\\n self.name = None\\n names = self.names.filter(invalid=False) \\\\\\n .values_list('name_id', flat=True)\\n if names.exists():\\n self.name_entropy = compute_entropy(names)\\n hist = Counter(names).most_common(2)\\n name_id, count = hist[0]\\n # must be at least the consensus, and larger than the 2nd choice\\n if count >= min_consensus and (len(hist) == 1 or hist[1][1] < count):\\n self.name_id = name_id\\n self.quality_method = 'M'\\n\\n # update rectified normal\\n self.rectified_normal = None\\n if self.planar:\\n for n in self.rectified_normals.all():\\n if n.better_than(self.rectified_normal):\\n self.rectified_normal = n\\n if self.rectified_normal and not self.rectified_normal.correct:\\n self.rectified_normal = None\\n\\n # update bsdf\\n self.bsdf_wd = None\\n for b in self.bsdfs_wd.all():\\n if b.gloss_correct and b.color_correct and b.better_than(self.bsdf_wd):\\n self.bsdf_wd = b\\n\\n if save:\\n self.save()\",\n \"def mutate_snp(genome, var):\\n nt_options = {'A':['T','G','C'], 'T':['A','G','C'], 'G':['A','T','C'], 'C':['A','T','G']}\\n n = random.randint(0,2)\\n nt = nt_options.get(genome.seq[var.start])[n]\\n genome.mut_seq[var.start] = nt\\n\\n var.ref = genome.seq[var.start]\\n var.alt = nt\",\n \"def map_to_mgi(adata, copy = False):\\n from pybiomart import Server\\n # connest to the biomart server\\n server = Server(host='http://www.ensembl.org')\\n\\n # retrieve the mouse data set we need\\n dataset = (server.marts['ENSEMBL_MART_ENSEMBL']\\n .datasets['mmusculus_gene_ensembl'])\\n\\n # recieve the mapping from ensembl to MGI\\n conv_table = dataset.query(attributes=['ensembl_gene_id', 'external_gene_name'])\\n\\n # we first drop duplicates in the first column\\n conv_table = conv_table.drop_duplicates(conv_table.columns.values[0])\\n\\n # convert the gene names from the adata object to a data frame\\n adata_table = pd.DataFrame(adata.var_names)\\n\\n # give the first column a name\\n adata_table.columns = ['Gene stable ID']\\n\\n # change the gene table so that the ensembl names are now the index\\n conv_table = conv_table.set_index('Gene stable ID')\\n\\n # project the names from the conversion table on the corr. names in the\\n # adata var names table\\n mapping = adata_table.join(conv_table, on='Gene stable ID')\\n\\n # how many could we not map\\n not_found_mgi = sum(pd.isnull(mapping).iloc[:,1])\\n\\n # how many ensg symbols did we map several times?\\n rep_ensg = len(mapping.iloc[:, 0]) - len(set(mapping.iloc[:, 0]))\\n\\n # how many mgi symbols did we map several times?\\n rep_mgi = len(mapping.iloc[:, 1]) - len(set(mapping.iloc[:, 1]))\\n\\n # print this information\\n print('Genes where no MGI annotations where found: {}\\\\nENSG repetition: {}\\\\nMGI repetition: {}'.\\\\\\n format(not_found_mgi, rep_ensg, rep_mgi))\\n\\n # fill nans in mgi column with corresponding ensembl annotations\\n mapping['Gene name'].fillna(mapping['Gene stable ID'], inplace = True)\\n\\n # add the new gene names to the adata object\\n adata.var['mgi_symbols'] = mapping['Gene name'].tolist()\",\n \"def take_control_over(self, other):\\n a = self\\n if a == other: return\\n if util.onechancein(6): #make a master of b\\n if other.master is not None:\\n if other.master != a and a.master != other: #if b already had master, make a enemy of b.master\\n a.history.append('In year %d %s tried to overtake the control over %s, but failed' % (world.year, a.name, other.name))\\n other.master.conflict_with(a)\\n else:\\n if a.master == other: #if we overtook controll\\n a.master = None\\n try:\\n other.minions.remove(a)\\n except ValueError: pass\\n try:\\n other.master.minions.remove(other)\\n except Exception : pass\\n a.minions.append(other)\\n other.master = a\\n a.history.append('In year %d %s became boss over %s' %(world.year, a.name, other.name))\",\n \"def update_module_indexes(self, generation):\\n self.species_module_index_map = {}\\n\\n if Config.blueprint_nodes_use_representatives:\\n # For representatives species_module_index_map becomes: representative -> (species index, member index)\\n for rep, module in self.species_module_ref_map.items():\\n if module is None:\\n continue\\n\\n for species_index, species in enumerate(generation.module_population.species):\\n if module in species:\\n self.species_module_index_map[rep] = \\\\\\n (species_index, generation.module_population.species[species_index].members.index(module))\\n break\\n else:\\n for spc_index, module in self.species_module_ref_map.items():\\n if module is None:\\n continue\\n\\n if spc_index < len(generation.module_population.species) and \\\\\\n module in generation.module_population.species[spc_index]:\\n\\n self.species_module_index_map[spc_index] = \\\\\\n generation.module_population.species[spc_index].members.index(module)\\n\\n elif Config.allow_cross_species_mappings:\\n for new_species_index, species in enumerate(generation.module_population.species):\\n if module in species:\\n \\\"\\\"\\\"found module in new species\\\"\\\"\\\"\\n self.species_module_index_map[spc_index] = \\\\\\n (new_species_index,\\n generation.module_population.species[new_species_index].members.index(module))\\n break\",\n \"def setSharp(self,sharp):\\n super(self.__class__, self).setSharp(self, sharp)\",\n \"def addMaster(self,masterName):\\n masterInfo = modInfos[masterName]\\n self.masterNames.append(masterName)\\n #--Map info\\n iMod = len(self.masterNames)\\n #--Map masters\\n masterMap = self.getMasterMap(masterInfo)\\n masterRefs = masterInfo.extras['FileRefs']\\n #--Get Refs types and alts\\n cellRefIds = self.cellRefIds\\n cellRefAlts = self.cellRefAlts\\n #--Progress\\n cntCells = 0\\n progress = self.progress\\n progress.setMax(len(masterRefs.cells))\\n progress(0.0,_(\\\"Building \\\")+masterName)\\n for cell,record in masterRefs.lands.items():\\n self.lands[cell] = record\\n for masterCell in masterRefs.cells:\\n cellId = masterCell.getId()\\n #--Named exterior cell?\\n if not (masterCell.flags & 1) and masterCell.cellName:\\n self.extCellNames.add(masterCell.cellName)\\n #--New cell id?\\n if cellId not in cellRefIds:\\n refIds = cellRefIds[cellId] = {}\\n refAlts = cellRefAlts[cellId] = {}\\n #--Exiting cell id?\\n else:\\n refIds = cellRefIds[cellId]\\n refAlts = cellRefAlts[cellId]\\n #--Objects\\n for object in masterCell.getObjects().list():\\n (iMMod,iObj,objId) = object[:3]\\n newIdKey = (iMod,iObj)\\n #--Modifies a master reference?\\n if iMMod:\\n if iMMod >= len(masterMap):\\n raise Tes3RefError(masterName,cellId,objId,iObj,iMMod,\\n _('NO SUCH MASTER'))\\n altKey = (masterMap[iMMod],iObj)\\n oldIdKey = altKey\\n #--Already modified?\\n if altKey in refAlts:\\n oldIdKey = refAlts[altKey]\\n if oldIdKey not in refIds:\\n raise Tes3RefError(masterName,cellId,objId,iObj,iMMod,\\n masterInfo.masterNames[iMMod-1])\\n del refIds[oldIdKey]\\n refAlts[altKey] = newIdKey\\n #print cellId, newIdKey, objId\\n #--Save it\\n refIds[newIdKey] = objId\\n #--Progress\\n cntCells += 1\\n progress(cntCells)\\n #--Debris Ids\\n for type, ids in masterRefs.debrisIds.items():\\n if type not in self.debrisIds:\\n self.debrisIds[type] = set()\\n self.debrisIds[type].update(ids)\\n #--List Masters\\n levListMasters = self.levListMasters\\n for levList in (masterRefs.debrisIds['LEVC'] + masterRefs.debrisIds['LEVI']):\\n if levList not in levListMasters:\\n levListMasters[levList] = []\\n levListMasters[levList].append(masterName)\",\n \"def testMakeNewSpecies(self):\\n\\n # adding 3 unique species:\\n cerm = CoreEdgeReactionModel()\\n\\n spcs = [Species().fromSMILES('[OH]'), \\n Species().fromSMILES('CC'),\\n Species().fromSMILES('[CH3]')]\\n\\n for spc in spcs:\\n cerm.makeNewSpecies(spc)\\n\\n self.assertEquals(len(cerm.speciesDict), len(spcs)) \\n self.assertEquals(len(cerm.indexSpeciesDict), len(spcs))\\n\\n # adding 3 unique, and 1 already existing species:\\n cerm = CoreEdgeReactionModel()\\n\\n spcs = [Species().fromSMILES('[OH]'), \\n Species().fromSMILES('CC'),\\n Species().fromSMILES('[CH3]'),\\n Species().fromSMILES('CC')]#duplicate species\\n\\n for spc in spcs:\\n cerm.makeNewSpecies(spc)\\n\\n self.assertEquals(len(cerm.speciesDict), len(spcs) - 1) \\n self.assertEquals(len(cerm.indexSpeciesDict), len(spcs) - 1)\",\n \"def remap(self,newMasters,modMap,objMaps=[]):\\n #--Masters\\n self.tes3.masters = newMasters\\n #--File mapping\\n modMapKeys = modMap.keys()\\n #--Remap iObjs\\n cells_id = self.cells_id\\n reObjNum = re.compile('[0-9A-Z]{8}$')\\n for (iMod,objMap) in objMaps:\\n cellIds = objMap.keys()\\n for cellId in cellIds:\\n cellObjMap = objMap[cellId]\\n #--Save \\n cell = cells_id.get(cellId)\\n if not cell: continue\\n #--Objects\\n objects = cell.getObjects()\\n for object in objects.list():\\n #--Different mod?\\n if object[0] != iMod:\\n pass\\n #--Cell deleted?\\n elif cellObjMap == -1:\\n objects.remove(object)\\n #--Remapped object?\\n elif object[1] in cellObjMap:\\n (newIObj,objId) = cellObjMap[object[1]]\\n objIdBase = reObjNum.sub('',objId) #--Strip '00001234' id num from object\\n #--Mismatched object id?\\n if objId != objIdBase:\\n #print 'Mismatch:',object[:3]\\n pass \\n #--Deleted object?\\n elif newIObj == -1:\\n #print 'Deleted',object[:3]\\n objects.remove(object)\\n #--Remapped object?\\n else:\\n #print 'Remapped',object[:3],'to',newIObj\\n newObject = self.remapObject(object,iMod,newIObj)\\n objects.replace(object,newObject)\\n self.updateScptRefs()\\n #--Remap iMods\\n if not modMapKeys: return\\n for cell in self.cells:\\n objects = cell.getObjects()\\n for object in objects.list():\\n #--Remap IMod\\n iMod = object[0]\\n #--No change?\\n if iMod not in modMapKeys: \\n pass\\n #--Object deleted?\\n elif modMap[iMod] == -1:\\n objects.remove(object)\\n #--Object not deleted?\\n else:\\n newObject = self.remapObject(object,modMap[iMod])\\n objects.replace(object,newObject)\\n self.updateScptRefs()\",\n \"def refine(self): # pylint: disable=R0201\\n return True\",\n \"def __init__(\\n self,\\n locus_tag: str,\\n gene_type: str,\\n location: Union[FeatureLocation, CompoundLocation],\\n name: str,\\n reference_sequence: Seq,\\n cog: str = None,\\n y_ome: str = None,\\n essential: bool = False,\\n replication_strand: str = None,\\n origin_distance: int = None,\\n terminus_distance: int = None\\n ):\\n\\n super().__init__('gene', location=location, reference_sequence=reference_sequence, name=name)\\n self.reading_frame = get_reading_frame(self.location, len(reference_sequence))\\n\\n # if the gene is a coding sequence, it should have a multiple of 3 length; sequence is set by super init\\n if gene_type == 'CDS' and len(self.location) % 3 != 0:\\n raise ValueError(locus_tag + ': sequence should have multiple of 3 length if gene is coding')\\n\\n self.locus_tag = locus_tag\\n self.gene_type = gene_type\\n self.cog = cog\\n self.y_ome = y_ome\\n self.essential = essential\\n self.replication_strand = replication_strand\\n self.origin_distance = origin_distance\\n self.terminus_distance = terminus_distance\\n \\n # only set by add_regulon_db_gene_ids\\n self.id = None\\n\\n # only set after calculate_and_add_cai is run\\n self.cai = None\\n\\n # only set after the appropriate linking functions are run\\n self.protein = None\\n self.trna = None\\n self.transcription_units = []\\n self.attenuators = []\\n self.riboswitches = []\\n self.shine_dalgarno = None\\n self.i_modulons = []\",\n \"def fromGenomeRepresentation(self,genome):\\n self.clear()\\n #print(genome)\\n tokens = genome.split(\\\"||\\\")\\n self.setAxiomFromString(tokens[0])\\n self.setIterations(int(tokens[1]))\\n for i in range(2,len(tokens)): self.addProductionFromGenomeRepresentation(tokens[i])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63167685","0.63009715","0.62039506","0.60391605","0.5989629","0.580947","0.5797044","0.5579908","0.5506126","0.5501652","0.5439127","0.54250365","0.5421335","0.5421209","0.5415419","0.5400045","0.5384445","0.53612787","0.5360659","0.5338628","0.5326598","0.5267285","0.5259004","0.52573365","0.52154595","0.51732326","0.51732326","0.51732326","0.51659495","0.5146133","0.51217264","0.5114201","0.51115304","0.5079434","0.5075999","0.5060804","0.5057662","0.505726","0.5050674","0.5047666","0.5047666","0.5038679","0.5027599","0.5017093","0.50083613","0.49937823","0.49849874","0.49709076","0.49672082","0.4959547","0.49510905","0.49510226","0.49418533","0.49410427","0.49232328","0.49139506","0.4908437","0.4893635","0.48899898","0.4880612","0.4873191","0.48728704","0.48505864","0.4850016","0.4849835","0.48454213","0.4842338","0.48363462","0.4835189","0.4834145","0.48183978","0.48123688","0.48102513","0.48040268","0.48021996","0.47928134","0.4791444","0.47899526","0.4785557","0.47828388","0.4782793","0.47819734","0.47812623","0.47749725","0.4770109","0.47660735","0.4762974","0.47590238","0.47435144","0.4741376","0.47299457","0.47294453","0.47291008","0.4723753","0.47221193","0.47218472","0.471945","0.4718755","0.47115818","0.4699803","0.46952504"],"string":"[\n \"0.63167685\",\n \"0.63009715\",\n \"0.62039506\",\n \"0.60391605\",\n \"0.5989629\",\n \"0.580947\",\n \"0.5797044\",\n \"0.5579908\",\n \"0.5506126\",\n \"0.5501652\",\n \"0.5439127\",\n \"0.54250365\",\n \"0.5421335\",\n \"0.5421209\",\n \"0.5415419\",\n \"0.5400045\",\n \"0.5384445\",\n \"0.53612787\",\n \"0.5360659\",\n \"0.5338628\",\n \"0.5326598\",\n \"0.5267285\",\n \"0.5259004\",\n \"0.52573365\",\n \"0.52154595\",\n \"0.51732326\",\n \"0.51732326\",\n \"0.51732326\",\n \"0.51659495\",\n \"0.5146133\",\n \"0.51217264\",\n \"0.5114201\",\n \"0.51115304\",\n \"0.5079434\",\n \"0.5075999\",\n \"0.5060804\",\n \"0.5057662\",\n \"0.505726\",\n \"0.5050674\",\n \"0.5047666\",\n \"0.5047666\",\n \"0.5038679\",\n \"0.5027599\",\n \"0.5017093\",\n \"0.50083613\",\n \"0.49937823\",\n \"0.49849874\",\n \"0.49709076\",\n \"0.49672082\",\n \"0.4959547\",\n \"0.49510905\",\n \"0.49510226\",\n \"0.49418533\",\n \"0.49410427\",\n \"0.49232328\",\n \"0.49139506\",\n \"0.4908437\",\n \"0.4893635\",\n \"0.48899898\",\n \"0.4880612\",\n \"0.4873191\",\n \"0.48728704\",\n \"0.48505864\",\n \"0.4850016\",\n \"0.4849835\",\n \"0.48454213\",\n \"0.4842338\",\n \"0.48363462\",\n \"0.4835189\",\n \"0.4834145\",\n \"0.48183978\",\n \"0.48123688\",\n \"0.48102513\",\n \"0.48040268\",\n \"0.48021996\",\n \"0.47928134\",\n \"0.4791444\",\n \"0.47899526\",\n \"0.4785557\",\n \"0.47828388\",\n \"0.4782793\",\n \"0.47819734\",\n \"0.47812623\",\n \"0.47749725\",\n \"0.4770109\",\n \"0.47660735\",\n \"0.4762974\",\n \"0.47590238\",\n \"0.47435144\",\n \"0.4741376\",\n \"0.47299457\",\n \"0.47294453\",\n \"0.47291008\",\n \"0.4723753\",\n \"0.47221193\",\n \"0.47218472\",\n \"0.471945\",\n \"0.4718755\",\n \"0.47115818\",\n \"0.4699803\",\n \"0.46952504\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3086,"cells":{"query":{"kind":"string","value":"return 0 if they equal, 1 if snp1 less, else 1"},"document":{"kind":"string","value":"def compare(chr1, pos1, chr2, pos2):\n\tpos1 = int(pos1)\n\tpos2 = int(pos2)\n\tif chrsort == 'version':\n\t\tchr1 = mapChrForVersion(chr1)\n\t\tchr2 = mapChrForVersion(chr2)\n\telif chrsort == 'natural':\n\t\tpass # use original chr1, chr2\n\telse:\n\t\tchr1 = chrsort.get(chr1, chr1)\n\t\tchr2 = chrsort.get(chr2, chr2)\n\treturn -1 if (chr1, pos1) < (chr2, pos2) else 1 if (chr1, pos1) > (chr2, pos2) else 0"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def judge(n1: List[int], n2: List[int]) -> int:\n\tmin_length = min(len(n1),len(n2))\n\tpass_count = 0\n\tfor i in range(min_length):\n\t\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\n\n\treturn pass_count","def compareones_c(w1,w2,tn):\n nw1 = np.int_(np.copy(w1))\n nw2 = np.int_(np.copy(w2))\n code = \"\"\"\n int s;\n s = 0;\n for(int i = 0; i < n; i++)\n {\n if((nw1[i] == 1)&(nw2[i] == 1))\n {\n s += 100;\n }\n }\n return_val = s;\n \"\"\"\n n = len(w2)\n res = inline(code, ['nw1','nw2','n'], headers = ['<math.h>'], compiler = 'gcc')\n return res / float(tn)","def score(c1, c2):\n if c1 == c2:\n return 1\n else:\n return 0","def compare(cls, s1, s2=None):\n if s2 is None:\n s = s1\n else:\n s = cls.multiply(s1, s2) # is self the class here\n result = 0\n result += cls.VERT_Z if reduce(lambda v, q: q^v, s.qubit_line('col', inbetween='z')) & 1 else 0\n result += cls.HOR_Z if reduce(lambda v, q: q^v, s.qubit_line('row', inbetween='z')) & 1 else 0\n result += cls.VERT_X if reduce(lambda v, q: q^v, s.qubit_line('col', inbetween='x')) & 2 else 0\n result += cls.HOR_X if reduce(lambda v, q: q^v, s.qubit_line('row', inbetween='x')) & 2 else 0\n return result","def _same(p1,p2,prec=0.0001):\n #return num.all(num.equal(p1,p2))\n t1 = num.fabs(p1[0]-p2[0]) < prec\n t2 = num.fabs(p1[1]-p2[1]) < prec\n if t1 and t2:\n #print \"same\", p1,p2\n return True","def checarPs(self,p1,p2):\n return abs(p1-p2) < 0.00001","def are_equal(self, sp1, sp2):\n return","def are_equal(self, sp1, sp2):\n return True","def compare_zipcodes(s1, s2):\n\n # check if the zipcode are identical (return 1 or 0)\n sim = (s1 == s2).astype(float)\n\n # check the first 2 numbers of the distinct comparisons\n sim[(sim == 0) & (s1.str[0:2] == s2.str[0:2])] = 0.5\n\n return sim","def evaluate(self) :\n if self.inStates[0].getState() == self.inStates[1].getState(): return 0\n return 1","def compare(self) -> int:","def lamport_compare(ts1, ts2):\n time1 = parse_op_id(ts1)\n time2 = parse_op_id(ts2)\n if time1.counter != time2.counter:\n return time1.counter - time2.counter\n if time1.actorId != time2.actorId:\n return 1 if time1.actorId > time2.actorId else -1\n return 0","def test_psnr_with_two_completely_different_sets(self):\n low = np.zeros((10, 500, 500, 1), dtype=np.uint8)\n high = np.ones((10, 500, 500, 1), dtype=np.uint8) * 255\n\n avg_psnr = np.array(psnr(high, low)).mean()\n self.assertEqual(avg_psnr, 0.0)","def indicator(self, a, b):\n return self.n_score(a == b)","def check(self):\n if (sum(self.state) == 0):\n return -1\n elif (self.state[-1] >= 1):\n return 1\n else:\n return 0","def fn(x):\n k = 0 \n for i, ch in enumerate(s): \n if mp.get(i, inf) < x: continue \n if k < len(p) and ch == p[k]: k += 1\n return k == len(p)","def assembly_compare(x, y) :\n if x.kinf() < y.kinf() :\n return 1\n elif x.kinf() == y.kinf() :\n return 0\n else : #x.resultType < y.resultType\n return -1","def __le__(self, rs):\n Number.comparisons += 1\n result = self.data <= rs.data\n return result","def compare_spectrum(spectrum0, spectrum1):\n title0 = spectrum0.get_title() \n title1 = spectrum1.get_title() \n if(title0 < title1): \n return -1\n elif(title0 > title1): \n return 1\n else:\n return 0","def judge(genA: typing.Iterator[int], genB: typing.Iterator[int], steps: int) -> int:\n res = 0\n for na, nb in it.islice(zip(genA, genB), steps):\n la, lb = lower16(na), lower16(nb)\n if la == lb:\n res += 1\n return res","def lps(mask):\n if not mask: return 0\n if not mask & (mask-1): return 1\n lo = int(log2(mask & ~(mask-1))) # least significant set bi\n hi = int(log2(mask)) # most significant set bit \n if s[lo] == s[hi]: return 2 + lps(mask^(1<<lo)^(1<<hi))\n return max(lps(mask^(1<<lo)), lps(mask^(1<<hi)))","def compare(predictions, truth):\n comp = predictions - truth\n return 1 - (np.count_nonzero(comp) / len(predictions))","def get_nTruePositive(atrank, was_retrieved, gt_ranks):\n TP = (np.logical_and(was_retrieved, gt_ranks <= atrank)).sum()\n return TP","def _transition_probability(self, s, a, s1):\n unreachable_states = [4, # F with prod_score == 4\n 5] # M with prod_score == 0\n\n if s1 in unreachable_states:\n return 0\n else:\n return 1 / (self.n_states - len(unreachable_states))","def prior(old_params,params):\n \n for s in range(len(params)):\n if params[s] < 0.0 or params[s] > 2:\n return 0\n return 1","def get_identical_score(bin1,bin2=None):\n if bin2==None: bin2=[]\n tmpscore=0.0\n norm=0\n for ali1 in bin1:\n tmpscore+=get_subscore(ali1,ali1)\n norm+=1\n for ali2 in bin2:\n tmpscore+=get_subscore(ali2,ali2)\n norm+=1\n return tmpscore/norm","def compare_addresses(s1_1, s1_2, s2_1, s2_2):\n\n return ((s1_1 == s2_1) | (s1_2 == s2_2) | (s1_1 == s2_2) | (s1_2 == s2_1)).astype(float)","def psnr(gt, pred):\n return compare_psnr(gt, pred, data_range=gt.max())","def psnr(gt, pred):\n return compare_psnr(gt, pred, data_range=gt.max())","def gateCompare(self,gate1,gate2):\n \n if gate1.getDist()>gate2.getDist():\n return 1\n elif gate1.getDist()==gate2.getDist():\n return 0\n else: #gate1Num<gate2Num\n return -1","def Q1_test():\n A, p1, p2 = [0,0], [2,4], [6,5]\n return (distance(A,p1) > 4.472135) and (distance(p1,p2) < 4.472136)","def cal_psnr(im1, im2):\n # assert pixel value range is 0-255 and type is uint8\n mse = ((im1.astype(np.float) - im2.astype(np.float)) ** 2).mean()\n psnr = 10 * np.log10(255 ** 2 / mse)\n return psnr","def judge(self, s1, s2):\n if len(s2) < len(s1):\n return False\n index_of_s1 = 0\n index_of_s2 = 0\n while index_of_s1 < len(s1) and index_of_s2 < len(s2):\n if s1[index_of_s1] == s2[index_of_s2]:\n index_of_s1 += 1\n index_of_s2 += 1\n else:\n index_of_s2 += 1\n return True if index_of_s1 == len(s1) else False","def initial_conditions_2(x):\n u1 = 1\n return u1 if 1 <= x <= 2 else 0","def sgn(x) -> int:\n if x > 0:\n return 1\n if x < 0:\n return -1\n return 0","def g_minority_1_dev(by_grps):\n if by_grps[0][0]==by_grps[0][1]:\n print(\"Failed g_1dev_t2 -- small groups match\")\n return False\n \n cts = 0\n ctn = 0\n cto = 0\n big_letter= \"\"\n \n for item in by_grps[1]:\n if item==\"S\":\n cts+=1\n if item==\"N\":\n ctn+=1 \n if item==\"O\":\n cto+=1\n if(cts==4 or ctn==4 or cto ==4):\n pass\n else:\n print(\"Failed g_1dev_t2 -- no large group consistency\")\n return False\n \n if(cts==4):\n big_letter = \"S\"\n if(cto==4):\n big_letter = \"O\"\n if(ctn == 4):\n big_letter = \"N\"\n \n for item in by_grps[0]:\n if(item==big_letter):\n print(\"Faield g_1dev_t2 -- a small group member and large group letter are the same\")\n return False\n print(\"Confirmed g_1dev_t2 -- small group with 1 deviancy and large group are different\")\n return True","def successes(predictions,truth):\n\ttotal = len(predictions)\n\tcorrect = 0.0\n\tfor p in predictions:\n\t\tif p == truth:\n\t\t\tcorrect += 1\n\t\telse:\n\t\t\tprint truth,\"\\t\",p\n\treturn correct","def true_positive(y_true, y_pred):\n \n # initialize\n tp = 0\n for yt, yp in zip(y_true, y_pred):\n if yt == 1 and yp == 1:\n tp += 1\n return tp","def are_equal(self, sp1, sp2):\n return sp1 == sp2","def compare(seq1, seq2):\n if seq1 == seq2:\n return 1\n len_diff = len(seq1) / len(seq2)\n if len_diff > 1:\n len_diff = 1 / len_diff\n\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\n\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\n if overall == 1 or overall == 0:\n return overall\n\n try:\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\n except ValueError:\n return 0\n\n return (len_diff + max_match + overall) / 3","def is_SNP(count):\n counts = sum(count)\n return counts and float(counts - max(count)) / counts > MAX_NOISE","def compare_snp_calls(gt_call, vcf_call):\n if vcf_call == 'NA':\n print(vcf_call)\n return 'NA'\n\n if not set('ACGT ').issuperset(gt_call):\n return 'NA'\n\n allele_freq, ref_allele, alt_allele = vcf_call.split(':')\n\n if gt_call == '{0} {1}'.format(ref_allele, ref_allele):\n gt_call = 0\n\n elif gt_call == '{0} {1}'.format(alt_allele, alt_allele):\n gt_call = 1\n\n elif ref_allele not in gt_call and alt_allele not in gt_call:\n gt_call = 0.5\n\n # 'If alleles do not match, e.g. genotyping gives C/T and SNP calling A/G!'\n else:\n print('')\n print(gt_call)\n print('{0} {1}'.format(ref_allele, ref_allele))\n print('{0} {1}'.format(alt_allele, alt_allele))\n print('')\n return 'NA'\n\n diff = gt_call - float(allele_freq)\n return diff","def kangaroo(x1, v1, x2, v2):\n # 0 3 4 2\n\n if v2 >= v1: # We know x1 is always less than x2, so a faster x2 kangaroo means they will never meet\n return \"NO\"\n else:\n d1 = x1\n d2 = x2\n t = 0\n\n while d1 < d2:\n t += 1 # good thing to track, in case it is needed in a real use case\n d1 += v1\n d2 += v2\n if d1 == d2:\n return \"YES\"\n\n return \"NO\"","def __get_score(self):\n for pair in zip(self.nu[self.nu_idx:], self.sw[self.sw_idx:]):\n if pair[0] == pair[1]:\n self.score += 1\n else:\n break","def compareAUTOR(offense1, offense2):\n \n if (offense1 == offense2):\n return 0\n elif (offense1 > offense2):\n return 1\n else:\n return -1","def Sgn(num):\n n = float(num)\n if n < 0:\n return -1\n elif n == 0:\n return 0\n else:\n return 1","def _check_RS(self,suits_frequency):\n if len(np.array(suits_frequency.loc[suits_frequency==5])) == 1:\n RS=1\n else:\n RS=0\n\n return RS","def _cmp(x, y):\n if x[1].count > y[1].count:\n return CmpRelation.GREATER\n if x[1].count < y[1].count:\n return CmpRelation.LESS\n if x[1].ptn_length < y[1].ptn_length:\n return CmpRelation.GREATER\n if x[1].ptn_length > y[1].ptn_length:\n return CmpRelation.LESS\n return CmpRelation.EQUAL","def check(s1):\n chars = [0] * 128\n for c in s1:\n chars[ord(c)]+=1\n\n counter = 0\n for i in range(len(chars)):\n if chars[i] %2 != 0:\n counter+=1\n \n return counter <= 1","def check_prize(correct_num):","def overUseRes(res1, res2):\n \n for i in range(len(res1)):\n if res1[i] > res2[i]:\n return True\n return False","def jaccard_sim(self, s1, s2):\n set1, set2 = set(s1.split()), set(s2.split())\n num = len(set1.intersection(set2))\n denom = len(set1.union(set2))\n return num / denom if denom != 0 else 0","def __le__(self, other):\n return int(self.rank) <= int(other.rank)","def haveEncountered(self,mono1,mono2,eps): \n return self.distance(mono1,mono2) < eps","def new_binomial_prefactor(s,l1,l2,PAx,PBx):\n with loops.Scope() as L:\n L.total = 0.\n L.t = 0\n for _ in L.while_range(lambda: L.t < s + 1):\n #TEMP TODO rewrite this. The cond_range causes a huge overhead.\n # Try Valeev implementation\n for _ in L.cond_range(((s - l1) <= L.t) & (L.t <= l2)):\n L.total += binomials[l1,s-L.t] * binomials[l2,L.t] * PAx[l1-s + L.t] * PBx[l2 - L.t]\n L.t += 1\n return L.total","def firstMissingPositive(self, nums):\n nums.sort()\n res = 1\n for num in nums:\n if num == res:\n res += 1\n return res","def SNR(op0, op1):\n result = len(op0)*np.abs(np.mean(op1) - np.mean(op0))**2/((np.var(op1)+np.var(op0))/2)\n \n return result","def are_equal(self, sp1, sp2):\n for s1 in sp1.keys():\n spin1 = getattr(s1, \"spin\", 0)\n oxi1 = getattr(s1, \"oxi_state\", 0)\n for s2 in sp2.keys():\n spin2 = getattr(s2, \"spin\", 0)\n oxi2 = getattr(s2, \"oxi_state\", 0)\n if (s1.symbol == s2.symbol and oxi1 == oxi2 and\n spin2 == -spin1):\n break\n else:\n return False\n return True","def compare(l1, l2):\n if link_weights[l1] < link_weights[l2]:\n return 1\n elif link_weights[l1] == link_weights[l2]:\n return 0\n else:\n return -1","def fullCmpSets(s1, s2):\n if len(s1) != len(s2):\n return 1\n for s1i, s2i in map(None, s1, s2):\n f = s1i.fullCmp(s2i)\n if f:\n return f","def arsenalResults(dat):\n arsScore = int(dat[0])\n othScore = int(dat[2])\n if arsScore > othScore:\n res = 1\n elif arsScore == othScore:\n res = 2\n else:\n res = 0\n return res","def get_hand1_wins(p1_hand, p1_rank, p1_rank_value, p2_hand, p2_rank, p2_rank_value):\n if HAND_RANKS.index(p1_rank) > HAND_RANKS.index(p2_rank):\n return 1\n elif HAND_RANKS.index(p1_rank) < HAND_RANKS.index(p2_rank):\n return 0\n\n # Ranks are equal\n if p1_rank_value > p2_rank_value:\n return 1\n elif p1_rank_value < p2_rank_value:\n return 0\n\n # Ranks and rank values are equal, go by highest card until one hand wins\n for i in range(0, 5):\n val1 = VALUES[p1_hand[i][0]]\n val2 = VALUES[p2_hand[i][0]]\n if val1 > val2:\n return 1\n elif val1 < val2:\n return 0\n\n print \"WTF\"\n return 0","def check(self):\n\n if (sum(self.game_state) == 0):\n return 1\n elif (self.game_state[-1] >=1 ):\n return -1\n else:\n return 0","def compare(self, other):\n return len(self & other) / max(len(self | other), 1)","def samesign ( a , b ) :\n return ( 0 < a and 0 < b ) or ( 0 > a and 0 > b )","def evaluate_binary_consistency(self):\n\n change_rw = 0\n change_sm = 0\n th = [0.005]\n for threshold in th:\n raw_th = [self.rw_data[t] > threshold for t in range(0, self.T)]\n smooth_th = [self.smth_data[t] > 0 for t in range(0, self.T)]\n # print(\"Zeros rw:\", get_avg_zeros_per_row(raw_th))\n # print(\"Zeros sm:\", get_avg_zeros_per_row(self.smth_data))\n change_rw = change_rw + self.change_of_network_over_time(raw_th)\n change_sm = change_sm + self.change_of_network_over_time(smooth_th)\n\n change_rw = change_rw / len(th)\n change_sm = change_sm / len(th)\n\n return change_rw, change_sm","def jaccard(sl, sr):\n\tunion = sl | sr\n\tif not union:\n\t\treturn 0.0\n\treturn len(sl & sr) / float(len(union))","def compare (v1, v2):\n v1_norm = normalize(v1)\n v2_norm = normalize(v2)\n if v1_norm < v2_norm:\n return -1\n if v1_norm > v2_norm:\n return 1\n return 0","def __le__(self, other):\n self.numerator=self.numerator*other.denominator\n other.numerator=self.denominator*other.numerator\n if(self.numerator<=other.numerator):\n return True\n else:\n return False","def is_swap(score0, score1):\n # BEGIN PROBLEM 5\n s0_is_double_s1 = score0 // 2 == score1 and score0 % 2 == 0\n s1_is_double_s0 = score1 // 2 == score0 and score1 % 2 == 0\n return s0_is_double_s1 or s1_is_double_s0\n # END PROBLEM 5","def check_equal_rsa_pub_key(sk2_, sk_):\n pub_n = sk_.public_numbers()\n pub_n2 = sk2_.public_numbers()\n\n self.assertEqual(pub_n2.e, pub_n.e)\n self.assertEqual(pub_n2.n, pub_n.n)","def read_pairwise_ld(snp1, snp2):\n\tif snp1.rsID == snp2.rsID:\n\t\treturn 1\n\tif snp1.rsID in r2_cache and snp2.rsID in r2_cache:\n\t\treturn r2_cache[snp1.rsID][snp2.rsID]\n\telse:\n\t\treturn 0","def is_over(self, state: StonehengeState) -> bool:\n total_result = state.hori_result + state.left_result + state.right_result\n total_line = len(total_result)\n p1_taken = 0\n p2_taken = 0\n # all_taken = True\n for item in total_result:\n if item == '1':\n p1_taken+=1\n elif item =='2':\n p2_taken += 1\n # else:\n # all_taken = False\n # print('p1 taken:' + str(p1_taken))\n # print('p2 taken:' + str(p2_taken))\n # print('p1_taken more than half?')\n # print(float(p1_taken) >= total_line/2)\n # print('p2_taken more than half?')\n # print(float(p2_taken) >= total_line/2)\n return float(p1_taken) >= total_line/2 or float(p2_taken) >= total_line/2","def get_eqn(p0, p1):\n m = (p0[1] - p1[1]) / (p0[0] - p1[0])\n return (m, p0[1] - m * p0[0])","def helper(s1,s2):\n # start with string of smaller len\n if len(s1) > len(s2): # swap\n temp = s1\n s1 = s2\n s2 = temp\n\n ans = 0\n\n # build two counters\n counter1 = collections.Counter(s1)\n counter2 = collections.Counter(s2)\n for item in counter1:\n ans += min(counter1[item],counter2[item])\n\n return ans","def p(x):\n if x<0 or x>1:\n return 0\n else:\n return 1","def compare(x, y):\n if x >= y:\n return 1.0\n else:\n return 0.0","def fn(i, s0, s1, c0, c1):\n if s0 > n or s1 > n: return 0 # impossible \n if i == len(balls): return int(c0 == c1)\n ans = 0 \n for x in range(balls[i]+1): \n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\n return ans","def compare_sid(x_true, x_pred):\n x_true, x_pred = x_true.astype(np.float32), x_pred.astype(np.float32)\n N = x_true.shape[2]\n err = np.zeros(N)\n for i in range(N):\n err[i] = abs(np.sum(x_pred[:, :, i] * np.log10((x_pred[:, :, i] + 1e-3) / (x_true[:, :, i] + 1e-3))) +\n np.sum(x_true[:, :, i] * np.log10((x_true[:, :, i] + 1e-3) / (x_pred[:, :, i] + 1e-3))))\n return np.mean(err / (x_true.shape[1] * x_true.shape[0]))","def lrt_2_pval(self, lrt):\n ind = (self.val < lrt)[::-1].argmax()\n pval = 1-self.cumprob[ind]\n return pval","def compareVersion(self, version1, version2):\n v1 = version1.split('.')\n v2 = version2.split('.')\n\n for x, y in zip(v1, v2):\n if int(x) > int(y):\n return 1\n elif int(x) < int(y):\n return -1\n\n # all prefixes are equal\n if len(v1) > len(v2):\n for num in v1[len(v2):]:\n if int(num) > 0:\n return 1\n elif len(v1) < len(v2):\n for num in v2[len(v1):]:\n if int(num) > 0:\n return -1\n return 0","def _psnr(img1, img2):\n mse = np.mean((img1 - img2) ** 2)\n if mse == 0:\n return 100\n PIXEL_MAX = 1\n return (20 * math.log10(PIXEL_MAX)) - (10 * math.log10(mse))","def is_ppc(C1, C2, i):\n c1, c2 = sorted(C1), sorted(C2)\n for k in range(len(c1)):\n if i <= c2[k]:\n # return False\n break\n if c1[k] != c2[k]:\n return False\n return True","def npcr(mat1, mat2):\n\tnpcr = 0\n\tw, h = mat1.shape\n\tif mat1.shape != mat2.shape:\n\t\treturn -1\n\tfor i in range(w):\n\t\tfor j in range(h):\n\t\t\tif mat1[i,j] != mat2[i,j]:\n\t\t\t\tnpcr += 1\n\tnpcr /= (w*h)\n\treturn npcr*100","def winner(strategy0, strategy1):\n score0, score1 = play(strategy0, strategy1)\n if score0 > score1:\n return 0\n else:\n return 1","def winner(strategy0, strategy1):\n score0, score1 = play(strategy0, strategy1)\n if score0 > score1:\n return 0\n else:\n return 1","def winner(strategy0, strategy1):\n score0, score1 = play(strategy0, strategy1)\n if score0 > score1:\n return 0\n else:\n return 1","def quality_data(self, s):\n known_symbols = np.mod(range(176),48)>=32\n print('quality_data',np.sum(np.real(s[known_symbols])<0))\n success = np.sum(np.real(s[known_symbols])<0) < 20\n return success,0 ## no doppler estimate for data frames","def p_value(set1, set2):\n\ts, p = stats.ttest_ind(set1, set2)\n\treturn p","def complementary_score(s1, s2) -> int:\n aligner = Align.PairwiseAligner()\n aligner.mode = 'local'\n aligner.open_gap_score = -1000 # Don't want any gaps!\n # score = the number of complementary nucleotides between s1 and s2.\n return aligner.score(str(s1), str(s2.complement()))","def evaluate(self) :\n for inp in self.inStates :\n if inp.getState() == 1 : return 1\n return 0","def sat(nums: List[int]):\n a, b, c, n = nums\n return (a ** n + b ** n == c ** n) and min(a, b, c) > 0 and n > 2","def test_integer(self):\n esnA = ESN(N_in,N_out,random_state=1)\n esnB = ESN(N_in,N_out,random_state=1)\n self._compare(esnA,esnB,should_be=\"same\")","def compare_sentences(s1,s2):\n\n total_score=0;\n num_total=0;\n for k in s1:\n num_total+=1\n if k in s2:\n if s1[k]==s2[k]:\n score = 1;\n else:\n score = 0;\n else:\n score = 0;\n total_score += score;\n \n for k in s2:\n if k not in s1:\n num_total+=1\n\n logging.info(\"Scored %f out of %d\" % (total_score, num_total));\n\n if num_total==0:\n return 1;\n return float(total_score)/float(num_total)","def minerr_cls(p1, p2):\n metric = p1 / p2\n res = np.zeros_like(p1)\n res[metric > 1] = 0\n res[metric <= 1] = 1\n return res","def computePairBetweenness(self,s0,s1=None):\r\n if s1==None:s1=s0[1];s0=s0[0]; #if given only one argument it should be a two tuple\r\n \r\n #calculate PB\r\n #Note that PB(u,v)=PB(v,u)\r\n #Every path is counted only once for s0!=s1 because :\r\n #delta(v,s0,s1)>0 => delta(v,s1,s0)=0\r\n #delta(v,s1,s0)>0 => delta(v,s0,s1)=0\r\n result = 0.0\r\n for u in range(self._n):\r\n #calculate Delta(u,{s0,s1},*)\r\n dd1 = self._deltaDot[u,s1] * self.getDelta(u,s0,s1)\r\n #paths from s0 and s1 already counted in deltaDot matrix\r\n result += dd1\r\n #when s0=s1 every path is counted twice (in both directions)\r\n #if s0==s1: self._PB[s0][s1] /= 2\r\n return result","def comparison(self, other):\n comparison = 0\n if self.races > other.races:\n comparison += 1\n elif self.races < other.races:\n comparison -= 1\n if self.wins > other.wins:\n comparison += 1\n elif self.wins < other.wins:\n comparison -= 1\n if len(self.drivers_championships_years) > len(other.drivers_championships_years):\n comparison += 1\n elif len(self.drivers_championships_years) < len(other.drivers_championships_years):\n comparison -= 1\n if len(self.constructors_championships_years) > len(other.constructors_championships_years):\n comparison += 1\n elif len(self.constructors_championships_years) < len(other.constructors_championships_years):\n comparison -= 1\n return comparison","def _canonical_order(node_chunk_a: node_chunk, node_chunk_b: node_chunk) -> int:\n na, prec_a, slotsA = node_chunk_a\n nb, prec_b, slotsB = node_chunk_b\n\n # compare based on node precedence\n if prec_a > prec_b:\n return -1\n elif prec_b > prec_a:\n return 1\n\n # compare based on slots\n else:\n # slots are equivalent\n if slotsA == slotsB:\n return 0\n\n # a is subset of b\n aWithoutB = slotsA - slotsB\n if not aWithoutB:\n return 1\n\n # b is subset of a\n bWithoutA = slotsB - slotsA\n if not bWithoutA:\n return -1\n\n # compare based on slots\n aMin = min(aWithoutB)\n bMin = min(bWithoutA)\n return -1 if aMin < bMin else 1","def atiecorrect(rankvals):\r\n sorted,posn = ashellsort(N.array(rankvals))\r\n n = len(sorted)\r\n T = 0.0\r\n i = 0\r\n while (i<n-1):\r\n if sorted[i] == sorted[i+1]:\r\n nties = 1\r\n while (i<n-1) and (sorted[i] == sorted[i+1]):\r\n nties = nties +1\r\n i = i +1\r\n T = T + nties**3 - nties\r\n i = i+1\r\n T = T / float(n**3-n)\r\n return 1.0 - T","def evaluate(self) :\n for inp in self.inStates :\n if inp.getState() == 0 : return 0\n return 1","def __ge__(self, other):\n return int(self.rank) >= int(other.rank)"],"string":"[\n \"def judge(n1: List[int], n2: List[int]) -> int:\\n\\tmin_length = min(len(n1),len(n2))\\n\\tpass_count = 0\\n\\tfor i in range(min_length):\\n\\t\\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\\n\\n\\treturn pass_count\",\n \"def compareones_c(w1,w2,tn):\\n nw1 = np.int_(np.copy(w1))\\n nw2 = np.int_(np.copy(w2))\\n code = \\\"\\\"\\\"\\n int s;\\n s = 0;\\n for(int i = 0; i < n; i++)\\n {\\n if((nw1[i] == 1)&(nw2[i] == 1))\\n {\\n s += 100;\\n }\\n }\\n return_val = s;\\n \\\"\\\"\\\"\\n n = len(w2)\\n res = inline(code, ['nw1','nw2','n'], headers = ['<math.h>'], compiler = 'gcc')\\n return res / float(tn)\",\n \"def score(c1, c2):\\n if c1 == c2:\\n return 1\\n else:\\n return 0\",\n \"def compare(cls, s1, s2=None):\\n if s2 is None:\\n s = s1\\n else:\\n s = cls.multiply(s1, s2) # is self the class here\\n result = 0\\n result += cls.VERT_Z if reduce(lambda v, q: q^v, s.qubit_line('col', inbetween='z')) & 1 else 0\\n result += cls.HOR_Z if reduce(lambda v, q: q^v, s.qubit_line('row', inbetween='z')) & 1 else 0\\n result += cls.VERT_X if reduce(lambda v, q: q^v, s.qubit_line('col', inbetween='x')) & 2 else 0\\n result += cls.HOR_X if reduce(lambda v, q: q^v, s.qubit_line('row', inbetween='x')) & 2 else 0\\n return result\",\n \"def _same(p1,p2,prec=0.0001):\\n #return num.all(num.equal(p1,p2))\\n t1 = num.fabs(p1[0]-p2[0]) < prec\\n t2 = num.fabs(p1[1]-p2[1]) < prec\\n if t1 and t2:\\n #print \\\"same\\\", p1,p2\\n return True\",\n \"def checarPs(self,p1,p2):\\n return abs(p1-p2) < 0.00001\",\n \"def are_equal(self, sp1, sp2):\\n return\",\n \"def are_equal(self, sp1, sp2):\\n return True\",\n \"def compare_zipcodes(s1, s2):\\n\\n # check if the zipcode are identical (return 1 or 0)\\n sim = (s1 == s2).astype(float)\\n\\n # check the first 2 numbers of the distinct comparisons\\n sim[(sim == 0) & (s1.str[0:2] == s2.str[0:2])] = 0.5\\n\\n return sim\",\n \"def evaluate(self) :\\n if self.inStates[0].getState() == self.inStates[1].getState(): return 0\\n return 1\",\n \"def compare(self) -> int:\",\n \"def lamport_compare(ts1, ts2):\\n time1 = parse_op_id(ts1)\\n time2 = parse_op_id(ts2)\\n if time1.counter != time2.counter:\\n return time1.counter - time2.counter\\n if time1.actorId != time2.actorId:\\n return 1 if time1.actorId > time2.actorId else -1\\n return 0\",\n \"def test_psnr_with_two_completely_different_sets(self):\\n low = np.zeros((10, 500, 500, 1), dtype=np.uint8)\\n high = np.ones((10, 500, 500, 1), dtype=np.uint8) * 255\\n\\n avg_psnr = np.array(psnr(high, low)).mean()\\n self.assertEqual(avg_psnr, 0.0)\",\n \"def indicator(self, a, b):\\n return self.n_score(a == b)\",\n \"def check(self):\\n if (sum(self.state) == 0):\\n return -1\\n elif (self.state[-1] >= 1):\\n return 1\\n else:\\n return 0\",\n \"def fn(x):\\n k = 0 \\n for i, ch in enumerate(s): \\n if mp.get(i, inf) < x: continue \\n if k < len(p) and ch == p[k]: k += 1\\n return k == len(p)\",\n \"def assembly_compare(x, y) :\\n if x.kinf() < y.kinf() :\\n return 1\\n elif x.kinf() == y.kinf() :\\n return 0\\n else : #x.resultType < y.resultType\\n return -1\",\n \"def __le__(self, rs):\\n Number.comparisons += 1\\n result = self.data <= rs.data\\n return result\",\n \"def compare_spectrum(spectrum0, spectrum1):\\n title0 = spectrum0.get_title() \\n title1 = spectrum1.get_title() \\n if(title0 < title1): \\n return -1\\n elif(title0 > title1): \\n return 1\\n else:\\n return 0\",\n \"def judge(genA: typing.Iterator[int], genB: typing.Iterator[int], steps: int) -> int:\\n res = 0\\n for na, nb in it.islice(zip(genA, genB), steps):\\n la, lb = lower16(na), lower16(nb)\\n if la == lb:\\n res += 1\\n return res\",\n \"def lps(mask):\\n if not mask: return 0\\n if not mask & (mask-1): return 1\\n lo = int(log2(mask & ~(mask-1))) # least significant set bi\\n hi = int(log2(mask)) # most significant set bit \\n if s[lo] == s[hi]: return 2 + lps(mask^(1<<lo)^(1<<hi))\\n return max(lps(mask^(1<<lo)), lps(mask^(1<<hi)))\",\n \"def compare(predictions, truth):\\n comp = predictions - truth\\n return 1 - (np.count_nonzero(comp) / len(predictions))\",\n \"def get_nTruePositive(atrank, was_retrieved, gt_ranks):\\n TP = (np.logical_and(was_retrieved, gt_ranks <= atrank)).sum()\\n return TP\",\n \"def _transition_probability(self, s, a, s1):\\n unreachable_states = [4, # F with prod_score == 4\\n 5] # M with prod_score == 0\\n\\n if s1 in unreachable_states:\\n return 0\\n else:\\n return 1 / (self.n_states - len(unreachable_states))\",\n \"def prior(old_params,params):\\n \\n for s in range(len(params)):\\n if params[s] < 0.0 or params[s] > 2:\\n return 0\\n return 1\",\n \"def get_identical_score(bin1,bin2=None):\\n if bin2==None: bin2=[]\\n tmpscore=0.0\\n norm=0\\n for ali1 in bin1:\\n tmpscore+=get_subscore(ali1,ali1)\\n norm+=1\\n for ali2 in bin2:\\n tmpscore+=get_subscore(ali2,ali2)\\n norm+=1\\n return tmpscore/norm\",\n \"def compare_addresses(s1_1, s1_2, s2_1, s2_2):\\n\\n return ((s1_1 == s2_1) | (s1_2 == s2_2) | (s1_1 == s2_2) | (s1_2 == s2_1)).astype(float)\",\n \"def psnr(gt, pred):\\n return compare_psnr(gt, pred, data_range=gt.max())\",\n \"def psnr(gt, pred):\\n return compare_psnr(gt, pred, data_range=gt.max())\",\n \"def gateCompare(self,gate1,gate2):\\n \\n if gate1.getDist()>gate2.getDist():\\n return 1\\n elif gate1.getDist()==gate2.getDist():\\n return 0\\n else: #gate1Num<gate2Num\\n return -1\",\n \"def Q1_test():\\n A, p1, p2 = [0,0], [2,4], [6,5]\\n return (distance(A,p1) > 4.472135) and (distance(p1,p2) < 4.472136)\",\n \"def cal_psnr(im1, im2):\\n # assert pixel value range is 0-255 and type is uint8\\n mse = ((im1.astype(np.float) - im2.astype(np.float)) ** 2).mean()\\n psnr = 10 * np.log10(255 ** 2 / mse)\\n return psnr\",\n \"def judge(self, s1, s2):\\n if len(s2) < len(s1):\\n return False\\n index_of_s1 = 0\\n index_of_s2 = 0\\n while index_of_s1 < len(s1) and index_of_s2 < len(s2):\\n if s1[index_of_s1] == s2[index_of_s2]:\\n index_of_s1 += 1\\n index_of_s2 += 1\\n else:\\n index_of_s2 += 1\\n return True if index_of_s1 == len(s1) else False\",\n \"def initial_conditions_2(x):\\n u1 = 1\\n return u1 if 1 <= x <= 2 else 0\",\n \"def sgn(x) -> int:\\n if x > 0:\\n return 1\\n if x < 0:\\n return -1\\n return 0\",\n \"def g_minority_1_dev(by_grps):\\n if by_grps[0][0]==by_grps[0][1]:\\n print(\\\"Failed g_1dev_t2 -- small groups match\\\")\\n return False\\n \\n cts = 0\\n ctn = 0\\n cto = 0\\n big_letter= \\\"\\\"\\n \\n for item in by_grps[1]:\\n if item==\\\"S\\\":\\n cts+=1\\n if item==\\\"N\\\":\\n ctn+=1 \\n if item==\\\"O\\\":\\n cto+=1\\n if(cts==4 or ctn==4 or cto ==4):\\n pass\\n else:\\n print(\\\"Failed g_1dev_t2 -- no large group consistency\\\")\\n return False\\n \\n if(cts==4):\\n big_letter = \\\"S\\\"\\n if(cto==4):\\n big_letter = \\\"O\\\"\\n if(ctn == 4):\\n big_letter = \\\"N\\\"\\n \\n for item in by_grps[0]:\\n if(item==big_letter):\\n print(\\\"Faield g_1dev_t2 -- a small group member and large group letter are the same\\\")\\n return False\\n print(\\\"Confirmed g_1dev_t2 -- small group with 1 deviancy and large group are different\\\")\\n return True\",\n \"def successes(predictions,truth):\\n\\ttotal = len(predictions)\\n\\tcorrect = 0.0\\n\\tfor p in predictions:\\n\\t\\tif p == truth:\\n\\t\\t\\tcorrect += 1\\n\\t\\telse:\\n\\t\\t\\tprint truth,\\\"\\\\t\\\",p\\n\\treturn correct\",\n \"def true_positive(y_true, y_pred):\\n \\n # initialize\\n tp = 0\\n for yt, yp in zip(y_true, y_pred):\\n if yt == 1 and yp == 1:\\n tp += 1\\n return tp\",\n \"def are_equal(self, sp1, sp2):\\n return sp1 == sp2\",\n \"def compare(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n len_diff = len(seq1) / len(seq2)\\n if len_diff > 1:\\n len_diff = 1 / len_diff\\n\\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\\n\\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\\n if overall == 1 or overall == 0:\\n return overall\\n\\n try:\\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\\n except ValueError:\\n return 0\\n\\n return (len_diff + max_match + overall) / 3\",\n \"def is_SNP(count):\\n counts = sum(count)\\n return counts and float(counts - max(count)) / counts > MAX_NOISE\",\n \"def compare_snp_calls(gt_call, vcf_call):\\n if vcf_call == 'NA':\\n print(vcf_call)\\n return 'NA'\\n\\n if not set('ACGT ').issuperset(gt_call):\\n return 'NA'\\n\\n allele_freq, ref_allele, alt_allele = vcf_call.split(':')\\n\\n if gt_call == '{0} {1}'.format(ref_allele, ref_allele):\\n gt_call = 0\\n\\n elif gt_call == '{0} {1}'.format(alt_allele, alt_allele):\\n gt_call = 1\\n\\n elif ref_allele not in gt_call and alt_allele not in gt_call:\\n gt_call = 0.5\\n\\n # 'If alleles do not match, e.g. genotyping gives C/T and SNP calling A/G!'\\n else:\\n print('')\\n print(gt_call)\\n print('{0} {1}'.format(ref_allele, ref_allele))\\n print('{0} {1}'.format(alt_allele, alt_allele))\\n print('')\\n return 'NA'\\n\\n diff = gt_call - float(allele_freq)\\n return diff\",\n \"def kangaroo(x1, v1, x2, v2):\\n # 0 3 4 2\\n\\n if v2 >= v1: # We know x1 is always less than x2, so a faster x2 kangaroo means they will never meet\\n return \\\"NO\\\"\\n else:\\n d1 = x1\\n d2 = x2\\n t = 0\\n\\n while d1 < d2:\\n t += 1 # good thing to track, in case it is needed in a real use case\\n d1 += v1\\n d2 += v2\\n if d1 == d2:\\n return \\\"YES\\\"\\n\\n return \\\"NO\\\"\",\n \"def __get_score(self):\\n for pair in zip(self.nu[self.nu_idx:], self.sw[self.sw_idx:]):\\n if pair[0] == pair[1]:\\n self.score += 1\\n else:\\n break\",\n \"def compareAUTOR(offense1, offense2):\\n \\n if (offense1 == offense2):\\n return 0\\n elif (offense1 > offense2):\\n return 1\\n else:\\n return -1\",\n \"def Sgn(num):\\n n = float(num)\\n if n < 0:\\n return -1\\n elif n == 0:\\n return 0\\n else:\\n return 1\",\n \"def _check_RS(self,suits_frequency):\\n if len(np.array(suits_frequency.loc[suits_frequency==5])) == 1:\\n RS=1\\n else:\\n RS=0\\n\\n return RS\",\n \"def _cmp(x, y):\\n if x[1].count > y[1].count:\\n return CmpRelation.GREATER\\n if x[1].count < y[1].count:\\n return CmpRelation.LESS\\n if x[1].ptn_length < y[1].ptn_length:\\n return CmpRelation.GREATER\\n if x[1].ptn_length > y[1].ptn_length:\\n return CmpRelation.LESS\\n return CmpRelation.EQUAL\",\n \"def check(s1):\\n chars = [0] * 128\\n for c in s1:\\n chars[ord(c)]+=1\\n\\n counter = 0\\n for i in range(len(chars)):\\n if chars[i] %2 != 0:\\n counter+=1\\n \\n return counter <= 1\",\n \"def check_prize(correct_num):\",\n \"def overUseRes(res1, res2):\\n \\n for i in range(len(res1)):\\n if res1[i] > res2[i]:\\n return True\\n return False\",\n \"def jaccard_sim(self, s1, s2):\\n set1, set2 = set(s1.split()), set(s2.split())\\n num = len(set1.intersection(set2))\\n denom = len(set1.union(set2))\\n return num / denom if denom != 0 else 0\",\n \"def __le__(self, other):\\n return int(self.rank) <= int(other.rank)\",\n \"def haveEncountered(self,mono1,mono2,eps): \\n return self.distance(mono1,mono2) < eps\",\n \"def new_binomial_prefactor(s,l1,l2,PAx,PBx):\\n with loops.Scope() as L:\\n L.total = 0.\\n L.t = 0\\n for _ in L.while_range(lambda: L.t < s + 1):\\n #TEMP TODO rewrite this. The cond_range causes a huge overhead.\\n # Try Valeev implementation\\n for _ in L.cond_range(((s - l1) <= L.t) & (L.t <= l2)):\\n L.total += binomials[l1,s-L.t] * binomials[l2,L.t] * PAx[l1-s + L.t] * PBx[l2 - L.t]\\n L.t += 1\\n return L.total\",\n \"def firstMissingPositive(self, nums):\\n nums.sort()\\n res = 1\\n for num in nums:\\n if num == res:\\n res += 1\\n return res\",\n \"def SNR(op0, op1):\\n result = len(op0)*np.abs(np.mean(op1) - np.mean(op0))**2/((np.var(op1)+np.var(op0))/2)\\n \\n return result\",\n \"def are_equal(self, sp1, sp2):\\n for s1 in sp1.keys():\\n spin1 = getattr(s1, \\\"spin\\\", 0)\\n oxi1 = getattr(s1, \\\"oxi_state\\\", 0)\\n for s2 in sp2.keys():\\n spin2 = getattr(s2, \\\"spin\\\", 0)\\n oxi2 = getattr(s2, \\\"oxi_state\\\", 0)\\n if (s1.symbol == s2.symbol and oxi1 == oxi2 and\\n spin2 == -spin1):\\n break\\n else:\\n return False\\n return True\",\n \"def compare(l1, l2):\\n if link_weights[l1] < link_weights[l2]:\\n return 1\\n elif link_weights[l1] == link_weights[l2]:\\n return 0\\n else:\\n return -1\",\n \"def fullCmpSets(s1, s2):\\n if len(s1) != len(s2):\\n return 1\\n for s1i, s2i in map(None, s1, s2):\\n f = s1i.fullCmp(s2i)\\n if f:\\n return f\",\n \"def arsenalResults(dat):\\n arsScore = int(dat[0])\\n othScore = int(dat[2])\\n if arsScore > othScore:\\n res = 1\\n elif arsScore == othScore:\\n res = 2\\n else:\\n res = 0\\n return res\",\n \"def get_hand1_wins(p1_hand, p1_rank, p1_rank_value, p2_hand, p2_rank, p2_rank_value):\\n if HAND_RANKS.index(p1_rank) > HAND_RANKS.index(p2_rank):\\n return 1\\n elif HAND_RANKS.index(p1_rank) < HAND_RANKS.index(p2_rank):\\n return 0\\n\\n # Ranks are equal\\n if p1_rank_value > p2_rank_value:\\n return 1\\n elif p1_rank_value < p2_rank_value:\\n return 0\\n\\n # Ranks and rank values are equal, go by highest card until one hand wins\\n for i in range(0, 5):\\n val1 = VALUES[p1_hand[i][0]]\\n val2 = VALUES[p2_hand[i][0]]\\n if val1 > val2:\\n return 1\\n elif val1 < val2:\\n return 0\\n\\n print \\\"WTF\\\"\\n return 0\",\n \"def check(self):\\n\\n if (sum(self.game_state) == 0):\\n return 1\\n elif (self.game_state[-1] >=1 ):\\n return -1\\n else:\\n return 0\",\n \"def compare(self, other):\\n return len(self & other) / max(len(self | other), 1)\",\n \"def samesign ( a , b ) :\\n return ( 0 < a and 0 < b ) or ( 0 > a and 0 > b )\",\n \"def evaluate_binary_consistency(self):\\n\\n change_rw = 0\\n change_sm = 0\\n th = [0.005]\\n for threshold in th:\\n raw_th = [self.rw_data[t] > threshold for t in range(0, self.T)]\\n smooth_th = [self.smth_data[t] > 0 for t in range(0, self.T)]\\n # print(\\\"Zeros rw:\\\", get_avg_zeros_per_row(raw_th))\\n # print(\\\"Zeros sm:\\\", get_avg_zeros_per_row(self.smth_data))\\n change_rw = change_rw + self.change_of_network_over_time(raw_th)\\n change_sm = change_sm + self.change_of_network_over_time(smooth_th)\\n\\n change_rw = change_rw / len(th)\\n change_sm = change_sm / len(th)\\n\\n return change_rw, change_sm\",\n \"def jaccard(sl, sr):\\n\\tunion = sl | sr\\n\\tif not union:\\n\\t\\treturn 0.0\\n\\treturn len(sl & sr) / float(len(union))\",\n \"def compare (v1, v2):\\n v1_norm = normalize(v1)\\n v2_norm = normalize(v2)\\n if v1_norm < v2_norm:\\n return -1\\n if v1_norm > v2_norm:\\n return 1\\n return 0\",\n \"def __le__(self, other):\\n self.numerator=self.numerator*other.denominator\\n other.numerator=self.denominator*other.numerator\\n if(self.numerator<=other.numerator):\\n return True\\n else:\\n return False\",\n \"def is_swap(score0, score1):\\n # BEGIN PROBLEM 5\\n s0_is_double_s1 = score0 // 2 == score1 and score0 % 2 == 0\\n s1_is_double_s0 = score1 // 2 == score0 and score1 % 2 == 0\\n return s0_is_double_s1 or s1_is_double_s0\\n # END PROBLEM 5\",\n \"def check_equal_rsa_pub_key(sk2_, sk_):\\n pub_n = sk_.public_numbers()\\n pub_n2 = sk2_.public_numbers()\\n\\n self.assertEqual(pub_n2.e, pub_n.e)\\n self.assertEqual(pub_n2.n, pub_n.n)\",\n \"def read_pairwise_ld(snp1, snp2):\\n\\tif snp1.rsID == snp2.rsID:\\n\\t\\treturn 1\\n\\tif snp1.rsID in r2_cache and snp2.rsID in r2_cache:\\n\\t\\treturn r2_cache[snp1.rsID][snp2.rsID]\\n\\telse:\\n\\t\\treturn 0\",\n \"def is_over(self, state: StonehengeState) -> bool:\\n total_result = state.hori_result + state.left_result + state.right_result\\n total_line = len(total_result)\\n p1_taken = 0\\n p2_taken = 0\\n # all_taken = True\\n for item in total_result:\\n if item == '1':\\n p1_taken+=1\\n elif item =='2':\\n p2_taken += 1\\n # else:\\n # all_taken = False\\n # print('p1 taken:' + str(p1_taken))\\n # print('p2 taken:' + str(p2_taken))\\n # print('p1_taken more than half?')\\n # print(float(p1_taken) >= total_line/2)\\n # print('p2_taken more than half?')\\n # print(float(p2_taken) >= total_line/2)\\n return float(p1_taken) >= total_line/2 or float(p2_taken) >= total_line/2\",\n \"def get_eqn(p0, p1):\\n m = (p0[1] - p1[1]) / (p0[0] - p1[0])\\n return (m, p0[1] - m * p0[0])\",\n \"def helper(s1,s2):\\n # start with string of smaller len\\n if len(s1) > len(s2): # swap\\n temp = s1\\n s1 = s2\\n s2 = temp\\n\\n ans = 0\\n\\n # build two counters\\n counter1 = collections.Counter(s1)\\n counter2 = collections.Counter(s2)\\n for item in counter1:\\n ans += min(counter1[item],counter2[item])\\n\\n return ans\",\n \"def p(x):\\n if x<0 or x>1:\\n return 0\\n else:\\n return 1\",\n \"def compare(x, y):\\n if x >= y:\\n return 1.0\\n else:\\n return 0.0\",\n \"def fn(i, s0, s1, c0, c1):\\n if s0 > n or s1 > n: return 0 # impossible \\n if i == len(balls): return int(c0 == c1)\\n ans = 0 \\n for x in range(balls[i]+1): \\n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\\n return ans\",\n \"def compare_sid(x_true, x_pred):\\n x_true, x_pred = x_true.astype(np.float32), x_pred.astype(np.float32)\\n N = x_true.shape[2]\\n err = np.zeros(N)\\n for i in range(N):\\n err[i] = abs(np.sum(x_pred[:, :, i] * np.log10((x_pred[:, :, i] + 1e-3) / (x_true[:, :, i] + 1e-3))) +\\n np.sum(x_true[:, :, i] * np.log10((x_true[:, :, i] + 1e-3) / (x_pred[:, :, i] + 1e-3))))\\n return np.mean(err / (x_true.shape[1] * x_true.shape[0]))\",\n \"def lrt_2_pval(self, lrt):\\n ind = (self.val < lrt)[::-1].argmax()\\n pval = 1-self.cumprob[ind]\\n return pval\",\n \"def compareVersion(self, version1, version2):\\n v1 = version1.split('.')\\n v2 = version2.split('.')\\n\\n for x, y in zip(v1, v2):\\n if int(x) > int(y):\\n return 1\\n elif int(x) < int(y):\\n return -1\\n\\n # all prefixes are equal\\n if len(v1) > len(v2):\\n for num in v1[len(v2):]:\\n if int(num) > 0:\\n return 1\\n elif len(v1) < len(v2):\\n for num in v2[len(v1):]:\\n if int(num) > 0:\\n return -1\\n return 0\",\n \"def _psnr(img1, img2):\\n mse = np.mean((img1 - img2) ** 2)\\n if mse == 0:\\n return 100\\n PIXEL_MAX = 1\\n return (20 * math.log10(PIXEL_MAX)) - (10 * math.log10(mse))\",\n \"def is_ppc(C1, C2, i):\\n c1, c2 = sorted(C1), sorted(C2)\\n for k in range(len(c1)):\\n if i <= c2[k]:\\n # return False\\n break\\n if c1[k] != c2[k]:\\n return False\\n return True\",\n \"def npcr(mat1, mat2):\\n\\tnpcr = 0\\n\\tw, h = mat1.shape\\n\\tif mat1.shape != mat2.shape:\\n\\t\\treturn -1\\n\\tfor i in range(w):\\n\\t\\tfor j in range(h):\\n\\t\\t\\tif mat1[i,j] != mat2[i,j]:\\n\\t\\t\\t\\tnpcr += 1\\n\\tnpcr /= (w*h)\\n\\treturn npcr*100\",\n \"def winner(strategy0, strategy1):\\n score0, score1 = play(strategy0, strategy1)\\n if score0 > score1:\\n return 0\\n else:\\n return 1\",\n \"def winner(strategy0, strategy1):\\n score0, score1 = play(strategy0, strategy1)\\n if score0 > score1:\\n return 0\\n else:\\n return 1\",\n \"def winner(strategy0, strategy1):\\n score0, score1 = play(strategy0, strategy1)\\n if score0 > score1:\\n return 0\\n else:\\n return 1\",\n \"def quality_data(self, s):\\n known_symbols = np.mod(range(176),48)>=32\\n print('quality_data',np.sum(np.real(s[known_symbols])<0))\\n success = np.sum(np.real(s[known_symbols])<0) < 20\\n return success,0 ## no doppler estimate for data frames\",\n \"def p_value(set1, set2):\\n\\ts, p = stats.ttest_ind(set1, set2)\\n\\treturn p\",\n \"def complementary_score(s1, s2) -> int:\\n aligner = Align.PairwiseAligner()\\n aligner.mode = 'local'\\n aligner.open_gap_score = -1000 # Don't want any gaps!\\n # score = the number of complementary nucleotides between s1 and s2.\\n return aligner.score(str(s1), str(s2.complement()))\",\n \"def evaluate(self) :\\n for inp in self.inStates :\\n if inp.getState() == 1 : return 1\\n return 0\",\n \"def sat(nums: List[int]):\\n a, b, c, n = nums\\n return (a ** n + b ** n == c ** n) and min(a, b, c) > 0 and n > 2\",\n \"def test_integer(self):\\n esnA = ESN(N_in,N_out,random_state=1)\\n esnB = ESN(N_in,N_out,random_state=1)\\n self._compare(esnA,esnB,should_be=\\\"same\\\")\",\n \"def compare_sentences(s1,s2):\\n\\n total_score=0;\\n num_total=0;\\n for k in s1:\\n num_total+=1\\n if k in s2:\\n if s1[k]==s2[k]:\\n score = 1;\\n else:\\n score = 0;\\n else:\\n score = 0;\\n total_score += score;\\n \\n for k in s2:\\n if k not in s1:\\n num_total+=1\\n\\n logging.info(\\\"Scored %f out of %d\\\" % (total_score, num_total));\\n\\n if num_total==0:\\n return 1;\\n return float(total_score)/float(num_total)\",\n \"def minerr_cls(p1, p2):\\n metric = p1 / p2\\n res = np.zeros_like(p1)\\n res[metric > 1] = 0\\n res[metric <= 1] = 1\\n return res\",\n \"def computePairBetweenness(self,s0,s1=None):\\r\\n if s1==None:s1=s0[1];s0=s0[0]; #if given only one argument it should be a two tuple\\r\\n \\r\\n #calculate PB\\r\\n #Note that PB(u,v)=PB(v,u)\\r\\n #Every path is counted only once for s0!=s1 because :\\r\\n #delta(v,s0,s1)>0 => delta(v,s1,s0)=0\\r\\n #delta(v,s1,s0)>0 => delta(v,s0,s1)=0\\r\\n result = 0.0\\r\\n for u in range(self._n):\\r\\n #calculate Delta(u,{s0,s1},*)\\r\\n dd1 = self._deltaDot[u,s1] * self.getDelta(u,s0,s1)\\r\\n #paths from s0 and s1 already counted in deltaDot matrix\\r\\n result += dd1\\r\\n #when s0=s1 every path is counted twice (in both directions)\\r\\n #if s0==s1: self._PB[s0][s1] /= 2\\r\\n return result\",\n \"def comparison(self, other):\\n comparison = 0\\n if self.races > other.races:\\n comparison += 1\\n elif self.races < other.races:\\n comparison -= 1\\n if self.wins > other.wins:\\n comparison += 1\\n elif self.wins < other.wins:\\n comparison -= 1\\n if len(self.drivers_championships_years) > len(other.drivers_championships_years):\\n comparison += 1\\n elif len(self.drivers_championships_years) < len(other.drivers_championships_years):\\n comparison -= 1\\n if len(self.constructors_championships_years) > len(other.constructors_championships_years):\\n comparison += 1\\n elif len(self.constructors_championships_years) < len(other.constructors_championships_years):\\n comparison -= 1\\n return comparison\",\n \"def _canonical_order(node_chunk_a: node_chunk, node_chunk_b: node_chunk) -> int:\\n na, prec_a, slotsA = node_chunk_a\\n nb, prec_b, slotsB = node_chunk_b\\n\\n # compare based on node precedence\\n if prec_a > prec_b:\\n return -1\\n elif prec_b > prec_a:\\n return 1\\n\\n # compare based on slots\\n else:\\n # slots are equivalent\\n if slotsA == slotsB:\\n return 0\\n\\n # a is subset of b\\n aWithoutB = slotsA - slotsB\\n if not aWithoutB:\\n return 1\\n\\n # b is subset of a\\n bWithoutA = slotsB - slotsA\\n if not bWithoutA:\\n return -1\\n\\n # compare based on slots\\n aMin = min(aWithoutB)\\n bMin = min(bWithoutA)\\n return -1 if aMin < bMin else 1\",\n \"def atiecorrect(rankvals):\\r\\n sorted,posn = ashellsort(N.array(rankvals))\\r\\n n = len(sorted)\\r\\n T = 0.0\\r\\n i = 0\\r\\n while (i<n-1):\\r\\n if sorted[i] == sorted[i+1]:\\r\\n nties = 1\\r\\n while (i<n-1) and (sorted[i] == sorted[i+1]):\\r\\n nties = nties +1\\r\\n i = i +1\\r\\n T = T + nties**3 - nties\\r\\n i = i+1\\r\\n T = T / float(n**3-n)\\r\\n return 1.0 - T\",\n \"def evaluate(self) :\\n for inp in self.inStates :\\n if inp.getState() == 0 : return 0\\n return 1\",\n \"def __ge__(self, other):\\n return int(self.rank) >= int(other.rank)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6195848","0.61714214","0.5978105","0.59495175","0.58783364","0.58137816","0.5750367","0.57387525","0.56986475","0.56565875","0.5649709","0.55772007","0.55763227","0.557493","0.55728525","0.5571845","0.557098","0.5570138","0.5562759","0.55625623","0.5560324","0.55452406","0.5534755","0.5527516","0.5506003","0.55004406","0.5492515","0.54799116","0.54799116","0.5478314","0.5471997","0.5465939","0.5459837","0.54578406","0.5442059","0.54408354","0.5436002","0.5418299","0.54160005","0.5403953","0.54028726","0.54022384","0.5396006","0.5394935","0.5390424","0.53886276","0.53824157","0.5337867","0.5334057","0.53279436","0.5322588","0.5320954","0.53192383","0.5316079","0.5307573","0.529541","0.5294255","0.52935714","0.5291914","0.52865744","0.5271816","0.5271694","0.5262424","0.52513856","0.5250089","0.5249864","0.52498007","0.5240176","0.5234246","0.5233502","0.5232174","0.5231767","0.52248853","0.52232474","0.5216304","0.5213496","0.52127934","0.52114123","0.52061987","0.5203657","0.520005","0.5197558","0.51965725","0.5195507","0.5190003","0.5190003","0.5190003","0.5185989","0.5178887","0.51786333","0.5175977","0.51684964","0.5167848","0.51640224","0.5155705","0.5155318","0.51550895","0.5151632","0.51505876","0.5135912","0.5130843"],"string":"[\n \"0.6195848\",\n \"0.61714214\",\n \"0.5978105\",\n \"0.59495175\",\n \"0.58783364\",\n \"0.58137816\",\n \"0.5750367\",\n \"0.57387525\",\n \"0.56986475\",\n \"0.56565875\",\n \"0.5649709\",\n \"0.55772007\",\n \"0.55763227\",\n \"0.557493\",\n \"0.55728525\",\n \"0.5571845\",\n \"0.557098\",\n \"0.5570138\",\n \"0.5562759\",\n \"0.55625623\",\n \"0.5560324\",\n \"0.55452406\",\n \"0.5534755\",\n \"0.5527516\",\n \"0.5506003\",\n \"0.55004406\",\n \"0.5492515\",\n \"0.54799116\",\n \"0.54799116\",\n \"0.5478314\",\n \"0.5471997\",\n \"0.5465939\",\n \"0.5459837\",\n \"0.54578406\",\n \"0.5442059\",\n \"0.54408354\",\n \"0.5436002\",\n \"0.5418299\",\n \"0.54160005\",\n \"0.5403953\",\n \"0.54028726\",\n \"0.54022384\",\n \"0.5396006\",\n \"0.5394935\",\n \"0.5390424\",\n \"0.53886276\",\n \"0.53824157\",\n \"0.5337867\",\n \"0.5334057\",\n \"0.53279436\",\n \"0.5322588\",\n \"0.5320954\",\n \"0.53192383\",\n \"0.5316079\",\n \"0.5307573\",\n \"0.529541\",\n \"0.5294255\",\n \"0.52935714\",\n \"0.5291914\",\n \"0.52865744\",\n \"0.5271816\",\n \"0.5271694\",\n \"0.5262424\",\n \"0.52513856\",\n \"0.5250089\",\n \"0.5249864\",\n \"0.52498007\",\n \"0.5240176\",\n \"0.5234246\",\n \"0.5233502\",\n \"0.5232174\",\n \"0.5231767\",\n \"0.52248853\",\n \"0.52232474\",\n \"0.5216304\",\n \"0.5213496\",\n \"0.52127934\",\n \"0.52114123\",\n \"0.52061987\",\n \"0.5203657\",\n \"0.520005\",\n \"0.5197558\",\n \"0.51965725\",\n \"0.5195507\",\n \"0.5190003\",\n \"0.5190003\",\n \"0.5190003\",\n \"0.5185989\",\n \"0.5178887\",\n \"0.51786333\",\n \"0.5175977\",\n \"0.51684964\",\n \"0.5167848\",\n \"0.51640224\",\n \"0.5155705\",\n \"0.5155318\",\n \"0.51550895\",\n \"0.5151632\",\n \"0.51505876\",\n \"0.5135912\",\n \"0.5130843\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":3087,"cells":{"query":{"kind":"string","value":"Method which calculus game score through pss (player standard stats)"},"document":{"kind":"string","value":"def set_game_score(self):\n bx = self.get_standard_stats()\n tcInt = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n tcConv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n ft = bx[\"tl_int\"] - bx[\"tl_conv\"]\n ptos = bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"]\n #Con \"%.2f\" % round(x, 2) además de redondear a dos decimales, nos quedamos con los ceros finales\n result = \"%.2f\" % round(float(ptos) + (float(0.4)*float(tcConv)) - (float(0.7)*float(tcInt)) - (float(0.4)*float(ft)) + (float(0.7)*float(bx[\"reb_of\"]))\n + (float(0.3)*float(bx[\"reb_def\"])) + float(bx[\"steals\"]) + (float(0.7)*float(bx[\"assists\"])) + (float(0.7)*float(bx[\"block_shots\"]))\n - (float(0.4)*float(bx[\"fouls_cm\"])) - float(bx[\"turnovers\"]), 2)\n self.game_score = \"%.2f\" % round(Decimal(result)/bx[\"games\"], 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def scoreEvaluationFunction(gameState):\n return gameState.getScore()","def scoreEvaluationFunction(currentGameState):\r\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()","def scoreGame(self):\n # create valueLs[card1,card2,...], pass it to sumHandReturnPoints(valueLs) or twoCardReturnPoints(valueLs)\n scoreLs = []\n ### Score of row\n for rowKey in self.table:\n valueLs = self.table[rowKey]\n points = self.sumHandReturnPoints(valueLs)\n scoreLs.append(points)\n\n ### Score of 4-card column\n for offset in range(0,3): # 0,1,2\n tmpLs = []\n for rowKey in self.table:\n valueLs = self.table[rowKey]\n if len(valueLs) == 5:\n iterStart = 1\n else:\n iterStart = 0\n card = valueLs[iterStart+offset]\n tmpLs.append(card)\n points = self.sumHandReturnPoints(tmpLs)\n scoreLs.append(points) \n\n ### Score of 2-card column\n #(1) 1st column\n valueLs1 = self.table['row1']\n valueLs2 = self.table['row2']\n tmpLs = []\n tmpLs.append(valueLs1[0].get_rank())\n tmpLs.append(valueLs2[0].get_rank())\n points = self.twoCardReturnPoints(tmpLs)\n scoreLs.append(points)\n #(2) 5th column\n valueLs3 = self.table['row1']\n valueLs4 = self.table['row2']\n tmpLs = []\n tmpLs.append(valueLs3[-1].get_rank())\n tmpLs.append(valueLs4[-1].get_rank())\n points = self.twoCardReturnPoints(tmpLs)\n scoreLs.append(points) \n\n ### Add up scoreLs\n sumPoints = 0\n for points in scoreLs:\n sumPoints += points\n return sumPoints","def custom_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player) / 8\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n\n # Calculate centerness_score\n completeness = completeness_of_game(game)\n centerness_score = 0\n if completeness < 0.5:\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n own_centerness = centerness(game, player) / centerness_max\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def scoreEvaluationFunction(currentGameState):\n\treturn currentGameState.getScore()","def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )","def score(self):","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def disp_score():","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n \"*** YOUR CODE HERE ***\"\n return successorGameState.getScore()","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n \"*** YOUR CODE HERE ***\"\n return successorGameState.getScore()","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n \"*** YOUR CODE HERE ***\"\n return successorGameState.getScore()","def score(game):\r\n result = 0\r\n roll = 0\r\n game = game + [0]*(21 - len(game))\r\n\r\n for frame in range(0, 10):\r\n if is_strike(game, roll):\r\n result += _score_strike(game, roll)\r\n roll += 1\r\n elif is_spare(game, roll):\r\n result += _score_spare(game, roll)\r\n roll += 2\r\n else:\r\n result += _score_frame(game, roll)\r\n roll += 2\r\n\r\n return result","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [\n ghostState.scaredTimer for ghostState in newGhostStates]\n\n \"*** YOUR CODE HERE ***\"\n return successorGameState.getScore()","def custom_score(game, player):\n \"\"\" custom_score heuristic function idea is to implement aggressive heuristic function \n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) # Calculate length of myPlayer moves\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player))) # Calculate length of opposite player moves same as custom score 2\n return float(length_my_player_moves - 1.5*length_opp_payer_moves)","def custom_score(game, player):\n # return penalize_corners_heuristic(game, player)\n # return favor_run_away_heuristic(game, player)\n return look_ahead_heuristic(game, player)","def custom_score(game, player):\n # TODO: finish this function!\n if game.is_winner(player): # check to see if player is in state winner\n #print(\"You win!\")\n return math.inf # abstraction of score, +inf equates to a win\n elif game.is_loser(player):\n #print(\"You lose!\")\n return -math.inf # abstraction of score, -inf equates to a loss\n\n # Opponent\n opponent = game.get_opponent(player)\n\n # Remaining spaces left on the board\n rem_spaces = len(game.get_blank_spaces())\n\n # number of agent's available moves\n no_moves = len(game.get_legal_moves(player))\n\n # number of opponent's available moves\n opp_moves = len(game.get_legal_moves(opponent))\n\n # evaluation of board \"goodness\"\n # using moves available to both players\n # Idea is player chooses moves with scores that maximise whilst minimizing\n # evaluate board states and positions as scores\n board_score = no_moves - opp_moves\n score = board_score/rem_spaces\n\n return float(score)","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n #newGhostStates = successorGameState.getGhostStates()\n #newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n \"*** YOUR CODE HERE ***\"\n score = 0.0\n base = 100.0\n\n #if get fodd then add score\n score += currentGameState.hasFood(newPos[0], newPos[1]) * base\n for food in newFood.asList():\n score -= base * (1 - math.exp(-1.0 * util.manhattanDistance(newPos, food)))\n \n #if too close to ghost then minus points\n GhostPos = successorGameState.getGhostState(1).getPosition()\n GhostScareTime = successorGameState.getGhostState(1).scaredTimer\n if util.manhattanDistance(newPos, GhostPos) < 2 and GhostScareTime ==0:\n score -= 1e100\n\n #Stop is not good for win so minus points\n if action == Directions.STOP:\n score -= base\n\n return score\n #return successorGameState.getScore()","def custom_score(game, player):\n if game.is_loser(player):\n return -math.inf\n\n if game.is_winner(player):\n return math.inf\n\n opp_moves = game.get_legal_moves(game.get_opponent(player))\n own_moves = game.get_legal_moves(player)\n\n return len(own_moves) / max(len(opp_moves), 1e-6)","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n oldFood = currentGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n\n return successorGameState.getScore()","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n #Between 1-8\n return own_moves / opp_moves","def score(self):\n score_message = {\n 'Onewins': \"\\nThe Winner is Player 1!\",\n 'Twowins': \"\\nThe Winner is Player 2!\",\n 'Tie': \"\\nTie! Looks like everyone's a winner!\",\n 'Nowinner': \"\\nYikes, neither of you win!\"\n }\n if self.pone_score > self.ptwo_score:\n print(score_message['Onewins'])\n elif self.pone_score < self.ptwo_score:\n print(score_message['Twowins'])\n elif self.pone_score == 0 and self.ptwo_score == 0:\n print(score_message['Nowinner'])\n else:\n print(score_message['Tie'])","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = own_moves / opp_moves\n\n completeness = completeness_of_game(game)\n centerness_score = 0\n\n if completeness < 0.5:\n own_centerness = centerness(game, player)\n opp_centerness = centerness(game, game.get_opponent(player))\n centerness_ratio = own_centerness / opp_centerness + 0.1\n\n center_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def custom_score_2(game, player):\n # TODO: finish this function!\n if game.is_loser(player):\n #print(\"You lose!\")\n return -math.inf\n if game.is_winner(player):\n #print(\"You win\")\n return math.inf\n\n # center\n width = game.width / 2\n height = game.height / 2\n\n # Opponent\n opponent = game.get_opponent(player)\n opp_y_coord, opp_x_coord = game.get_player_location(opponent)\n opp_x_eval = (width - float(opp_x_coord)) ** 2\n opp_y_eval = (height - float(opp_y_coord)) ** 2\n opp_center_eval = float(opp_x_eval + opp_y_eval)\n\n # Remaining spaces left on the board\n rem_spaces = len(game.get_blank_spaces())\n\n # number of agent's available moves\n no_moves = len(game.get_legal_moves(player))\n\n # number of opponent's available moves\n opp_moves = len(game.get_legal_moves(opponent))\n\n # evaluation of board \"goodness\"\n # using moves available to both players\n # Idea is player chooses moves with scores that maximise whilst minimizing\n # evaluate board states and positions as scores\n opp_score = opp_moves * 2 - opp_center_eval\n score = no_moves - opp_score/rem_spaces\n return float(score)","def score(entry):\n score = time_seconds(entry['Swim'])\n score += time_seconds(entry['Run'])\n score -= (int(entry['Push-ups']) * 2)\n score -= int(entry['Sit-ups'])\n score -= int(entry['Pull-ups']) * 6\n return score","def compute_score(window, computer_piece):\n score = 0\n if window.count(computer_piece) == 4:\n score += 100\n elif window.count(computer_piece) == 3 and window.count(0) == 1:\n score += 5\n elif window.count(computer_piece) == 2 and window.count(0) == 2:\n score += 2\n if window.count(PLAYER_PIECE) == 2 and window.count(0) == 2:\n score -= 1\n if window.count(PLAYER_PIECE) == 3 and window.count(0) == 1:\n score -= 100\n return score","def GetResult(self, playerjm):\n return self.score / len(self.scores)","def score_game(self):\r\n players = self.player_control.get_players()\r\n ###game_control = self.game_control\r\n ###if game_control is not None:\r\n ### game_control.set_vals() # Update any changed game control settings\r\n if len(players) == 0:\r\n return # No players\r\n n_top_score = 0\r\n top_score = players[0].get_score()\r\n for player in players:\r\n if player.get_score() > top_score:\r\n top_score = player.get_score()\r\n for player in players:\r\n player_score = player.get_score()\r\n if player_score == top_score:\r\n n_top_score += 1\r\n \r\n for player in players:\r\n player_score = player.get_score()\r\n player_played = player.get_played()\r\n player_ties = player.get_ties()\r\n player_wins = player.get_wins()\r\n new_played = player_played+1\r\n player.set_played(new_played)\r\n player.set_prop(\"played\")\r\n if player_score == top_score:\r\n if n_top_score > 1:\r\n new_ties = player_ties + 1\r\n player.set_ties(new_ties)\r\n player.set_prop(\"ties\")\r\n else:\r\n new_wins = player_wins + 1\r\n player.set_wins(new_wins)\r\n player.set_prop(\"wins\")\r\n self.update_score_window()","def pss(self):\n return (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / \\\n ((self.table[0, 0] + self.table[1, 0]) * (self.table[0, 1] + self.table[1, 1]))","def custom_score_7(game, player):\n \"\"\"custom_score_7 heuristic function also aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n oldFood = currentGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n return successorGameState.getScore()","def score(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= SQUARE_WEIGHTS[i]\r\n else:\r\n numOpp+=SQUARE_WEIGHTS[i]\r\n return numPlayer-numOpp","def custom_score_2(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # shortcut to definite state:\n # 1. my agent win -> return very high score\n if opp_moves == 0:\n return float(\"inf\")\n # 2. opponenent's agent win -> return very low score\n elif own_moves == 0:\n return float(\"-inf\")\n\n # score: avaliable moves ratio\n return float(own_moves/opp_moves)","def custom_score(game, player):\n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n if game.move_count < 15:\n return center_modified_score(game, player)\n\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the base information to calculate player & opponent\n # feature values\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n if len(player_legal_moves) != len(opponent_legal_moves):\n return float(len(player_legal_moves) - len(opponent_legal_moves))\n \n # Get_center_coordinates and opponent. Then set the list of participants\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n participants = [player, opponent]\n \n # Then, for each participant obtain his/her feature values \n for participant in participants:\n if participant == player:\n p_legal_moves = player_legal_moves\n player_either = player\n participant_coordinates = p_y, p_x = \\\n game.get_player_location(participant)\n player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, \\\n player_path_count, player_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either,participant_coordinates, p_legal_moves)\n else:\n p_legal_moves = opponent_legal_moves\n player_either = opponent\n participant_coordinates = p_y, p_x \\\n = game.get_player_location(participant)\n opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, opponent_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either, participant_coordinates, p_legal_moves)\n \n # Place each participant's feature values in a tuple/vector surrogate \n pro_player_vector = \\\n (player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, player_path_count, \\\n opponent_min_center_diff)\n pro_opponent_vector = \\\n (opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, player_min_center_diff)\n \n # Provide a weighting vector for the features \n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\n \n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\n \n return float(weighted_difference_dot_product)","def custom_score_6(game, player):\n \"\"\"custom_score_6 heuristic function aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)","def utility(self, state, player):\n if state.isWin() or state.isLose():\n return state.getScore()\n\n # In case of cycle.\n if player == PACMAN:\n return INFINITY\n else:\n return -INFINITY","def calculate_score(player_cards):\n score = sum(player_cards)\n return score","def scoreEvaluationFunction(currentGameState, index):\n if currentGameState.isLose():\n return -float(\"inf\")\n \n if currentGameState.isWin():\n return float(\"inf\")\n\n # ghost function\n def ghostScore(gameState):\n if len(gameState.getGhostStates()) == 0:\n return 0\n score = 0\n newGhostPos = gameState.getGhostPositions()\n newGhostStates = gameState.getGhostStates()\n for pacman in gameState.getPacmanPositions():\n for i in range(len(newGhostPos)):\n if newGhostStates[i].scaredTimer > 0:\n score += ((max(4 - euclidDistance(pacman, newGhostPos[i]), 0)) ** 2)\n else:\n score -= ((max(4 - euclidDistance(pacman, newGhostPos[i]), 0)) ** 2)\n if manhattanDistance(pacman, newGhostPos[i]) < 2:\n return -float(\"inf\")\n \n return score\n \n # food function\n def foodScore(gameState):\n score = 0\n for pacman in gameState.getPacmanPositions():\n pacScore = []\n for foodCoord in gameState.getFood().asList():\n pacScore.append(euclidDistance(foodCoord, pacman))\n score = min(pacScore)\n \n score = score * -2\n score -= len(gameState.getFood().asList()) * 15\n return score\n\n\n totalScore = currentGameState.getScore()[0]\n totalScore += ghostScore(currentGameState) \n totalScore += foodScore(currentGameState)\n return totalScore","def calculate_scores(players):\n scores = {}\n for player in players.tuple_:\n scores[player.id_] = player.score()\n return scores","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n oldFood = currentGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n\n \"*** YOUR CODE HERE ***\"\n\n score = 10000\n if successorGameState.isWin():\n return 100000000\n for ghost in newGhostStates:\n ghostPos = ghost.getPosition()\n if util.manhattanDistance(ghostPos, newPos) < 2:\n score -= 10000\n else:\n score += util.manhattanDistance(ghostPos, newPos) * 1\n \n nearFood = 1000\n farFood = 1000\n for foodPos in oldFood.asList():\n dist = util.manhattanDistance(foodPos, newPos)\n if (dist < nearFood):\n nearFood = dist\n if (dist > farFood):\n farFood = dist\n if (currentGameState.getNumFood() < successorGameState.getNumFood()):\n score += 5\n\n if action == Directions.WEST:\n score -= 1\n if action == Directions.STOP:\n score -= 2\n \n for scareTime in newScaredTimes:\n score += scareTime * 1\n\n score -= 2 * farFood\n score -= 5 * nearFood\n capsuleplaces = currentGameState.getCapsules()\n if successorGameState.getPacmanPosition() in capsuleplaces:\n score += 5\n return max(score, 0)\n \n #their original return\n #return successorGameState.getScore()","def __get_score(self):\n for pair in zip(self.nu[self.nu_idx:], self.sw[self.sw_idx:]):\n if pair[0] == pair[1]:\n self.score += 1\n else:\n break","def custom_score(game, player):\n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the improved score\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n improved = len(player_legal_moves) - len(opponent_legal_moves)\n if improved != 0:\n return float(improved)\n \n # Second get differences from center\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n player_coordinates = game.get_player_location(player)\n opponent_coordinates = game.get_player_location(opponent)\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\n center_dist_diff = player_center_dist - opponent_center_dist\n \n # Third obtain next_moves\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \n improved_next = len(player_next_moves) - len(opponent_next_moves)\n \n # Put player and opponent feature differences in a tuple/vector surrogoate\n feature_diff_vector = (improved, center_dist_diff, improved_next)\n \n # Provide a weighting vector for the features of each player-participant\n weight_vector = (1.5,0.1,1.0)\n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(feature_diff_vector, weight_vector))\n \n return float(weighted_difference_dot_product)","def get_game_score(self):\n if self.game_is_tied():\n return 0\n elif self.is_game_won():\n my_available_steps = self.steps_available(self.loc)\n opp_available_steps = self.steps_available(self.opponent_loc)\n my_score = self.my_score - self.penalty_score if my_available_steps == 0 else self.my_score\n opp_score = self.opponent_score - self.penalty_score if opp_available_steps == 0 else self.opponent_score\n return (my_score - opp_score) / (abs(my_score) + abs(opp_score))\n else:\n if abs(self.my_score) + abs(self.opponent_score) == 0:\n return 0\n return (self.my_score - self.opponent_score) / (abs(self.my_score) + abs(self.opponent_score))","def update_score():\n pass","def game_score(self):\n score = self.score.quantize(Decimal('0.001'))\n return score if score > 0 else 0","def getScore(self, gameState):\n\n if (self.red):\n return gameState.getScore()\n else:\n return gameState.getScore() * -1","def stats(self):\n conversion, view = AB_test.unpack(self)\n prob_ctrl = self.control[0]/self.control[1]\n SE_ctrl = math.sqrt(prob_ctrl * (1 - prob_ctrl) / self.control[1])\n prob = np.zeros(len(conversion))\n SE = np.zeros(len(conversion))\n ZScore = np.zeros(len(conversion))\n pvalue = np.zeros(len(conversion))\n for i in range(len(conversion)):\n # probability is the conversion / view, \n prob[i] = conversion[i]/view[i]\n # SE is \\sqrt{ {p (1-p) \\over view} } in LaTeX\n SE[i] = math.sqrt(prob[i] * (1-prob[i]) / view[i])\n # Zscore is {p_{test} - p_{control} \\over SE_{test} ^ 2 + SE_{control} ^ 2}\n ZScore[i] = (prob[i] - prob_ctrl)/math.sqrt(SE[i] ** 2 + SE_ctrl **2)\n # pvalue is given as the cdf of the normal distribution funcion\n pvalue[i] = stats.norm.cdf(ZScore[i])\n self.prob = prob\n self.se = SE\n self.zscore = ZScore\n self.pvalue = pvalue\n return","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def custom_score_3(game, player):\n # TODO: finish this function!\n if game.is_winner(player): # check to see if player is in state winner\n #print(\"You win!\")\n return math.inf # abstraction of score, +inf equates to a win\n elif game.is_loser(player):\n #print(\"You lose!\")\n return -math.inf # abstraction of score, -inf equates to a loss\n\n # center\n width = game.width / 2\n height = game.height / 2\n\n # Opponent\n opponent = game.get_opponent(player)\n y_coord, x_coord = game.get_player_location(player)\n x_eval = (width - float(x_coord)) ** 2\n y_eval = (height - float(y_coord)) ** 2\n center_eval = float(x_eval + y_eval)\n\n # Remaining spaces left on the board\n rem_spaces = len(game.get_blank_spaces())\n\n # number of agent's available moves\n no_moves = len(game.get_legal_moves(player))\n\n # number of opponent's available moves\n opp_moves = len(game.get_legal_moves(opponent))\n\n # evaluation of board \"goodness\"\n # using moves available to both players\n # Idea is player chooses moves with scores that maximise whilst minimizing\n # evaluate board states and positions as scores\n opp_score = opp_moves - center_eval\n score = no_moves - opp_score\n return float(score)","def getScore(data):\n return score","def vanilaScore(self,attended,state,W):","def custom_score(game, player):\n\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n return __heuristic3__(game, player)","def evaluate(state):\r\n if wins(state, COMP):\r\n score = +1\r\n elif wins(state, HUMAN):\r\n score = -1\r\n else:\r\n score = 0\r\n\r\n return score","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n \n \"*** YOUR CODE HERE ***\"\n\n final_score=0.0\n #for ghosts\n Ghost_dist= []\n for ghost in newGhostStates:\n Ghost_Position = ghost.getPosition() \n d=manhattanDistance(Ghost_Position, newPos)\n Ghost_dist.append(d)\n \n for i in Ghost_dist:\n factor=1\n if(i<=1):\n if(ghost.scaredTimer==0): \n final_score=final_score-200\n else:\n final_score=final_score + 1500\n factor=-1\n\n #for capsule\n capsule_state= currentGameState.getCapsules()\n capsule_dist= []\n for capsule in capsule_state:\n b=manhattanDistance(capsule,newPos)\n capsule_dist.append(b)\n\n for j in capsule_dist:\n if(b==0):\n final_score=final_score + 100\n else:\n final_score=final_score + (10.0/b)\n\n #for food\n Food= currentGameState.getFood() \n food_list = Food.asList()\n food_pos = []\n for k in food_list:\n a=manhattanDistance(k,newPos)\n food_pos.append(a)\n for i in food_pos:\n if(i==0):\n final_score=final_score + 100\n else:\n final_score=final_score + (1.0/(i**2))\n return final_score","def _calculate_score(self):\n mul = self._check_board()\n if mul > 0:\n inc = 100 * mul + ((mul - 1) * 25)\n self.score += inc","def custom_score_3(game, player):\n \n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n player_legal_move_count, opponent_legal_move_count = \\\n len(player_legal_moves), len(opponent_legal_moves)\n move_count_difference = player_legal_move_count - opponent_legal_move_count\n # Find coordinates of center box\n h, w = get_center_coordinates(game)\n # Retrieve player's coordinates\n y, x = game.get_player_location(player)\n # Obtain coordinate further, closest to origin\n furthest_coord, closest_coord = max(h - y, w -x), min(h - y, w - x)\n # Return weighted, vector-valued length from origin / sum of weights\n weighted_distance_from_center = \\\n math.sqrt((closest_coord**2 + 2*(furthest_coord**2)))/3\n feature_vector = (move_count_difference, weighted_distance_from_center)\n \n weight_vector = (1.0,0.1)\n \n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(weight_vector, feature_vector)) \n \n return float(weighted_difference_dot_product)","def utility(state):\n return state.getScore()","def get_score(self, game_state):\n if self.red:\n return game_state.get_score()\n else:\n return game_state.get_score() * -1","def calculate_player_position_score(marbles: list):\n prime = Evaluator.prime_positions\n good = Evaluator.good_positions\n position_score = 0\n for marble in marbles:\n if marble in prime:\n position_score += 10\n elif marble in good:\n position_score += 5\n else:\n position_score -= 1\n return position_score","def custom_score_general(game, player, constants=[]):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n v = []\n\n if constants[0] != 0 or constants[2] != 0:\n own_moves = number_moves(game, player) / 8\n\n if own_moves == 0:\n return float(\"-inf\")\n\n v.append(own_moves)\n\n if constants[1] != 0 or constants[2] != 0:\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n\n if opp_moves == 0:\n return float(\"inf\")\n\n v.append(opp_moves)\n\n if constants[2] != 0:\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n v.append(move_ratio)\n\n if constants[3] != 0 or constants[5] != 0:\n own_openness = nearby_openness(game, player) / 80\n v.append(own_openness)\n\n if constants[4] != 0 or constants[5] != 0:\n opp_openness = nearby_openness(game, game.get_opponent(player)) / 80\n v.append(opp_openness)\n\n if constants[5] != 0:\n openness_ratio = (own_openness * 80) / (opp_openness + 0.0001 * 80) /80\n v.append(openness_ratio)\n\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n if constants[6] != 0 or constants[8] != 0:\n own_centerness = centerness(game, player) / centerness_max\n v.append(own_centerness)\n\n if constants[7] != 0 or constants[8] != 0:\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n v.append(opp_centerness)\n\n if constants[8] != 0:\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n return sum([x * y for x, y in zip(constants, v)])"],"string":"[\n \"def scoreEvaluationFunction(gameState):\\n return gameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\r\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreEvaluationFunction(currentGameState):\\n return currentGameState.getScore()\",\n \"def scoreGame(self):\\n # create valueLs[card1,card2,...], pass it to sumHandReturnPoints(valueLs) or twoCardReturnPoints(valueLs)\\n scoreLs = []\\n ### Score of row\\n for rowKey in self.table:\\n valueLs = self.table[rowKey]\\n points = self.sumHandReturnPoints(valueLs)\\n scoreLs.append(points)\\n\\n ### Score of 4-card column\\n for offset in range(0,3): # 0,1,2\\n tmpLs = []\\n for rowKey in self.table:\\n valueLs = self.table[rowKey]\\n if len(valueLs) == 5:\\n iterStart = 1\\n else:\\n iterStart = 0\\n card = valueLs[iterStart+offset]\\n tmpLs.append(card)\\n points = self.sumHandReturnPoints(tmpLs)\\n scoreLs.append(points) \\n\\n ### Score of 2-card column\\n #(1) 1st column\\n valueLs1 = self.table['row1']\\n valueLs2 = self.table['row2']\\n tmpLs = []\\n tmpLs.append(valueLs1[0].get_rank())\\n tmpLs.append(valueLs2[0].get_rank())\\n points = self.twoCardReturnPoints(tmpLs)\\n scoreLs.append(points)\\n #(2) 5th column\\n valueLs3 = self.table['row1']\\n valueLs4 = self.table['row2']\\n tmpLs = []\\n tmpLs.append(valueLs3[-1].get_rank())\\n tmpLs.append(valueLs4[-1].get_rank())\\n points = self.twoCardReturnPoints(tmpLs)\\n scoreLs.append(points) \\n\\n ### Add up scoreLs\\n sumPoints = 0\\n for points in scoreLs:\\n sumPoints += points\\n return sumPoints\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player) / 8\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n\\n # Calculate centerness_score\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n if completeness < 0.5:\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n own_centerness = centerness(game, player) / centerness_max\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def scoreEvaluationFunction(currentGameState):\\n\\treturn currentGameState.getScore()\",\n \"def score( self ):\\r\\n result = 0.0\\r\\n for rr in self.ee.getRsrcs( ):\\r\\n value = self.scoreRsrc( rr )\\r\\n result += value\\r\\n print( \\\"INFO: Value for the schedule is %s \\\" % ( rr, result ) )\\r\\n return( result )\",\n \"def score(self):\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def disp_score():\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return successorGameState.getScore()\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return successorGameState.getScore()\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return successorGameState.getScore()\",\n \"def score(game):\\r\\n result = 0\\r\\n roll = 0\\r\\n game = game + [0]*(21 - len(game))\\r\\n\\r\\n for frame in range(0, 10):\\r\\n if is_strike(game, roll):\\r\\n result += _score_strike(game, roll)\\r\\n roll += 1\\r\\n elif is_spare(game, roll):\\r\\n result += _score_spare(game, roll)\\r\\n roll += 2\\r\\n else:\\r\\n result += _score_frame(game, roll)\\r\\n roll += 2\\r\\n\\r\\n return result\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [\\n ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return successorGameState.getScore()\",\n \"def custom_score(game, player):\\n \\\"\\\"\\\" custom_score heuristic function idea is to implement aggressive heuristic function \\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) # Calculate length of myPlayer moves\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player))) # Calculate length of opposite player moves same as custom score 2\\n return float(length_my_player_moves - 1.5*length_opp_payer_moves)\",\n \"def custom_score(game, player):\\n # return penalize_corners_heuristic(game, player)\\n # return favor_run_away_heuristic(game, player)\\n return look_ahead_heuristic(game, player)\",\n \"def custom_score(game, player):\\n # TODO: finish this function!\\n if game.is_winner(player): # check to see if player is in state winner\\n #print(\\\"You win!\\\")\\n return math.inf # abstraction of score, +inf equates to a win\\n elif game.is_loser(player):\\n #print(\\\"You lose!\\\")\\n return -math.inf # abstraction of score, -inf equates to a loss\\n\\n # Opponent\\n opponent = game.get_opponent(player)\\n\\n # Remaining spaces left on the board\\n rem_spaces = len(game.get_blank_spaces())\\n\\n # number of agent's available moves\\n no_moves = len(game.get_legal_moves(player))\\n\\n # number of opponent's available moves\\n opp_moves = len(game.get_legal_moves(opponent))\\n\\n # evaluation of board \\\"goodness\\\"\\n # using moves available to both players\\n # Idea is player chooses moves with scores that maximise whilst minimizing\\n # evaluate board states and positions as scores\\n board_score = no_moves - opp_moves\\n score = board_score/rem_spaces\\n\\n return float(score)\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n #newGhostStates = successorGameState.getGhostStates()\\n #newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n score = 0.0\\n base = 100.0\\n\\n #if get fodd then add score\\n score += currentGameState.hasFood(newPos[0], newPos[1]) * base\\n for food in newFood.asList():\\n score -= base * (1 - math.exp(-1.0 * util.manhattanDistance(newPos, food)))\\n \\n #if too close to ghost then minus points\\n GhostPos = successorGameState.getGhostState(1).getPosition()\\n GhostScareTime = successorGameState.getGhostState(1).scaredTimer\\n if util.manhattanDistance(newPos, GhostPos) < 2 and GhostScareTime ==0:\\n score -= 1e100\\n\\n #Stop is not good for win so minus points\\n if action == Directions.STOP:\\n score -= base\\n\\n return score\\n #return successorGameState.getScore()\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return -math.inf\\n\\n if game.is_winner(player):\\n return math.inf\\n\\n opp_moves = game.get_legal_moves(game.get_opponent(player))\\n own_moves = game.get_legal_moves(player)\\n\\n return len(own_moves) / max(len(opp_moves), 1e-6)\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n oldFood = currentGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n\\n return successorGameState.getScore()\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n #Between 1-8\\n return own_moves / opp_moves\",\n \"def score(self):\\n score_message = {\\n 'Onewins': \\\"\\\\nThe Winner is Player 1!\\\",\\n 'Twowins': \\\"\\\\nThe Winner is Player 2!\\\",\\n 'Tie': \\\"\\\\nTie! Looks like everyone's a winner!\\\",\\n 'Nowinner': \\\"\\\\nYikes, neither of you win!\\\"\\n }\\n if self.pone_score > self.ptwo_score:\\n print(score_message['Onewins'])\\n elif self.pone_score < self.ptwo_score:\\n print(score_message['Twowins'])\\n elif self.pone_score == 0 and self.ptwo_score == 0:\\n print(score_message['Nowinner'])\\n else:\\n print(score_message['Tie'])\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = own_moves / opp_moves\\n\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n\\n if completeness < 0.5:\\n own_centerness = centerness(game, player)\\n opp_centerness = centerness(game, game.get_opponent(player))\\n centerness_ratio = own_centerness / opp_centerness + 0.1\\n\\n center_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def custom_score_2(game, player):\\n # TODO: finish this function!\\n if game.is_loser(player):\\n #print(\\\"You lose!\\\")\\n return -math.inf\\n if game.is_winner(player):\\n #print(\\\"You win\\\")\\n return math.inf\\n\\n # center\\n width = game.width / 2\\n height = game.height / 2\\n\\n # Opponent\\n opponent = game.get_opponent(player)\\n opp_y_coord, opp_x_coord = game.get_player_location(opponent)\\n opp_x_eval = (width - float(opp_x_coord)) ** 2\\n opp_y_eval = (height - float(opp_y_coord)) ** 2\\n opp_center_eval = float(opp_x_eval + opp_y_eval)\\n\\n # Remaining spaces left on the board\\n rem_spaces = len(game.get_blank_spaces())\\n\\n # number of agent's available moves\\n no_moves = len(game.get_legal_moves(player))\\n\\n # number of opponent's available moves\\n opp_moves = len(game.get_legal_moves(opponent))\\n\\n # evaluation of board \\\"goodness\\\"\\n # using moves available to both players\\n # Idea is player chooses moves with scores that maximise whilst minimizing\\n # evaluate board states and positions as scores\\n opp_score = opp_moves * 2 - opp_center_eval\\n score = no_moves - opp_score/rem_spaces\\n return float(score)\",\n \"def score(entry):\\n score = time_seconds(entry['Swim'])\\n score += time_seconds(entry['Run'])\\n score -= (int(entry['Push-ups']) * 2)\\n score -= int(entry['Sit-ups'])\\n score -= int(entry['Pull-ups']) * 6\\n return score\",\n \"def compute_score(window, computer_piece):\\n score = 0\\n if window.count(computer_piece) == 4:\\n score += 100\\n elif window.count(computer_piece) == 3 and window.count(0) == 1:\\n score += 5\\n elif window.count(computer_piece) == 2 and window.count(0) == 2:\\n score += 2\\n if window.count(PLAYER_PIECE) == 2 and window.count(0) == 2:\\n score -= 1\\n if window.count(PLAYER_PIECE) == 3 and window.count(0) == 1:\\n score -= 100\\n return score\",\n \"def GetResult(self, playerjm):\\n return self.score / len(self.scores)\",\n \"def score_game(self):\\r\\n players = self.player_control.get_players()\\r\\n ###game_control = self.game_control\\r\\n ###if game_control is not None:\\r\\n ### game_control.set_vals() # Update any changed game control settings\\r\\n if len(players) == 0:\\r\\n return # No players\\r\\n n_top_score = 0\\r\\n top_score = players[0].get_score()\\r\\n for player in players:\\r\\n if player.get_score() > top_score:\\r\\n top_score = player.get_score()\\r\\n for player in players:\\r\\n player_score = player.get_score()\\r\\n if player_score == top_score:\\r\\n n_top_score += 1\\r\\n \\r\\n for player in players:\\r\\n player_score = player.get_score()\\r\\n player_played = player.get_played()\\r\\n player_ties = player.get_ties()\\r\\n player_wins = player.get_wins()\\r\\n new_played = player_played+1\\r\\n player.set_played(new_played)\\r\\n player.set_prop(\\\"played\\\")\\r\\n if player_score == top_score:\\r\\n if n_top_score > 1:\\r\\n new_ties = player_ties + 1\\r\\n player.set_ties(new_ties)\\r\\n player.set_prop(\\\"ties\\\")\\r\\n else:\\r\\n new_wins = player_wins + 1\\r\\n player.set_wins(new_wins)\\r\\n player.set_prop(\\\"wins\\\")\\r\\n self.update_score_window()\",\n \"def pss(self):\\n return (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / \\\\\\n ((self.table[0, 0] + self.table[1, 0]) * (self.table[0, 1] + self.table[1, 1]))\",\n \"def custom_score_7(game, player):\\n \\\"\\\"\\\"custom_score_7 heuristic function also aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n oldFood = currentGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n return successorGameState.getScore()\",\n \"def score(self,player, board):\\r\\n numPlayer = 0\\r\\n numOpp = 0\\r\\n for i in self.squares():\\r\\n if board[i] == player:\\r\\n numPlayer+= SQUARE_WEIGHTS[i]\\r\\n else:\\r\\n numOpp+=SQUARE_WEIGHTS[i]\\r\\n return numPlayer-numOpp\",\n \"def custom_score_2(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # shortcut to definite state:\\n # 1. my agent win -> return very high score\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n # 2. opponenent's agent win -> return very low score\\n elif own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n # score: avaliable moves ratio\\n return float(own_moves/opp_moves)\",\n \"def custom_score(game, player):\\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n if game.move_count < 15:\\n return center_modified_score(game, player)\\n\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the base information to calculate player & opponent\\n # feature values\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n if len(player_legal_moves) != len(opponent_legal_moves):\\n return float(len(player_legal_moves) - len(opponent_legal_moves))\\n \\n # Get_center_coordinates and opponent. Then set the list of participants\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n participants = [player, opponent]\\n \\n # Then, for each participant obtain his/her feature values \\n for participant in participants:\\n if participant == player:\\n p_legal_moves = player_legal_moves\\n player_either = player\\n participant_coordinates = p_y, p_x = \\\\\\n game.get_player_location(participant)\\n player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, \\\\\\n player_path_count, player_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either,participant_coordinates, p_legal_moves)\\n else:\\n p_legal_moves = opponent_legal_moves\\n player_either = opponent\\n participant_coordinates = p_y, p_x \\\\\\n = game.get_player_location(participant)\\n opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, opponent_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either, participant_coordinates, p_legal_moves)\\n \\n # Place each participant's feature values in a tuple/vector surrogate \\n pro_player_vector = \\\\\\n (player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, player_path_count, \\\\\\n opponent_min_center_diff)\\n pro_opponent_vector = \\\\\\n (opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, player_min_center_diff)\\n \\n # Provide a weighting vector for the features \\n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\\n \\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\\\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def custom_score_6(game, player):\\n \\\"\\\"\\\"custom_score_6 heuristic function aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)\",\n \"def utility(self, state, player):\\n if state.isWin() or state.isLose():\\n return state.getScore()\\n\\n # In case of cycle.\\n if player == PACMAN:\\n return INFINITY\\n else:\\n return -INFINITY\",\n \"def calculate_score(player_cards):\\n score = sum(player_cards)\\n return score\",\n \"def scoreEvaluationFunction(currentGameState, index):\\n if currentGameState.isLose():\\n return -float(\\\"inf\\\")\\n \\n if currentGameState.isWin():\\n return float(\\\"inf\\\")\\n\\n # ghost function\\n def ghostScore(gameState):\\n if len(gameState.getGhostStates()) == 0:\\n return 0\\n score = 0\\n newGhostPos = gameState.getGhostPositions()\\n newGhostStates = gameState.getGhostStates()\\n for pacman in gameState.getPacmanPositions():\\n for i in range(len(newGhostPos)):\\n if newGhostStates[i].scaredTimer > 0:\\n score += ((max(4 - euclidDistance(pacman, newGhostPos[i]), 0)) ** 2)\\n else:\\n score -= ((max(4 - euclidDistance(pacman, newGhostPos[i]), 0)) ** 2)\\n if manhattanDistance(pacman, newGhostPos[i]) < 2:\\n return -float(\\\"inf\\\")\\n \\n return score\\n \\n # food function\\n def foodScore(gameState):\\n score = 0\\n for pacman in gameState.getPacmanPositions():\\n pacScore = []\\n for foodCoord in gameState.getFood().asList():\\n pacScore.append(euclidDistance(foodCoord, pacman))\\n score = min(pacScore)\\n \\n score = score * -2\\n score -= len(gameState.getFood().asList()) * 15\\n return score\\n\\n\\n totalScore = currentGameState.getScore()[0]\\n totalScore += ghostScore(currentGameState) \\n totalScore += foodScore(currentGameState)\\n return totalScore\",\n \"def calculate_scores(players):\\n scores = {}\\n for player in players.tuple_:\\n scores[player.id_] = player.score()\\n return scores\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n oldFood = currentGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n score = 10000\\n if successorGameState.isWin():\\n return 100000000\\n for ghost in newGhostStates:\\n ghostPos = ghost.getPosition()\\n if util.manhattanDistance(ghostPos, newPos) < 2:\\n score -= 10000\\n else:\\n score += util.manhattanDistance(ghostPos, newPos) * 1\\n \\n nearFood = 1000\\n farFood = 1000\\n for foodPos in oldFood.asList():\\n dist = util.manhattanDistance(foodPos, newPos)\\n if (dist < nearFood):\\n nearFood = dist\\n if (dist > farFood):\\n farFood = dist\\n if (currentGameState.getNumFood() < successorGameState.getNumFood()):\\n score += 5\\n\\n if action == Directions.WEST:\\n score -= 1\\n if action == Directions.STOP:\\n score -= 2\\n \\n for scareTime in newScaredTimes:\\n score += scareTime * 1\\n\\n score -= 2 * farFood\\n score -= 5 * nearFood\\n capsuleplaces = currentGameState.getCapsules()\\n if successorGameState.getPacmanPosition() in capsuleplaces:\\n score += 5\\n return max(score, 0)\\n \\n #their original return\\n #return successorGameState.getScore()\",\n \"def __get_score(self):\\n for pair in zip(self.nu[self.nu_idx:], self.sw[self.sw_idx:]):\\n if pair[0] == pair[1]:\\n self.score += 1\\n else:\\n break\",\n \"def custom_score(game, player):\\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the improved score\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n improved = len(player_legal_moves) - len(opponent_legal_moves)\\n if improved != 0:\\n return float(improved)\\n \\n # Second get differences from center\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n player_coordinates = game.get_player_location(player)\\n opponent_coordinates = game.get_player_location(opponent)\\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\\n center_dist_diff = player_center_dist - opponent_center_dist\\n \\n # Third obtain next_moves\\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \\n improved_next = len(player_next_moves) - len(opponent_next_moves)\\n \\n # Put player and opponent feature differences in a tuple/vector surrogoate\\n feature_diff_vector = (improved, center_dist_diff, improved_next)\\n \\n # Provide a weighting vector for the features of each player-participant\\n weight_vector = (1.5,0.1,1.0)\\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(feature_diff_vector, weight_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def get_game_score(self):\\n if self.game_is_tied():\\n return 0\\n elif self.is_game_won():\\n my_available_steps = self.steps_available(self.loc)\\n opp_available_steps = self.steps_available(self.opponent_loc)\\n my_score = self.my_score - self.penalty_score if my_available_steps == 0 else self.my_score\\n opp_score = self.opponent_score - self.penalty_score if opp_available_steps == 0 else self.opponent_score\\n return (my_score - opp_score) / (abs(my_score) + abs(opp_score))\\n else:\\n if abs(self.my_score) + abs(self.opponent_score) == 0:\\n return 0\\n return (self.my_score - self.opponent_score) / (abs(self.my_score) + abs(self.opponent_score))\",\n \"def update_score():\\n pass\",\n \"def game_score(self):\\n score = self.score.quantize(Decimal('0.001'))\\n return score if score > 0 else 0\",\n \"def getScore(self, gameState):\\n\\n if (self.red):\\n return gameState.getScore()\\n else:\\n return gameState.getScore() * -1\",\n \"def stats(self):\\n conversion, view = AB_test.unpack(self)\\n prob_ctrl = self.control[0]/self.control[1]\\n SE_ctrl = math.sqrt(prob_ctrl * (1 - prob_ctrl) / self.control[1])\\n prob = np.zeros(len(conversion))\\n SE = np.zeros(len(conversion))\\n ZScore = np.zeros(len(conversion))\\n pvalue = np.zeros(len(conversion))\\n for i in range(len(conversion)):\\n # probability is the conversion / view, \\n prob[i] = conversion[i]/view[i]\\n # SE is \\\\sqrt{ {p (1-p) \\\\over view} } in LaTeX\\n SE[i] = math.sqrt(prob[i] * (1-prob[i]) / view[i])\\n # Zscore is {p_{test} - p_{control} \\\\over SE_{test} ^ 2 + SE_{control} ^ 2}\\n ZScore[i] = (prob[i] - prob_ctrl)/math.sqrt(SE[i] ** 2 + SE_ctrl **2)\\n # pvalue is given as the cdf of the normal distribution funcion\\n pvalue[i] = stats.norm.cdf(ZScore[i])\\n self.prob = prob\\n self.se = SE\\n self.zscore = ZScore\\n self.pvalue = pvalue\\n return\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def custom_score_3(game, player):\\n # TODO: finish this function!\\n if game.is_winner(player): # check to see if player is in state winner\\n #print(\\\"You win!\\\")\\n return math.inf # abstraction of score, +inf equates to a win\\n elif game.is_loser(player):\\n #print(\\\"You lose!\\\")\\n return -math.inf # abstraction of score, -inf equates to a loss\\n\\n # center\\n width = game.width / 2\\n height = game.height / 2\\n\\n # Opponent\\n opponent = game.get_opponent(player)\\n y_coord, x_coord = game.get_player_location(player)\\n x_eval = (width - float(x_coord)) ** 2\\n y_eval = (height - float(y_coord)) ** 2\\n center_eval = float(x_eval + y_eval)\\n\\n # Remaining spaces left on the board\\n rem_spaces = len(game.get_blank_spaces())\\n\\n # number of agent's available moves\\n no_moves = len(game.get_legal_moves(player))\\n\\n # number of opponent's available moves\\n opp_moves = len(game.get_legal_moves(opponent))\\n\\n # evaluation of board \\\"goodness\\\"\\n # using moves available to both players\\n # Idea is player chooses moves with scores that maximise whilst minimizing\\n # evaluate board states and positions as scores\\n opp_score = opp_moves - center_eval\\n score = no_moves - opp_score\\n return float(score)\",\n \"def getScore(data):\\n return score\",\n \"def vanilaScore(self,attended,state,W):\",\n \"def custom_score(game, player):\\n\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n return __heuristic3__(game, player)\",\n \"def evaluate(state):\\r\\n if wins(state, COMP):\\r\\n score = +1\\r\\n elif wins(state, HUMAN):\\r\\n score = -1\\r\\n else:\\r\\n score = 0\\r\\n\\r\\n return score\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n \\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n final_score=0.0\\n #for ghosts\\n Ghost_dist= []\\n for ghost in newGhostStates:\\n Ghost_Position = ghost.getPosition() \\n d=manhattanDistance(Ghost_Position, newPos)\\n Ghost_dist.append(d)\\n \\n for i in Ghost_dist:\\n factor=1\\n if(i<=1):\\n if(ghost.scaredTimer==0): \\n final_score=final_score-200\\n else:\\n final_score=final_score + 1500\\n factor=-1\\n\\n #for capsule\\n capsule_state= currentGameState.getCapsules()\\n capsule_dist= []\\n for capsule in capsule_state:\\n b=manhattanDistance(capsule,newPos)\\n capsule_dist.append(b)\\n\\n for j in capsule_dist:\\n if(b==0):\\n final_score=final_score + 100\\n else:\\n final_score=final_score + (10.0/b)\\n\\n #for food\\n Food= currentGameState.getFood() \\n food_list = Food.asList()\\n food_pos = []\\n for k in food_list:\\n a=manhattanDistance(k,newPos)\\n food_pos.append(a)\\n for i in food_pos:\\n if(i==0):\\n final_score=final_score + 100\\n else:\\n final_score=final_score + (1.0/(i**2))\\n return final_score\",\n \"def _calculate_score(self):\\n mul = self._check_board()\\n if mul > 0:\\n inc = 100 * mul + ((mul - 1) * 25)\\n self.score += inc\",\n \"def custom_score_3(game, player):\\n \\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n player_legal_move_count, opponent_legal_move_count = \\\\\\n len(player_legal_moves), len(opponent_legal_moves)\\n move_count_difference = player_legal_move_count - opponent_legal_move_count\\n # Find coordinates of center box\\n h, w = get_center_coordinates(game)\\n # Retrieve player's coordinates\\n y, x = game.get_player_location(player)\\n # Obtain coordinate further, closest to origin\\n furthest_coord, closest_coord = max(h - y, w -x), min(h - y, w - x)\\n # Return weighted, vector-valued length from origin / sum of weights\\n weighted_distance_from_center = \\\\\\n math.sqrt((closest_coord**2 + 2*(furthest_coord**2)))/3\\n feature_vector = (move_count_difference, weighted_distance_from_center)\\n \\n weight_vector = (1.0,0.1)\\n \\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(weight_vector, feature_vector)) \\n \\n return float(weighted_difference_dot_product)\",\n \"def utility(state):\\n return state.getScore()\",\n \"def get_score(self, game_state):\\n if self.red:\\n return game_state.get_score()\\n else:\\n return game_state.get_score() * -1\",\n \"def calculate_player_position_score(marbles: list):\\n prime = Evaluator.prime_positions\\n good = Evaluator.good_positions\\n position_score = 0\\n for marble in marbles:\\n if marble in prime:\\n position_score += 10\\n elif marble in good:\\n position_score += 5\\n else:\\n position_score -= 1\\n return position_score\",\n \"def custom_score_general(game, player, constants=[]):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n v = []\\n\\n if constants[0] != 0 or constants[2] != 0:\\n own_moves = number_moves(game, player) / 8\\n\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n v.append(own_moves)\\n\\n if constants[1] != 0 or constants[2] != 0:\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n v.append(opp_moves)\\n\\n if constants[2] != 0:\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n v.append(move_ratio)\\n\\n if constants[3] != 0 or constants[5] != 0:\\n own_openness = nearby_openness(game, player) / 80\\n v.append(own_openness)\\n\\n if constants[4] != 0 or constants[5] != 0:\\n opp_openness = nearby_openness(game, game.get_opponent(player)) / 80\\n v.append(opp_openness)\\n\\n if constants[5] != 0:\\n openness_ratio = (own_openness * 80) / (opp_openness + 0.0001 * 80) /80\\n v.append(openness_ratio)\\n\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n if constants[6] != 0 or constants[8] != 0:\\n own_centerness = centerness(game, player) / centerness_max\\n v.append(own_centerness)\\n\\n if constants[7] != 0 or constants[8] != 0:\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n v.append(opp_centerness)\\n\\n if constants[8] != 0:\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n return sum([x * y for x, y in zip(constants, v)])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68148273","0.68119067","0.6762667","0.6762667","0.6762667","0.6762667","0.6762667","0.6762667","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.67188406","0.6716563","0.6654658","0.6628369","0.6567261","0.65515983","0.6538091","0.6504703","0.64821315","0.64821315","0.64821315","0.6481259","0.6478393","0.64666617","0.6465129","0.6462271","0.6431659","0.6431099","0.6430386","0.64295894","0.6427708","0.642411","0.64185905","0.6415086","0.63960457","0.63758636","0.6364931","0.6363011","0.63545364","0.63506764","0.6347378","0.632407","0.6323092","0.6317552","0.63041025","0.63031983","0.6302785","0.62975925","0.6287927","0.6284152","0.6282239","0.6280579","0.62714636","0.6268819","0.6255092","0.62508017","0.62475055","0.62436897","0.62414646","0.62262577","0.62148684","0.62141883","0.6210203","0.61953425","0.6177278","0.6173667","0.6162166","0.6159499","0.6158116","0.6119973"],"string":"[\n \"0.68148273\",\n \"0.68119067\",\n \"0.6762667\",\n \"0.6762667\",\n \"0.6762667\",\n \"0.6762667\",\n \"0.6762667\",\n \"0.6762667\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.67188406\",\n \"0.6716563\",\n \"0.6654658\",\n \"0.6628369\",\n \"0.6567261\",\n \"0.65515983\",\n \"0.6538091\",\n \"0.6504703\",\n \"0.64821315\",\n \"0.64821315\",\n \"0.64821315\",\n \"0.6481259\",\n \"0.6478393\",\n \"0.64666617\",\n \"0.6465129\",\n \"0.6462271\",\n \"0.6431659\",\n \"0.6431099\",\n \"0.6430386\",\n \"0.64295894\",\n \"0.6427708\",\n \"0.642411\",\n \"0.64185905\",\n \"0.6415086\",\n \"0.63960457\",\n \"0.63758636\",\n \"0.6364931\",\n \"0.6363011\",\n \"0.63545364\",\n \"0.63506764\",\n \"0.6347378\",\n \"0.632407\",\n \"0.6323092\",\n \"0.6317552\",\n \"0.63041025\",\n \"0.63031983\",\n \"0.6302785\",\n \"0.62975925\",\n \"0.6287927\",\n \"0.6284152\",\n \"0.6282239\",\n \"0.6280579\",\n \"0.62714636\",\n \"0.6268819\",\n \"0.6255092\",\n \"0.62508017\",\n \"0.62475055\",\n \"0.62436897\",\n \"0.62414646\",\n \"0.62262577\",\n \"0.62148684\",\n \"0.62141883\",\n \"0.6210203\",\n \"0.61953425\",\n \"0.6177278\",\n \"0.6173667\",\n \"0.6162166\",\n \"0.6159499\",\n \"0.6158116\",\n \"0.6119973\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6767508"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":3088,"cells":{"query":{"kind":"string","value":"Method which calculate DRE metric"},"document":{"kind":"string","value":"def set_dre(self):\n bx = self.get_standard_stats()\n ptos = float(bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])\n fga = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n trb = float(bx[\"reb_def\"] + bx[\"reb_of\"])\n d1 = ptos + (0.2*trb) + (1.7*float(bx[\"steals\"])) + (0.535*float(bx[\"block_shots\"])) + (0.5*float(bx[\"assists\"]))\n d2 = (0.9*fga) + (0.35*float(bx[\"tl_int\"])) + (1.4*float(bx[\"turnovers\"])) + (0.136*float(bx[\"minutes\"]))\n result = \"%.2f\" % round(d1-d2, 2)\n self.dre = \"%.2f\" % round(Decimal(result)/bx[\"games\"], 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute_metrics(self):\n pass","def calculate(self) -> float:","def calculate(self):","def calculate_dataset_metrics(self):\n pass","def calculateDataRate(self):\n pass","def getMeasures():","def denominator(self, ???):","def calculate(self):\r\n\r\n pass","def calculate(self):\r\n pass","def compute_statistics(self):","def measure(self, recommender):","def _core_calc_degrad(self,bd,Ld) :\n\t\tdegrad = np.dot(Ld,bd) # Do matrix multiplication \n\t\tdegrad = np.exp(degrad) # Exponentiate to convert log to real\n\t\treturn degrad","def get_metric(self) -> GreedyDiarizationErrorRate:\n return GreedyDiarizationErrorRate(collar=0.0, skip_overlap=False)","def cost(self) -> float:","def calculate(self):\n pass","def metric(x,y):\n sm = x + y\n df = x - y\n div = sm / df if df != 0 else 0\n return \"sum is %s \" %sm, \"difference is %s \" %df, \"division of difference to sum is %s\" %div","def measure(self):\n pass","def _get_eval_metric(self):\n raise NotImplementedError","def get_metric(self, data_row: pd.Series) -> float:","def calc(self):\n return None","def compute(self) -> Tuple[float, float, float]:\n # ddp hotfix, could be done better\n # but metric must handle DDP on it's own\n if self._ddp_backend == \"xla\":\n self.statistics = {\n k: xm.mesh_reduce(k, v, np.sum) for k, v in self.statistics.items()\n }\n elif self._ddp_backend == \"ddp\":\n for key in self.statistics:\n value: List[int] = all_gather(self.statistics[key])\n value: int = sum(value)\n self.statistics[key] = value\n\n precision_value, recall_value, f1_value = get_binary_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n zero_division=self.zero_division,\n )\n return precision_value, recall_value, f1_value","def metric(self, eles):\n point = eles.pop()\n dist = edist(point, self.soln)\n return dist","def compute(self) -> Any:\n # ddp hotfix, could be done better\n # but metric must handle DDP on it's own\n if self._ddp_backend == \"xla\":\n device = get_device()\n for key in self.statistics:\n key_statistics = torch.tensor([self.statistics[key]], device=device)\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\n self.statistics[key] = key_statistics\n elif self._ddp_backend == \"ddp\":\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n support=self.statistics[\"support\"],\n zero_division=self.zero_division,\n )\n if self.compute_per_class_metrics:\n return per_class, micro, macro, weighted\n else:\n return [], micro, macro, weighted","def compute(self) -> Any:\n # ddp hotfix, could be done better\n # but metric must handle DDP on it's own\n if self._ddp_backend == \"xla\":\n device = get_device()\n for key in self.statistics:\n key_statistics = torch.tensor([self.statistics[key]], device=device)\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\n self.statistics[key] = key_statistics\n elif self._ddp_backend == \"ddp\":\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n support=self.statistics[\"support\"],\n zero_division=self.zero_division,\n )\n if self.compute_per_class_metrics:\n return per_class, micro, macro, weighted\n else:\n return [], micro, macro, weighted","def metric(x, y):\n d = x - y\n s = x + y\n print('difference is %g, sum is %g' % (d, s))\n if s == 0:\n return 0\n return d / s","def calc_stat_values(self):","def _compute_rmse(self, data):\n actual = data.rating.values\n pred = self._predict_all(data)\n rmse = np.sqrt(np.sum((actual - pred) **2) /len(pred))\n return rmse","def make_metrics(self):\n num_batches = self.data_loader.number_of_batches()\n dose_score_vec = np.zeros(num_batches)\n\n # Only make calculations if data_loader is not empty\n if not self.data_loader.file_paths_list:\n print('No patient information was given to calculate metrics')\n else:\n # Change batch size to 1\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\n if self.dose_loader is not None:\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\n\n for idx in tqdm.tqdm(range(num_batches)):\n # Get roi masks for patient\n self.get_constant_patient_features(idx)\n # Get dose tensors for reference dose and evaluate criteria\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\n if reference_dose is not None:\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\n # If a dose loader was provided, calculate the score\n if self.dose_loader is not None:\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\n # Make metric data frames\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\n # Evaluate mean absolute error of 3D dose\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\n # their files\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\n\n if self.dose_loader is not None:\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\n dose_score = dose_score_vec.mean()\n return dvh_score, dose_score\n else:\n print('No new dose provided. Metrics were only calculated for the provided dose.')","def calculate(self):\n\n beta = 1 # or 0.5 or 2 can also calculate F2 or F0.5 measure\n\n beta_squared = beta * beta\n precision = Precision()\n precision.confusion_matrix = self.confusion_matrix\n precision = precision.calculate()\n recall = Recall()\n recall.confusion_matrix = self.confusion_matrix\n recall = recall.calculate()\n\n denominator = beta_squared * precision + recall\n\n if denominator != 0:\n return (1 + beta_squared) * ((precision * recall) / denominator)\n else:\n return 0","def calculate_output(self):","def accuracy(self):","def advancedStats():","def calculate(self):\n\n tp = self.confusion_matrix.tp\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n return tp / (tp + fp + fn)","def eval_error_metric(predt, dtrain: xgb.DMatrix):\n label = dtrain.get_label()\n r = np.zeros(predt.shape)\n gt = predt > 0.5\n if predt.size == 0:\n return \"CustomErr\", 0\n r[gt] = 1 - label[gt]\n le = predt <= 0.5\n r[le] = label[le]\n return 'CustomErr', np.sum(r)","def calc_reduction_diesel_used (self):\n self.reduction_diesel_used = self.diesel_equiv_captured - \\\n self.loss_heat_recovery\n #~ print 'self.reduction_diesel_used',self.reduction_diesel_used","def rmdspe(self) -> float:\n return float(np.sqrt(np.median(np.square(self._percentage_error()))) * 100.0)","def getMeasure(unique_name):","def getMeasure(unique_name):","def compute(self) -> Tuple[float, float, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[float] = all_gather(self.statistics[key])\n value: float = sum(value)\n self.statistics[key] = value\n\n precision_value, recall_value, f1_value = get_binary_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n zero_division=self.zero_division,\n )\n return precision_value, recall_value, f1_value","def calc_D(state):\n\t\tif t < thresh:\n\t\t\tstate.D_g[t] = 0.5\n\t\t\tstate.D_n[t] = 0.5\n\t\telse:\n\t\t\tif mod == \"constant\":\n\t\t\t\tstate.D_g[t] = D\n\t\t\t\tstate.D_n[t] = 1-D\n\t\t\tif mod == \"value\":\n\t\t\t\t# NOTE: if rmag and lmag is 1/0, can just use V\n\t\t\t\t# average of two actions\n\t\t\t\tV = np.mean(1/2*(state.QG[t,:] - state.QN[t,:])) # state average(?) \n\t\t\t\tV = 1/(1 + np.exp(-V*k)) # translate between 0 and 1\n\t\t\t\tstate.D_g[t] = V \n\t\t\t\tstate.D_n[t] = 1 - V\n\t\treturn state","def patrimony_total(self):\n pass","def dfr(self):\n return self.table[1, 0] / (self.table[1, 0] + self.table[1, 1])","def calculate(self):\n\n tp = self.confusion_matrix.tp\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n return 1 - abs(fn - fp) / (2 * tp + fn + fp)","def cost_derivative(self,output_results,y):\r\n\t\treturn (output_results-y)","def compute_metric(inargs, exp_id, date):\n date_str = h.dt_to_yyyymmddhhmmss(date)\n fg_str = '_da' if inargs.fg else ''\n\n # Load presaved forecast data\n if exp_id in ['ey', 'rw']: # Make an exception for radar as exp_id\n radar_fn = (config.savedir_base + exp_id + '/prec_fields/' + exp_id +\n '_' + date_str + '.npy')\n fc_data = np.load(radar_fn)\n else:\n fc_fn = (config.savedir_base + exp_id + '/' +\n config.metric_dict[inargs.metric.split('-')[0]]['var'] +\n '_fields/' +\n config.metric_dict[inargs.metric.split('-')[0]]['det_or_ens'] +\n fg_str + '_' + date_str + '.npy')\n fc_data = np.load(fc_fn)\n\n if config.metric_dict[inargs.metric.split('-')[0]]['use_radar']:\n # Load presaved radar data\n radar_fn = (config.savedir_base + inargs.radar_comp + '/prec_fields/' +\n inargs.radar_comp + '_' + date_str + '.npy')\n radar_data = np.load(radar_fn)\n if inargs.combine_masks is not None:\n comb_fn = (config.savedir_base + inargs.combine_masks +\n '/prec_fields/' + inargs.combine_masks + '_' +\n date_str + '.npy')\n comb_data = np.load(comb_fn)\n else:\n comb_data = None\n radar_data, fc_data = h.handle_nans(radar_data, fc_data,\n inargs.radar_thresh,\n comb_data)\n\n if not inargs.upscale == 1:\n fc_data = h.upscale_fields(fc_data, inargs.upscale)\n if 'radar_data' in locals():\n radar_data = h.upscale_fields(radar_data, inargs.upscale)\n\n # Pass data to computation functions\n if inargs.metric in ['det_mean_prec', 'det_mean_cape', 'det_mean_cin']:\n m = h.compute_det_domain_mean(fc_data)\n elif inargs.metric in ['det_median_prec', 'det_median_cape',\n 'det_median_cin']:\n m = h.compute_det_domain_median(fc_data)\n elif inargs.metric == 'det_rmse':\n m = h.compute_det_rmse(radar_data, fc_data)\n elif 'det_sal' in inargs.metric:\n _, sal_thresh = inargs.metric.split('-')\n sal_thresh = float(sal_thresh) / 10.\n m = h.compute_det_sal(radar_data, fc_data, sal_thresh)\n elif 'det_fss' in inargs.metric:\n # Parse\n _, fss_thresh, fss_size = inargs.metric.split('-')\n fss_thresh = float(fss_thresh) / 10.\n fss_size = int(fss_size)\n # Update dictionary NOTE: This doesn't seem to work\n # config.metric_dict[inargs.metric.split('-')[0]]['ylabel'] = \\\n # 'FSS ' + str(fss_thresh) + 'mm/h ' + str(fss_size * 2.8) + 'km'\n m = h.compute_det_fss(radar_data, fc_data, fss_thresh, fss_size)\n elif inargs.metric == 'det_prec_hist':\n m = h.compute_det_prec_hist(fc_data)\n elif inargs.metric == 'ens_rmse':\n m = h.compute_ens_rmse(radar_data, fc_data)\n elif inargs.metric == 'ens_rmv':\n m = h.compute_ens_rmv(fc_data)\n elif inargs.metric == 'ens_crps':\n m = h.compute_ens_crps(radar_data, fc_data)\n elif 'ens_bs' in inargs.metric:\n # Parse\n s = inargs.metric.split('-')\n _, bs_thresh, bs_size = s\n bs_size = int(bs_size)\n bs_thresh = float(bs_thresh) / 10.\n # Update dictionary\n # config.metric_dict[inargs.metric.split('-')[0]]['ylabel'] = \\\n # 'BS ' + str(bs_thresh) + 'mm/h '\n m = h.compute_ens_bs(radar_data, fc_data, bs_thresh, bs_size)\n else:\n raise ValueError('Metric %s does not exist.' % inargs.metric)\n\n return m","def performance_measure(self, x):\n # \"calculate performance measure\" \n pref = x.evaluate()\n return pref","def evaluate(self):\n\n if self.opt['AccurateDFid']:\n DX = self.reconstruct()\n S = self.xstep.S\n dfd = (np.linalg.norm(self.xstep.W * (DX - S))**2) / 2.0\n if self.xmethod == 'fista':\n X = self.xstep.getcoef()\n else:\n X = self.xstep.var_y1()\n rl1 = np.sum(np.abs(X))\n return dict(DFid=dfd, RegL1=rl1,\n ObjFun=dfd + self.xstep.lmbda * rl1)\n else:\n return None","def calculate_metrics(self):\n \n for cv in self.cat_vals:\n cat_inds = np.where(self.category_values == cv)[0]\n weighted_difference = (self.z[cat_inds]-self.mz[cat_inds])/self.weight_values[cat_inds]\n resid = np.sqrt(np.sum(np.square(weighted_difference))/(cat_inds.size))\n self.metric[str(cv)] = resid\n \n return self.metric","def diarisationMetrics(reference, hypothesis, audioLength, collar_val = 0.5):\r\n with warnings.catch_warnings():\r\n warnings.simplefilter(\"ignore\")\r\n\r\n metrics = {}\r\n # for collar, skip_overlap, expName in [(0.0, False, 'NoCollarOverlap'),(collar_val, False, 'CollarOverlap'), (0.0, True, 'NoCollarNoOverlap'), (collar_val, True, 'CollarNoOverlap')]:\r\n for collar, skip_overlap, expName in [(collar_val, False, 'CollarOverlap'), (collar_val, True, 'CollarNoOverlap')]:\r\n diarizationErrorRate = DiarizationErrorRate(collar=collar, skip_overlap=skip_overlap)\r\n jaccardErrorRate = JaccardErrorRate(collar=collar, skip_overlap=skip_overlap)\r\n purity = DiarizationPurity(collar=collar, skip_overlap=skip_overlap)\r\n coverage = DiarizationCoverage(collar=collar, skip_overlap=skip_overlap)\r\n detectionAccuracy = DetectionAccuracy(collar=collar, skip_overlap=skip_overlap)\r\n\r\n print('*'*10, 'Collar: {}ms Skip Overlap: {}'.format(collar, skip_overlap), '*'*10)\r\n print(\"DER = {0:.5f}\".format(diarizationErrorRate(reference, hypothesis, uem=Segment(0, audioLength))))\r\n print(\"JER = {0:.5f}\".format(jaccardErrorRate(reference, hypothesis, uem=Segment(0, audioLength))))\r\n print(\"Optimal mapping = {}\".format(diarizationErrorRate.optimal_mapping(reference, hypothesis)))\r\n print(\"Purity = {0:.5f}\".format(purity(reference, hypothesis, uem=Segment(0, audioLength))))\r\n print(\"Coverage = {0:.5f}\".format(coverage(reference, hypothesis, uem=Segment(0, audioLength))))\r\n dtAcc = detectionAccuracy.compute_components(reference, hypothesis)\r\n # print(\"Detection Accuracy: FN = {:.5f}, FP = {:.5f}, TN = {:.5f}, TP = {:.5f}\\n\".format(dtAcc['false negative'],dtAcc['false positive'],dtAcc['true negative'],dtAcc['true positive']))\r\n\r\n metrics[expName]={}\r\n\r\n keys = ['DER','JER', 'mapping', 'purity', 'coverage', 'detectionAccuracy']\r\n values = diarizationErrorRate(reference, hypothesis, detailed=True, uem=Segment(0, audioLength)),\\\r\n jaccardErrorRate(reference, hypothesis, detailed=True, uem=Segment(0, audioLength)),\\\r\n diarizationErrorRate.optimal_mapping(reference, hypothesis),\\\r\n purity(reference, hypothesis, uem=Segment(0, audioLength)),\\\r\n coverage(reference, hypothesis, uem=Segment(0, audioLength)),\\\r\n detectionAccuracy.compute_components(reference, hypothesis)\r\n\r\n metrics[expName] = dict(zip(keys, list(values)))\r\n metrics = edict(metrics)\r\n return metrics","def __dmr_analysis(self, debug=False):\n global hfAdcRange, adcCountRange\n if self.buffer is None or len(self.buffer) != self.bufsize:\n self.set_eval_error(f'Data length ({len(self.buffer)}) differs from expected ({self.bufsize})')\n return None\n\n It = self.buffer[:self.bufsize//2]\n Qt = self.buffer[self.bufsize//2:]\n\n self.results['ADC_I'] = hfAdcRange * (It * 2 / adcCountRange - 1)\n self.results['ADC_Q'] = hfAdcRange * (Qt * 2 / adcCountRange - 1)\n\n # subtract the DC component and convert to int32\n It = np.around(It-np.mean(It)).astype('int32')\n Qt = np.around(Qt-np.mean(Qt)).astype('int32')\n\n # find the bit error rate and constant symbol intervals\n maxlen = 20*200 # max length of returned Iref, Qref\n numerr, numbit, Iref, Qref, symlenref = get_ber(It, Qt, maxlen)\n\n if numerr is None or numbit is None:\n self.set_eval_error(f'Too small data length - {len(self.buffer)}')\n return None\n\n ber = numerr/numbit\n\n return ber","def compute_metrics(self, results: list) -> dict:","def compute_metric(df, preds):\n\n y = np.array(df['pressure'].values.tolist())\n\n # inspiratory phase\n mask = 1 - np.array(df['u_out'].values.tolist())\n\n # combine with mae calculusse\n mae = mask * np.abs(y - preds)\n mae = mae.sum() / mask.sum()\n\n return mae","def calculate(self):\n\n specificity = self.confusion_matrix.tn / (self.confusion_matrix.tn + self.confusion_matrix.fp)\n\n false_positive_rate = 1 - specificity\n\n true_positive_rate = self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\n\n return (true_positive_rate - false_positive_rate + 1) / 2","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n n = self.confusion_matrix.n\n\n fn_tp = fn + tp\n fp_tp = fp + tp\n\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\n\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\n\n p00 = 1 if tn == 0 else (tn / n)\n p01 = 1 if fn == 0 else (fn / n)\n p10 = 1 if fp == 0 else (fp / n)\n p11 = 1 if tp == 0 else (tp / n)\n\n h12 = -((tn / n) * math.log2(p00) +\n (fn / n) * math.log2(p01) +\n (fp / n) * math.log2(p10) +\n (tp / n) * math.log2(p11))\n\n mi = h1 + h2 - h12\n\n vi = h1 + h2 - 2 * mi\n return vi","def _derivativeTerm(self):\n\n\t\treturn self._Kd * (self._getErrorFunction() - self._previousError) / self._dt","def calculations():\r\n\t\r\n\tpayload, avionics, booster = weight_input()\r\n\r\n\tdrogue_size, drogue_force = drogue_calc()\r\n\tmain_size, main_force = main_calc(avionics, booster, drogue_force) #total mass, payload detaches\r\n\r\n\tprint(\"Drogue is diameter is \" + str(drogue_size) + \" inches\")\r\n\tprint(\"Main is diameter is \" + str(main_size) + \" inches\")","def compute_metrics(mat,language='English',method ='dimensional',output='data_frame'):\n language = language.lower()\n method = method.lower()\n if language == 'english':\n if method == 'dimensional':\n if output == 'data_frame':\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\n return(mat)\n elif output == 'array':\n out_dict = {}\n out_dict['PosVal'] = mat[:,:,0]\n out_dict['NegVal'] = mat[:,:,1]\n out_dict['Arousal'] = mat[:,:,2]\n out_dict['Dominance'] = mat[:,:,3]\n out_dict['PosCount'] = mat[:,:,4]\n out_dict['DetectCount'] = mat[:,:,5]\n out_dict['TokenCount'] = mat[:,:,6]\n out_dict['ValSq'] = mat[:,:,7]\n\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\n # Mean Values:\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DetectCount'])\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\n # Percentages:\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\")\n elif method == 'discrete':\n if output == 'data_frame':\n mat['function_Percent'] = mat.function / mat.TokenCount\n mat['pronoun_Percent'] = mat.pronoun / mat.TokenCount\n mat['ppron_Percent'] = mat.ppron / mat.TokenCount\n mat['i_Percent'] = mat.i / mat.TokenCount\n mat['we_Percent'] = mat.we / mat.TokenCount\n mat['you_Percent'] = mat.you / mat.TokenCount\n mat['shehe_Percent'] = mat.shehe / mat.TokenCount\n mat['they_Percent'] = mat.they / mat.TokenCount\n mat['ipron_Percent'] = mat.ipron / mat.TokenCount\n mat['article_Percent'] = mat.article / mat.TokenCount\n mat['prep_Percent'] = mat.prep / mat.TokenCount\n mat['auxverb_Percent'] = mat.auxverb / mat.TokenCount\n mat['adverb_Percent'] = mat.adverb / mat.TokenCount\n mat['conj_Percent'] = mat.conj / mat.TokenCount\n mat['negate_Percent'] = mat.negate / mat.TokenCount\n mat['verb_Percent'] = mat.verb / mat.TokenCount\n mat['adj_Percent'] = mat.adj / mat.TokenCount\n mat['compare_Percent'] = mat.compare / mat.TokenCount\n mat['interrog_Percent'] = mat.interrog / mat.TokenCount\n mat['number_Percent'] = mat.number / mat.TokenCount\n mat['quant_Percent'] = mat.quant / mat.TokenCount\n mat['affect_Percent'] = mat.affect / mat.TokenCount\n mat['posemo_Percent'] = mat.posemo / mat.TokenCount\n mat['negemo_Percent'] = mat.negemo / mat.TokenCount\n mat['anx_Percent'] = mat.anx / mat.TokenCount\n mat['anger_Percent'] = mat.anger / mat.TokenCount\n mat['sad_Percent'] = mat.sad / mat.TokenCount\n mat['social_Percent'] = mat.social / mat.TokenCount\n mat['family_Percent'] = mat.family / mat.TokenCount\n mat['friend_Percent'] = mat.friend / mat.TokenCount\n mat['female_Percent'] = mat.female / mat.TokenCount\n mat['male_Percent'] = mat.male / mat.TokenCount\n mat['cogproc_Percent'] = mat.cogproc / mat.TokenCount\n mat['insight_Percent'] = mat.insight / mat.TokenCount\n mat['cause_Percent'] = mat.cause / mat.TokenCount\n mat['discrep_Percent'] = mat.discrep / mat.TokenCount\n mat['tentat_Percent'] = mat.tentat / mat.TokenCount\n mat['certain_Percent'] = mat.certain / mat.TokenCount\n mat['differ_Percent'] = mat.differ / mat.TokenCount\n mat['percept_Percent'] = mat.percept / mat.TokenCount\n mat['see_Percent'] = mat.see / mat.TokenCount\n mat['hear_Percent'] = mat.hear / mat.TokenCount\n mat['feel_Percent'] = mat.feel / mat.TokenCount\n mat['bio_Percent'] = mat.bio / mat.TokenCount\n mat['body_Percent'] = mat.body / mat.TokenCount\n mat['health_Percent'] = mat.health / mat.TokenCount\n mat['sexual_Percent'] = mat.sexual / mat.TokenCount\n mat['ingest_Percent'] = mat.ingest / mat.TokenCount\n mat['drives_Percent'] = mat.drives / mat.TokenCount\n mat['affiliation_Percent'] = mat.affiliation / mat.TokenCount\n mat['achieve_Percent'] = mat.achieve / mat.TokenCount\n mat['power_Percent'] = mat.power / mat.TokenCount\n mat['reward_Percent'] = mat.reward / mat.TokenCount\n mat['risk_Percent'] = mat.risk / mat.TokenCount\n mat['focuspast_Percent'] = mat.focuspast / mat.TokenCount\n mat['focuspresent_Percent'] = mat.focuspresent / mat.TokenCount\n mat['focusfuture_Percent'] = mat.focusfuture / mat.TokenCount\n mat['relativ_Percent'] = mat.relativ / mat.TokenCount\n mat['motion_Percent'] = mat.motion / mat.TokenCount\n mat['space_Percent'] = mat.space / mat.TokenCount\n mat['time_Percent'] = mat.time / mat.TokenCount\n mat['work_Percent'] = mat.work / mat.TokenCount\n mat['leisure_Percent'] = mat.leisure / mat.TokenCount\n mat['home_Percent'] = mat.home / mat.TokenCount\n mat['money_Percent'] = mat.money / mat.TokenCount\n mat['relig_Percent'] = mat.relig / mat.TokenCount\n mat['death_Percent'] = mat.death / mat.TokenCount\n mat['informal_Percent'] = mat.informal / mat.TokenCount\n mat['swear_Percent'] = mat.swear / mat.TokenCount\n mat['netspeak_Percent'] = mat.netspeak / mat.TokenCount\n mat['assent_Percent'] = mat.assent / mat.TokenCount\n mat['nonflu_Percent'] = mat.nonflu / mat.TokenCount\n mat['filler_Percent'] = mat.filler / mat.TokenCount\n mat['Detect_Percent'] = mat.DetectCount / mat.TokenCount\n return(mat)\n elif output == 'array':\n out_dict = {}\n out_dict['Affect'] = mat[:,:,21]\n out_dict['Posemo'] = mat[:,:,22]\n out_dict['Negemo'] = mat[:,:,23]\n out_dict['Anx'] = mat[:,:,24]\n out_dict['Anger'] = mat[:,:,25]\n out_dict['Sad'] = mat[:,:,26]\n out_dict['Function'] = mat[:,:,0]\n out_dict['CogProc'] = mat[:,:,32]\n out_dict['DetectCount'] = mat[:,:,-2]\n out_dict['TokenCount'] = mat[:,:,-1]\n\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\n\n\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\") \n else:\n print(\"Error: Method not found!\")\n elif language == 'german':\n if method == 'dimensional':\n if output == 'data_frame':\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\n mat['MeanPotency'] = mat['Potency'] / mat['DetectCount']\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\n return(mat)\n elif output == 'array':\n out_dict = {}\n out_dict['PosVal'] = mat[:,:,0]\n out_dict['NegVal'] = mat[:,:,1]\n out_dict['Arousal'] = mat[:,:,2]\n out_dict['Dominance'] = mat[:,:,3]\n out_dict['PosCount'] = mat[:,:,4]\n out_dict['DetectCount'] = mat[:,:,5]\n out_dict['Imagine'] = mat[:,:,6]\n out_dict['Potency'] = mat[:,:,7]\n out_dict['DomPot_Count'] = mat[:,:,8]\n out_dict['TokenCount'] = mat[:,:,9]\n out_dict['ValSq'] = mat[:,:,10]\n\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\n # Mean Values:\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DomPot_Count'])\n out_dict['MeanPotency'] = np.divide(out_dict['Potency'],out_dict['DomPot_Count'])\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\n # Percentages:\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\")\n elif method == 'discrete':\n if output == 'data_frame':\n mat['Pronoun_Percent'] = mat.Pronoun / mat.TokenCount\n mat['I_Percent'] = mat.I / mat.TokenCount\n mat['We_Percent'] = mat.We / mat.TokenCount\n mat['Self_Percent'] = mat.Self / mat.TokenCount\n mat['You_Percent'] = mat.You / mat.TokenCount\n mat['Other_Percent'] = mat.Other / mat.TokenCount\n mat['Negate_Percent'] = mat.Negate / mat.TokenCount\n mat['Assent_Percent'] = mat.Assent / mat.TokenCount\n mat['Article_Percent'] = mat.Article / mat.TokenCount\n mat['Preps_Percent'] = mat.Preps / mat.TokenCount\n mat['Number_Percent'] = mat.Number / mat.TokenCount\n mat['Affect_Percent'] = mat.Affect / mat.TokenCount\n mat['Posemo_Percent'] = mat.Posemo / mat.TokenCount\n mat['Posfeel_Percent'] = mat.Posfeel / mat.TokenCount\n mat['Optim_Percent'] = mat.Optim / mat.TokenCount\n mat['Negemo_Percent'] = mat.Negemo / mat.TokenCount\n mat['Anx_Percent'] = mat.Anx / mat.TokenCount\n mat['Anger_Percent'] = mat.Anger / mat.TokenCount\n mat['Sad_Percent'] = mat.Sad / mat.TokenCount\n mat['Cogmech_Percent'] = mat.Cogmech / mat.TokenCount\n mat['Cause_Percent'] = mat.Cause / mat.TokenCount\n mat['Insight_Percent'] = mat.Insight / mat.TokenCount\n mat['Discrep_Percent'] = mat.Discrep / mat.TokenCount\n mat['Inhib_Percent'] = mat.Inhib / mat.TokenCount\n mat['Tentat_Percent'] = mat.Tentat / mat.TokenCount\n mat['Certain_Percent'] = mat.Certain / mat.TokenCount\n mat['Senses_Percent'] = mat.Senses / mat.TokenCount\n mat['See_Percent'] = mat.See / mat.TokenCount\n mat['Hear_Percent'] = mat.Hear / mat.TokenCount\n mat['Feel_Percent'] = mat.Feel / mat.TokenCount\n mat['Social_Percent'] = mat.Social / mat.TokenCount\n mat['Comm_Percent'] = mat.Comm / mat.TokenCount\n mat['Othref_Percent'] = mat.Othref / mat.TokenCount\n mat['Friends_Percent'] = mat.Friends / mat.TokenCount\n mat['Family_Percent'] = mat.Family / mat.TokenCount\n mat['Humans_Percent'] = mat.Humans / mat.TokenCount\n mat['Time_Percent'] = mat.Time / mat.TokenCount\n mat['Past_Percent'] = mat.Past / mat.TokenCount\n mat['Present_Percent'] = mat.Present / mat.TokenCount\n mat['Future_Percent'] = mat.Future / mat.TokenCount\n mat['Space_Percent'] = mat.Space / mat.TokenCount\n mat['Up_Percent'] = mat.Up / mat.TokenCount\n mat['Down_Percent'] = mat.Down / mat.TokenCount\n mat['Incl_Percent'] = mat.Incl / mat.TokenCount\n mat['Excl_Percent'] = mat.Excl / mat.TokenCount\n mat['Motion_Percent'] = mat.Motion / mat.TokenCount\n mat['Occup_Percent'] = mat.Occup / mat.TokenCount\n mat['School_Percent'] = mat.School / mat.TokenCount\n mat['Job_Percent'] = mat.Job / mat.TokenCount\n mat['Achieve_Percent'] = mat.Achieve / mat.TokenCount\n mat['Leisure_Percent'] = mat.Leisure / mat.TokenCount\n mat['Home_Percent'] = mat.Home / mat.TokenCount\n mat['Sports_Percent'] = mat.Sports / mat.TokenCount\n mat['TV_Percent'] = mat.TV / mat.TokenCount\n mat['Music_Percent'] = mat.Music / mat.TokenCount\n mat['Money_Percent'] = mat.Money / mat.TokenCount\n mat['Metaph_Percent'] = mat.Metaph / mat.TokenCount\n mat['Relig_Percent'] = mat.Relig / mat.TokenCount\n mat['Death_Percent'] = mat.Death / mat.TokenCount\n mat['Physcal_Percent'] = mat.Physcal / mat.TokenCount\n mat['Body_Percent'] = mat.Body / mat.TokenCount\n mat['Sexual_Percent'] = mat.Sexual / mat.TokenCount\n mat['Eating_Percent'] = mat.Eating / mat.TokenCount\n mat['Sleep_Percent'] = mat.Sleep / mat.TokenCount\n mat['Groom_Percent'] = mat.Groom / mat.TokenCount\n mat['Swear_Percent'] = mat.Swear / mat.TokenCount\n mat['Nonfl_Percent'] = mat.Nonfl / mat.TokenCount\n mat['Fillers_Percent'] = mat.Fillers / mat.TokenCount\n mat['Swiss_Percent'] = mat.Swiss / mat.TokenCount\n mat['Ideo_Percent'] = mat.Ideo / mat.TokenCount\n mat['Personalpronomina_Percent'] = mat.Personalpronomina / mat.TokenCount\n mat['Indefinitpronomina_Percent'] = mat.Indefinitpronomina / mat.TokenCount\n mat['AuxiliaryVerbs_Percent'] = mat.AuxiliaryVerbs / mat.TokenCount\n mat['Konjunktionen_Percent'] = mat.Konjunktionen / mat.TokenCount\n mat['Adverbien_Percent'] = mat.Adverbien / mat.TokenCount\n mat['Detect_Percent'] = mat.LIWC_Counter / mat.TokenCount\n mat['Bedrohung_Percent'] = mat.Bedrohung / mat.TokenCount\n return(mat)\n\n elif output == 'array':\n out_dict = {}\n out_dict['Affect'] = mat[:,:,11]\n out_dict['Posemo'] = mat[:,:,12]\n out_dict['Posfeel'] = mat[:,:,13]\n out_dict['Optim'] = mat[:,:,14]\n out_dict['Negemo'] = mat[:,:,15]\n out_dict['Anx'] = mat[:,:,16]\n out_dict['Anger'] = mat[:,:,17]\n out_dict['Sad'] = mat[:,:,18]\n out_dict['Function'] = mat[:,:,0]\n out_dict['CogProc'] = mat[:,:,32]\n out_dict['DetectCount'] = mat[:,:,-2]\n out_dict['TokenCount'] = mat[:,:,-1]\n\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\n out_dict['DetectPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['DetectCount'])\n out_dict['OverallPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['TokenCount'])\n out_dict['DetectOptimPercent'] = np.divide(out_dict['Optim'], out_dict['DetectCount'])\n out_dict['OverallOptimPercent'] = np.divide(out_dict['Optim'], out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\n\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\") \n else:\n print(\"Error: Method not found!\") \n elif language == 'chinese':\n if method == 'dimensional':\n if output == 'data_frame':\n print(\"Error: This combination doesn't exist yet!\")\n elif output == 'array':\n print(\"Error: This combination doesn't exist yet!\")\n else:\n print(\"Error: Output Format not found!\")\n elif method == 'discrete':\n if output == 'data_frame':\n print(\"Error: This combination doesn't exist yet!\")\n elif output == 'array':\n out_dict = {}\n out_dict['Affect'] = mat[:,:,30]\n out_dict['Posemo'] = mat[:,:,31]\n out_dict['Negemo'] = mat[:,:,32]\n out_dict['Anx'] = mat[:,:,33]\n out_dict['Anger'] = mat[:,:,34]\n out_dict['Sad'] = mat[:,:,35]\n out_dict['Function'] = mat[:,:,0]\n out_dict['CogProc'] = mat[:,:,41]\n out_dict['DetectCount'] = mat[:,:,-2]\n out_dict['TokenCount'] = mat[:,:,-1]\n\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'], out_dict['TokenCount'])\n\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\n return(out_dict)\n else:\n print(\"Error: Output Format not found!\") \n else:\n print(\"Error: Method not found!\") \n else:\n print(\"Error: Language not found!\")","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n n = tp + tn + fp + fn\n e1 = (fn * (fn + 2 * tp) / (tp + fn) + fp * (fp + 2 * tn) / (tn + fp)) / n\n e2 = (fp * (fp + 2 * tp) / (tp + fp) + fn * (fn + 2 * tn) / (tn + fn)) / n\n\n return min(e1, e2)","def calculate(self):\n\n return 2 * self.confusion_matrix.tp / \\\n (2 * self.confusion_matrix.tp + self.confusion_matrix.fp + self.confusion_matrix.fn)","def test_get_derived_metric(self):\n pass","def get_dps(data_dict, R = 50):\n p1_ida = iterable_data_array(data_dict, 'p1')\n p2_ida = iterable_data_array(data_dict, 'p2')\n worker = data_array_builder()\n \n for p1, p2 in zip(p1_ida, p2_ida):\n worker.append((p1 - p2)/R) \n \n return {'time':data_dict['time'], 'dp':worker.build()}","def evaluate_viz_metrics(y_emb, dataset, verbose=1):\n results = {}\n\n # results[\"trust\"] = trustworthiness(dataset.inputs, y_emb, n_neighbors=5, metric=distance_metric)\n results[\"One NN accuracy\"] = nearest_neighbours_generalisation_accuracy(y_emb, dataset.labels, 1)\n results[\"Avg graph distance\"], results[\"Avg feature distance\"] = combined_dist_metric(y_emb, dataset.inputs, dataset.adj_matrix, k=5)\n results['Total distance'] = results[\"Avg graph distance\"] + results[\"Avg feature distance\"]\n\n if verbose:\n for k, v in results.items():\n print(\"{} = {:.4f}\".format(k, v))\n return results","def getDensityEstimate(self):\n return self.density","def r_d(self, tl):\n\t return self.RD0*exp(self.HKR/(R*self.TO)*(1. - self.TO/tl))","def ComputeEnergyConsumption(self):\r\n pass","def total_sdram_requirements(self):","def compute(dm,do):\n mae = MV.average(MV.absolute(MV.subtract(dm,do)))\n return float(mae)","def _calculate(self):\n source = self.source\n res = {}\n l_cols = [[], [], [], []]\n r_lines = {}\n dateline=None\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\n if source[t.ror].min() > -99.0:\n pass\n else:\n source[t.ror] = np.where(\n source[t.ror] > -99.0, source[t.ror], -99.0)\n ###\n for account in self.accounts:\n source_account = source[source[t.account] == account]\n source_account = source_account.reset_index(drop=True)\n dateline=source_account[t.effective_date]\n ror=source_account[t.ror]/100\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\n # double_return_cum=round(double_return_cum,2)+1\n returns_cum = returns_cum + 1\n growth_amounts = returns_cum * self.starting_value\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\n round(growth_amounts, 2)\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\n 'series': l_cols}\n res['growth_of_unit'] = {'xAxis': list(dateline),\n 'series': r_lines}\n return res\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\n # return ret_dict","def calculate(self):\n\n return self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)","def metric(self, i1, i2):\n xx = self._try_cache(self.i2e[i1[0]])\n yy = self._try_cache(self.i2e[i2[0]])\n\n \"\"\"Don't need to cache the xy similarity because it doesn't have other uses\"\"\"\n xy = parasail.nw_stats(self.i2e[i1[0]], self.i2e[i2[0]], **self.paraParams).score\n\n D = xx + yy - 2 * xy\n return D","def compute_dsc(self, original, shrinked):\n for i in range(len(original)):\n x, y = original[i]\n orig = y-x\n\n a, b = shrinked[i]\n new = b-a\n\n dsc = float(new/orig)\n\n return dsc","def dset(self):\n\n a = 0.0\n b = 0.0\n sums = np.sum(self.descriptors, axis=0)\n for sum in sums:\n if sum > 0:\n if sum == self.d_length:\n b += 1.\n else:\n a += 1.\n return a / (a+b)","def compute(self) -> Any:\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n support=self.statistics[\"support\"],\n zero_division=self.zero_division,\n )\n return per_class, micro, macro, weighted","def calculateR(sapienses: list) -> float:\n r = 0\n for i in sapienses:\n r = r + i.numberInfected\n r=r/I0\n r = r*S/(S+R+D)\n return r","def _compute_recons_metrics(cls, quant_module: StaticGridQuantWrapper, act_func, inp_data: torch.Tensor,\n out_data: torch.Tensor) -> Tuple[float, float]:\n adaround_quantizer = quant_module.param_quantizers['weight']\n\n # Enable hard rounding and get quantized wrapper module's output\n adaround_quantizer.use_soft_rounding = False\n out_data_hard = cls._compute_output_with_adarounded_weights(quant_module, inp_data)\n\n # Enable soft rounding and get quantized wrapper module's output\n adaround_quantizer.use_soft_rounding = True\n out_data_soft = cls._compute_output_with_adarounded_weights(quant_module, inp_data)\n\n # If followed by an activation function\n if act_func is not None:\n out_data = act_func(out_data)\n out_data_soft = act_func(out_data_soft)\n out_data_hard = act_func(out_data_hard)\n\n recons_err_soft = functional.mse_loss(out_data_soft, out_data)\n recons_err_hard = functional.mse_loss(out_data_hard, out_data)\n\n return float(recons_err_hard), float(recons_err_soft)","def evaluate_de_res(de_res, de_genes, adj_p_cutoff=0.05):\n n_genes = de_res.shape[0]\n called_pos = np.logical_and(de_res['tested'], de_res['adjusted_p_value'] <= adj_p_cutoff)\n actual_pos = np.array([g in de_genes for g in xrange(n_genes)], dtype=bool)\n true_pos = np.logical_and(called_pos, actual_pos)\n sens = true_pos.sum().astype(float) / actual_pos.sum()\n ppv = true_pos.sum().astype(float) / called_pos.sum()\n\n return sens, ppv","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n n = self.confusion_matrix.n\n\n fn_tp = fn + tp\n fp_tp = fp + tp\n\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\n\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\n\n p00 = 1 if tn == 0 else (tn / n)\n p01 = 1 if fn == 0 else (fn / n)\n p10 = 1 if fp == 0 else (fp / n)\n p11 = 1 if tp == 0 else (tp / n)\n\n h12 = -((tn / n) * math.log2(p00) +\n (fn / n) * math.log2(p01) +\n (fp / n) * math.log2(p10) +\n (tp / n) * math.log2(p11))\n\n mi = h1 + h2 - h12\n return mi","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def get_fractional_degradation(bt):\n\n\n\n NomIch = 0.125 # Nominal charge current\n NomId = 0.25 # Nominal discharge current\n NomSoC = 0.5 # Nominal state of charge_mode\n NomDoD = 1.0 # Nominal depth of discharge\n B = 5 #Battery capacity\n qt = 5 * 0.5 # Amount of energy in the battery at the start\n # Determin charge of discharge\n if bt > 0:\n Id = bt/(B*1) # time interval differnece is 1\n Ich = NomIch\n else:\n Ich = bt/(B*1)\n Id = NomId\n\n #Calculate average State of Charge\n SoC = 100 * (qt - 0.5*bt)/B\n\n #Calculate Depth of Discharge\n DoD = 100 * bt /B\n\n # Functions\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\n nCL = nCL1 * nCL2 * nCL3\n Fractional_D = (0.5/3650)/ nCL\n return Fractional_D","def _calc_r2(self):\n sse = np.sum((self.data.y - self.predict(self.data.x))**2)\n sst = np.sum((self.data.y - self.data.y.mean())**2)\n return (1. - sse/sst)","def calc_metrics(self, data, output):\n\n L1NormITAE = self.calcL1NormITAE(data)\n L1NormAbs = self.calcL1NormAbs(data)\n #\n # print 'ITAE score: ', errorIntegral\n print 'L1NormITAE: ', L1NormITAE\n print 'L1NormAbs: ', L1NormAbs\n print '\\n'\n output.update({'L1NormITAE': L1NormITAE, 'L1NormAbs': L1NormAbs})","def _calculate_metrics(self):\n metrics = {}\n precision, recall = self.calc_precision_recall()\n metrics[\"precision\"] = precision\n metrics[\"recall\"] = recall\n metrics[\"entropy\"] = self.calc_entropy()\n metrics[\"component_entropy\"] = self.calc_component_entropy()\n metrics[\"num_comps\"] = len(self.get_components())\n metrics[\"num_diagnoses\"] = len(self.diagnoses)\n metrics[\"distinct_diagnoses_scores\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\n metrics[\"num_tests\"] = len(self.get_tests())\n metrics[\"num_distinct_traces\"] = len(self.get_distinct_traces())\n metrics[\"num_failed_tests\"] = len(self._get_tests_by_error(1))\n metrics[\"num_passed_tests\"] = len(self._get_tests_by_error(0))\n passed_comps = set(self._get_components_by_error(0))\n failed_comps = set(self.get_components_in_failed_tests())\n metrics[\"num_failed_comps\"] = len(failed_comps)\n metrics[\"only_failed_comps\"] = len(failed_comps - passed_comps)\n metrics[\"only_passed_comps\"] = len(passed_comps - failed_comps)\n metrics[\"num_bugs\"] = len(self.get_bugs())\n metrics[\"wasted\"] = self.calc_wasted_components()\n metrics[\"top_k\"] = self.calc_top_k()\n metrics[\"num_comps_in_diagnoses\"] = len(self._get_comps_in_diagnoses())\n metrics[\"bugs_cover_ratio\"] = self._get_bugs_cover_ratio()\n metrics[\"average_trace_size\"] = self._get_average_trace_size()\n metrics[\"average_component_activity\"] = self._get_average_component_activity()\n metrics[\"average_diagnosis_size\"] = self._get_average_diagnosis_size()\n metrics[\"bugs_scores_average\"], metrics[\"bugs_scores_std\"], metrics[\"bugs_scores_entropy\"] = self._get_bugs_scores()\n metrics[\"non_bugs_scores_average\"], metrics[\"non_bugs_scores_std\"], metrics[\"non_bugs_scores_entropy\"] = self._get_non_bugs_scores()\n metrics.update(self.cardinality())\n # metrics[\"ochiai\"] = self.calc_ochiai_values()\n return metrics","def calculate_batch_metrics(self):\n pass","def calc_metric3(K_tilda):\n trace = np.trace(K_tilda)\n # determinant = np.linalg.det(K_tilda)\n _, log_determinant = np.linalg.slogdet(K_tilda)\n diff = trace - log_determinant\n print(trace, log_determinant, diff)\n return diff","def evaluate(pred_file, ref_file):\n ref_dict, pred_dict, query_dict, id_dict = build_pred_ref_dict(ref_file, pred_file, ref_file)\n total, acc, scores = res_eval_with_type_acc(query_dict, pred_dict, ref_dict, id_dict, save=False)\n em = calculate_exact_match(pred_dict, ref_dict)\n print('Comp Acc: {:.3f}%\\tBleu-4: {:.3f}\\tRouge-L: {:.3f}'.format(acc, scores['Bleu-4'], scores['Rouge-L']))\n print('EM: {:.3f}%'.format(em))\n # calculate_sketch_type_acc(ref_file, pred_file)\n # calculate_exact_match_for_each_q_type(ref_file, pred_file)\n return total, acc, scores, em","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n n = self.confusion_matrix.n\n\n fp_tn = tn + fp\n tp_fn = fn + tp\n tn_fn = tn + fn\n tp_fp = fp + tp\n nis = tn_fn * tn_fn + tp_fp * tp_fp\n njs = fp_tn * fp_tn + tp_fn * tp_fn\n sum_of_squares = tp * tp + tn * tn + fp * fp + fn * fn\n\n a = (tp * (tp - 1) + fp * (fp - 1) + tn * (tn - 1) + fn * (fn - 1)) / 2.\n b = (njs - sum_of_squares) / 2.\n c = (nis - sum_of_squares) / 2.\n d = (n * n + sum_of_squares - nis - njs) / 2.\n\n x1 = a - ((a + c) * (a + b) / (a + b + c + d))\n x2 = ((a + c) + (a + b)) / 2.\n x3 = ((a + c) * (a + b)) / (a + b + c + d)\n denominator = x2 - x3\n\n if denominator != 0:\n return x1 / denominator\n else:\n return 0","def dc(self):\n return np.array(self['dc'], dtype=np.float32) / 1000","def precalculate():\n pass","def precalculate():\n pass","def _compute_metrics(hits_or_lcs: int, pred_len: int, target_len: int) ->Dict[str, Tensor]:\n precision = hits_or_lcs / pred_len\n recall = hits_or_lcs / target_len\n if precision == recall == 0.0:\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n fmeasure = 2 * precision * recall / (precision + recall)\n return dict(precision=tensor(precision), recall=tensor(recall), fmeasure=tensor(fmeasure))","def get_expected_cost(self):","def measure(self):\n return self._measure","def performace_measure(data,pred):\n true = data['clicks']\n weights = weighting(data)\n diff = true-pred.astype(int)\n return np.sqrt(np.inner(weights,diff*diff)/weights.sum())","def compute_key_value(self) -> Dict[str, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = self.compute()\n metrics = self._convert_metrics_to_kv(\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\n )\n return metrics","def calculate_metrics(self):\n sensitivity = TP + FN\n sensitivity = TP / sensitivity\n\n specificity = TN + FP\n specificity = TN / specificity\n\n accuracy = TP + FP + TN + FN\n divisor = TP + TN\n accuracy = divisor / accuracy\n\n positive_predictive = TP + FP\n positive_predictive = TP / positive_predictive\n\n negative_predictive = TN + FN\n negative_predictive = TN / negative_predictive\n\n # This is for format decimal in metrics\n sensitivity = float(\"{0:.4f}\".format(sensitivity))\n specificity = float(\"{0:.4f}\".format(specificity))\n accuracy = float(\"{0:.4f}\".format(accuracy))\n positive_predictive = float(\"{0:.4f}\".format(positive_predictive))\n negative_predictive = float(\"{0:.4f}\".format(negative_predictive))\n\n average = (sensitivity + specificity + accuracy + positive_predictive + negative_predictive) / 5\n\n average = float(\"{0:.4f}\".format(average))\n\n metrics = [sensitivity, specificity, accuracy,positive_predictive,negative_predictive, average]\n\n return metrics","def tldiffusion(self, dt):\n\n # Reset erosion, depo, trans and flux_in to 0\n self.erosion[:] = 0.0\n self.depo[:] = 0.0\n self.trans[:] = 0.0\n self.flux_in[:] = 0.0\n\n # Downstream steepest slope at node:\n self.steepest = self.grid.at_node[\"topographic__steepest_slope\"]\n # On each node, node ID of downstream receiver node\n # (on node (i), ID of node that receives flow from node (i)):\n self.receiver = self.grid.at_node[\"flow__receiver_node\"]\n\n dx = self.grid.dx\n cores = self.grid.core_nodes\n\n # Calculate influx rate on node i = outflux of nodes\n # whose receiver is i\n for i in self.grid.core_nodes:\n self.flux_in[self.receiver[i]] += self.flux_out[i]\n\n # Calculate transport coefficient\n # When S ~ Scrit, d_coeff is set to \"infinity\", for stability and\n # so that there is no deposition\n if self.steepest[i] >= self.slope_crit:\n self.d_coeff[i] = 1000000000.0\n else:\n self.d_coeff[i] = 1 / (\n 1 - (np.power(((self.steepest[i]) / self.slope_crit), 2))\n )\n\n # Calculate deposition rate on node\n self.depo[cores] = self.flux_in[cores] / self.d_coeff[cores]\n\n # Calculate erosion rate on node (positive value)\n # If S > Scrit, erosion is simply set for the slope to return to Scrit\n # Otherwise, erosion is slope times erodibility coefficent\n for i in self.grid.core_nodes:\n if self.steepest[i] > self.slope_crit:\n self.erosion[i] = dx * (self.steepest[i] - self.slope_crit) / (100 * dt)\n else:\n self.erosion[i] = self.k * self.steepest[i]\n\n # Update elevation\n self.elev[i] += (-self.erosion[i] + self.depo[i]) * dt\n\n # Calculate transfer rate over node\n self.trans[cores] = self.flux_in[cores] - self.depo[cores]\n\n # Calculate outflux rate\n self.flux_out[:] = self.erosion + self.trans","def DW_cal(data, data_sm):\n n = len(data)\n numerator = 0\n denominator = 0\n for i in range(n):\n if i == 0:\n numerator = numerator + 0\n else:\n numerator = numerator + ((data[i] - data_sm[i]) - (data[i-1] - data_sm[i-1]))**2\n denominator = denominator + (data[i] - data_sm[i])**2\n return numerator/denominator*n/(n - 1)","def computePRMeasures(self, targetLabels, actualLabels):\r\n if self.basicMeasures is None:\r\n self.basicMeasures = self.computeBasicStatistics(targetLabels, actualLabels)\r\n if self.basicMeasures[0] == 0:\r\n self.prMeasures = (0,0)\r\n else:\r\n self.prMeasures = ((0.0 + self.basicMeasures[0]) / (self.basicMeasures[0] + self.basicMeasures[1]),\r\n (0.0 + self.basicMeasures[0]) / (self.basicMeasures[0] + self.basicMeasures[3]))\r\n return self.prMeasures","def test_calculate_supervisory_delta_call(self):\n SDC = calculate_supervisory_delta_call()\n \n self.assertEqual(SDC, 0.73)","def _df_reg(self):\n return self.k"],"string":"[\n \"def compute_metrics(self):\\n pass\",\n \"def calculate(self) -> float:\",\n \"def calculate(self):\",\n \"def calculate_dataset_metrics(self):\\n pass\",\n \"def calculateDataRate(self):\\n pass\",\n \"def getMeasures():\",\n \"def denominator(self, ???):\",\n \"def calculate(self):\\r\\n\\r\\n pass\",\n \"def calculate(self):\\r\\n pass\",\n \"def compute_statistics(self):\",\n \"def measure(self, recommender):\",\n \"def _core_calc_degrad(self,bd,Ld) :\\n\\t\\tdegrad = np.dot(Ld,bd) # Do matrix multiplication \\n\\t\\tdegrad = np.exp(degrad) # Exponentiate to convert log to real\\n\\t\\treturn degrad\",\n \"def get_metric(self) -> GreedyDiarizationErrorRate:\\n return GreedyDiarizationErrorRate(collar=0.0, skip_overlap=False)\",\n \"def cost(self) -> float:\",\n \"def calculate(self):\\n pass\",\n \"def metric(x,y):\\n sm = x + y\\n df = x - y\\n div = sm / df if df != 0 else 0\\n return \\\"sum is %s \\\" %sm, \\\"difference is %s \\\" %df, \\\"division of difference to sum is %s\\\" %div\",\n \"def measure(self):\\n pass\",\n \"def _get_eval_metric(self):\\n raise NotImplementedError\",\n \"def get_metric(self, data_row: pd.Series) -> float:\",\n \"def calc(self):\\n return None\",\n \"def compute(self) -> Tuple[float, float, float]:\\n # ddp hotfix, could be done better\\n # but metric must handle DDP on it's own\\n if self._ddp_backend == \\\"xla\\\":\\n self.statistics = {\\n k: xm.mesh_reduce(k, v, np.sum) for k, v in self.statistics.items()\\n }\\n elif self._ddp_backend == \\\"ddp\\\":\\n for key in self.statistics:\\n value: List[int] = all_gather(self.statistics[key])\\n value: int = sum(value)\\n self.statistics[key] = value\\n\\n precision_value, recall_value, f1_value = get_binary_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n zero_division=self.zero_division,\\n )\\n return precision_value, recall_value, f1_value\",\n \"def metric(self, eles):\\n point = eles.pop()\\n dist = edist(point, self.soln)\\n return dist\",\n \"def compute(self) -> Any:\\n # ddp hotfix, could be done better\\n # but metric must handle DDP on it's own\\n if self._ddp_backend == \\\"xla\\\":\\n device = get_device()\\n for key in self.statistics:\\n key_statistics = torch.tensor([self.statistics[key]], device=device)\\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\\n self.statistics[key] = key_statistics\\n elif self._ddp_backend == \\\"ddp\\\":\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n support=self.statistics[\\\"support\\\"],\\n zero_division=self.zero_division,\\n )\\n if self.compute_per_class_metrics:\\n return per_class, micro, macro, weighted\\n else:\\n return [], micro, macro, weighted\",\n \"def compute(self) -> Any:\\n # ddp hotfix, could be done better\\n # but metric must handle DDP on it's own\\n if self._ddp_backend == \\\"xla\\\":\\n device = get_device()\\n for key in self.statistics:\\n key_statistics = torch.tensor([self.statistics[key]], device=device)\\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\\n self.statistics[key] = key_statistics\\n elif self._ddp_backend == \\\"ddp\\\":\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n support=self.statistics[\\\"support\\\"],\\n zero_division=self.zero_division,\\n )\\n if self.compute_per_class_metrics:\\n return per_class, micro, macro, weighted\\n else:\\n return [], micro, macro, weighted\",\n \"def metric(x, y):\\n d = x - y\\n s = x + y\\n print('difference is %g, sum is %g' % (d, s))\\n if s == 0:\\n return 0\\n return d / s\",\n \"def calc_stat_values(self):\",\n \"def _compute_rmse(self, data):\\n actual = data.rating.values\\n pred = self._predict_all(data)\\n rmse = np.sqrt(np.sum((actual - pred) **2) /len(pred))\\n return rmse\",\n \"def make_metrics(self):\\n num_batches = self.data_loader.number_of_batches()\\n dose_score_vec = np.zeros(num_batches)\\n\\n # Only make calculations if data_loader is not empty\\n if not self.data_loader.file_paths_list:\\n print('No patient information was given to calculate metrics')\\n else:\\n # Change batch size to 1\\n self.data_loader.batch_size = 1 # Loads data related to ground truth patient information\\n if self.dose_loader is not None:\\n self.dose_loader.batch_size = 1 # Loads data related to ground truth patient information\\n\\n for idx in tqdm.tqdm(range(num_batches)):\\n # Get roi masks for patient\\n self.get_constant_patient_features(idx)\\n # Get dose tensors for reference dose and evaluate criteria\\n reference_dose = self.get_patient_dose_tensor(self.data_loader)\\n if reference_dose is not None:\\n self.reference_dose_metric_df = self.calculate_metrics(self.reference_dose_metric_df, reference_dose)\\n # If a dose loader was provided, calculate the score\\n if self.dose_loader is not None:\\n new_dose = self.get_patient_dose_tensor(self.dose_loader)\\n # Make metric data frames\\n self.new_dose_metric_df = self.calculate_metrics(self.new_dose_metric_df, new_dose)\\n # Evaluate mean absolute error of 3D dose\\n dose_score_vec[idx] = np.sum(np.abs(reference_dose - new_dose)) / np.sum(self.possible_dose_mask)\\n # Save metrics at the patient level (this is a template for how DVH stream participants could save\\n # their files\\n # self.dose_metric_df.loc[self.patient_list[0]].to_csv('{}.csv'.format(self.patient_list[0]))\\n\\n if self.dose_loader is not None:\\n dvh_score = np.nanmean(np.abs(self.reference_dose_metric_df - self.new_dose_metric_df).values)\\n dose_score = dose_score_vec.mean()\\n return dvh_score, dose_score\\n else:\\n print('No new dose provided. Metrics were only calculated for the provided dose.')\",\n \"def calculate(self):\\n\\n beta = 1 # or 0.5 or 2 can also calculate F2 or F0.5 measure\\n\\n beta_squared = beta * beta\\n precision = Precision()\\n precision.confusion_matrix = self.confusion_matrix\\n precision = precision.calculate()\\n recall = Recall()\\n recall.confusion_matrix = self.confusion_matrix\\n recall = recall.calculate()\\n\\n denominator = beta_squared * precision + recall\\n\\n if denominator != 0:\\n return (1 + beta_squared) * ((precision * recall) / denominator)\\n else:\\n return 0\",\n \"def calculate_output(self):\",\n \"def accuracy(self):\",\n \"def advancedStats():\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n return tp / (tp + fp + fn)\",\n \"def eval_error_metric(predt, dtrain: xgb.DMatrix):\\n label = dtrain.get_label()\\n r = np.zeros(predt.shape)\\n gt = predt > 0.5\\n if predt.size == 0:\\n return \\\"CustomErr\\\", 0\\n r[gt] = 1 - label[gt]\\n le = predt <= 0.5\\n r[le] = label[le]\\n return 'CustomErr', np.sum(r)\",\n \"def calc_reduction_diesel_used (self):\\n self.reduction_diesel_used = self.diesel_equiv_captured - \\\\\\n self.loss_heat_recovery\\n #~ print 'self.reduction_diesel_used',self.reduction_diesel_used\",\n \"def rmdspe(self) -> float:\\n return float(np.sqrt(np.median(np.square(self._percentage_error()))) * 100.0)\",\n \"def getMeasure(unique_name):\",\n \"def getMeasure(unique_name):\",\n \"def compute(self) -> Tuple[float, float, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[float] = all_gather(self.statistics[key])\\n value: float = sum(value)\\n self.statistics[key] = value\\n\\n precision_value, recall_value, f1_value = get_binary_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n zero_division=self.zero_division,\\n )\\n return precision_value, recall_value, f1_value\",\n \"def calc_D(state):\\n\\t\\tif t < thresh:\\n\\t\\t\\tstate.D_g[t] = 0.5\\n\\t\\t\\tstate.D_n[t] = 0.5\\n\\t\\telse:\\n\\t\\t\\tif mod == \\\"constant\\\":\\n\\t\\t\\t\\tstate.D_g[t] = D\\n\\t\\t\\t\\tstate.D_n[t] = 1-D\\n\\t\\t\\tif mod == \\\"value\\\":\\n\\t\\t\\t\\t# NOTE: if rmag and lmag is 1/0, can just use V\\n\\t\\t\\t\\t# average of two actions\\n\\t\\t\\t\\tV = np.mean(1/2*(state.QG[t,:] - state.QN[t,:])) # state average(?) \\n\\t\\t\\t\\tV = 1/(1 + np.exp(-V*k)) # translate between 0 and 1\\n\\t\\t\\t\\tstate.D_g[t] = V \\n\\t\\t\\t\\tstate.D_n[t] = 1 - V\\n\\t\\treturn state\",\n \"def patrimony_total(self):\\n pass\",\n \"def dfr(self):\\n return self.table[1, 0] / (self.table[1, 0] + self.table[1, 1])\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n return 1 - abs(fn - fp) / (2 * tp + fn + fp)\",\n \"def cost_derivative(self,output_results,y):\\r\\n\\t\\treturn (output_results-y)\",\n \"def compute_metric(inargs, exp_id, date):\\n date_str = h.dt_to_yyyymmddhhmmss(date)\\n fg_str = '_da' if inargs.fg else ''\\n\\n # Load presaved forecast data\\n if exp_id in ['ey', 'rw']: # Make an exception for radar as exp_id\\n radar_fn = (config.savedir_base + exp_id + '/prec_fields/' + exp_id +\\n '_' + date_str + '.npy')\\n fc_data = np.load(radar_fn)\\n else:\\n fc_fn = (config.savedir_base + exp_id + '/' +\\n config.metric_dict[inargs.metric.split('-')[0]]['var'] +\\n '_fields/' +\\n config.metric_dict[inargs.metric.split('-')[0]]['det_or_ens'] +\\n fg_str + '_' + date_str + '.npy')\\n fc_data = np.load(fc_fn)\\n\\n if config.metric_dict[inargs.metric.split('-')[0]]['use_radar']:\\n # Load presaved radar data\\n radar_fn = (config.savedir_base + inargs.radar_comp + '/prec_fields/' +\\n inargs.radar_comp + '_' + date_str + '.npy')\\n radar_data = np.load(radar_fn)\\n if inargs.combine_masks is not None:\\n comb_fn = (config.savedir_base + inargs.combine_masks +\\n '/prec_fields/' + inargs.combine_masks + '_' +\\n date_str + '.npy')\\n comb_data = np.load(comb_fn)\\n else:\\n comb_data = None\\n radar_data, fc_data = h.handle_nans(radar_data, fc_data,\\n inargs.radar_thresh,\\n comb_data)\\n\\n if not inargs.upscale == 1:\\n fc_data = h.upscale_fields(fc_data, inargs.upscale)\\n if 'radar_data' in locals():\\n radar_data = h.upscale_fields(radar_data, inargs.upscale)\\n\\n # Pass data to computation functions\\n if inargs.metric in ['det_mean_prec', 'det_mean_cape', 'det_mean_cin']:\\n m = h.compute_det_domain_mean(fc_data)\\n elif inargs.metric in ['det_median_prec', 'det_median_cape',\\n 'det_median_cin']:\\n m = h.compute_det_domain_median(fc_data)\\n elif inargs.metric == 'det_rmse':\\n m = h.compute_det_rmse(radar_data, fc_data)\\n elif 'det_sal' in inargs.metric:\\n _, sal_thresh = inargs.metric.split('-')\\n sal_thresh = float(sal_thresh) / 10.\\n m = h.compute_det_sal(radar_data, fc_data, sal_thresh)\\n elif 'det_fss' in inargs.metric:\\n # Parse\\n _, fss_thresh, fss_size = inargs.metric.split('-')\\n fss_thresh = float(fss_thresh) / 10.\\n fss_size = int(fss_size)\\n # Update dictionary NOTE: This doesn't seem to work\\n # config.metric_dict[inargs.metric.split('-')[0]]['ylabel'] = \\\\\\n # 'FSS ' + str(fss_thresh) + 'mm/h ' + str(fss_size * 2.8) + 'km'\\n m = h.compute_det_fss(radar_data, fc_data, fss_thresh, fss_size)\\n elif inargs.metric == 'det_prec_hist':\\n m = h.compute_det_prec_hist(fc_data)\\n elif inargs.metric == 'ens_rmse':\\n m = h.compute_ens_rmse(radar_data, fc_data)\\n elif inargs.metric == 'ens_rmv':\\n m = h.compute_ens_rmv(fc_data)\\n elif inargs.metric == 'ens_crps':\\n m = h.compute_ens_crps(radar_data, fc_data)\\n elif 'ens_bs' in inargs.metric:\\n # Parse\\n s = inargs.metric.split('-')\\n _, bs_thresh, bs_size = s\\n bs_size = int(bs_size)\\n bs_thresh = float(bs_thresh) / 10.\\n # Update dictionary\\n # config.metric_dict[inargs.metric.split('-')[0]]['ylabel'] = \\\\\\n # 'BS ' + str(bs_thresh) + 'mm/h '\\n m = h.compute_ens_bs(radar_data, fc_data, bs_thresh, bs_size)\\n else:\\n raise ValueError('Metric %s does not exist.' % inargs.metric)\\n\\n return m\",\n \"def performance_measure(self, x):\\n # \\\"calculate performance measure\\\" \\n pref = x.evaluate()\\n return pref\",\n \"def evaluate(self):\\n\\n if self.opt['AccurateDFid']:\\n DX = self.reconstruct()\\n S = self.xstep.S\\n dfd = (np.linalg.norm(self.xstep.W * (DX - S))**2) / 2.0\\n if self.xmethod == 'fista':\\n X = self.xstep.getcoef()\\n else:\\n X = self.xstep.var_y1()\\n rl1 = np.sum(np.abs(X))\\n return dict(DFid=dfd, RegL1=rl1,\\n ObjFun=dfd + self.xstep.lmbda * rl1)\\n else:\\n return None\",\n \"def calculate_metrics(self):\\n \\n for cv in self.cat_vals:\\n cat_inds = np.where(self.category_values == cv)[0]\\n weighted_difference = (self.z[cat_inds]-self.mz[cat_inds])/self.weight_values[cat_inds]\\n resid = np.sqrt(np.sum(np.square(weighted_difference))/(cat_inds.size))\\n self.metric[str(cv)] = resid\\n \\n return self.metric\",\n \"def diarisationMetrics(reference, hypothesis, audioLength, collar_val = 0.5):\\r\\n with warnings.catch_warnings():\\r\\n warnings.simplefilter(\\\"ignore\\\")\\r\\n\\r\\n metrics = {}\\r\\n # for collar, skip_overlap, expName in [(0.0, False, 'NoCollarOverlap'),(collar_val, False, 'CollarOverlap'), (0.0, True, 'NoCollarNoOverlap'), (collar_val, True, 'CollarNoOverlap')]:\\r\\n for collar, skip_overlap, expName in [(collar_val, False, 'CollarOverlap'), (collar_val, True, 'CollarNoOverlap')]:\\r\\n diarizationErrorRate = DiarizationErrorRate(collar=collar, skip_overlap=skip_overlap)\\r\\n jaccardErrorRate = JaccardErrorRate(collar=collar, skip_overlap=skip_overlap)\\r\\n purity = DiarizationPurity(collar=collar, skip_overlap=skip_overlap)\\r\\n coverage = DiarizationCoverage(collar=collar, skip_overlap=skip_overlap)\\r\\n detectionAccuracy = DetectionAccuracy(collar=collar, skip_overlap=skip_overlap)\\r\\n\\r\\n print('*'*10, 'Collar: {}ms Skip Overlap: {}'.format(collar, skip_overlap), '*'*10)\\r\\n print(\\\"DER = {0:.5f}\\\".format(diarizationErrorRate(reference, hypothesis, uem=Segment(0, audioLength))))\\r\\n print(\\\"JER = {0:.5f}\\\".format(jaccardErrorRate(reference, hypothesis, uem=Segment(0, audioLength))))\\r\\n print(\\\"Optimal mapping = {}\\\".format(diarizationErrorRate.optimal_mapping(reference, hypothesis)))\\r\\n print(\\\"Purity = {0:.5f}\\\".format(purity(reference, hypothesis, uem=Segment(0, audioLength))))\\r\\n print(\\\"Coverage = {0:.5f}\\\".format(coverage(reference, hypothesis, uem=Segment(0, audioLength))))\\r\\n dtAcc = detectionAccuracy.compute_components(reference, hypothesis)\\r\\n # print(\\\"Detection Accuracy: FN = {:.5f}, FP = {:.5f}, TN = {:.5f}, TP = {:.5f}\\\\n\\\".format(dtAcc['false negative'],dtAcc['false positive'],dtAcc['true negative'],dtAcc['true positive']))\\r\\n\\r\\n metrics[expName]={}\\r\\n\\r\\n keys = ['DER','JER', 'mapping', 'purity', 'coverage', 'detectionAccuracy']\\r\\n values = diarizationErrorRate(reference, hypothesis, detailed=True, uem=Segment(0, audioLength)),\\\\\\r\\n jaccardErrorRate(reference, hypothesis, detailed=True, uem=Segment(0, audioLength)),\\\\\\r\\n diarizationErrorRate.optimal_mapping(reference, hypothesis),\\\\\\r\\n purity(reference, hypothesis, uem=Segment(0, audioLength)),\\\\\\r\\n coverage(reference, hypothesis, uem=Segment(0, audioLength)),\\\\\\r\\n detectionAccuracy.compute_components(reference, hypothesis)\\r\\n\\r\\n metrics[expName] = dict(zip(keys, list(values)))\\r\\n metrics = edict(metrics)\\r\\n return metrics\",\n \"def __dmr_analysis(self, debug=False):\\n global hfAdcRange, adcCountRange\\n if self.buffer is None or len(self.buffer) != self.bufsize:\\n self.set_eval_error(f'Data length ({len(self.buffer)}) differs from expected ({self.bufsize})')\\n return None\\n\\n It = self.buffer[:self.bufsize//2]\\n Qt = self.buffer[self.bufsize//2:]\\n\\n self.results['ADC_I'] = hfAdcRange * (It * 2 / adcCountRange - 1)\\n self.results['ADC_Q'] = hfAdcRange * (Qt * 2 / adcCountRange - 1)\\n\\n # subtract the DC component and convert to int32\\n It = np.around(It-np.mean(It)).astype('int32')\\n Qt = np.around(Qt-np.mean(Qt)).astype('int32')\\n\\n # find the bit error rate and constant symbol intervals\\n maxlen = 20*200 # max length of returned Iref, Qref\\n numerr, numbit, Iref, Qref, symlenref = get_ber(It, Qt, maxlen)\\n\\n if numerr is None or numbit is None:\\n self.set_eval_error(f'Too small data length - {len(self.buffer)}')\\n return None\\n\\n ber = numerr/numbit\\n\\n return ber\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def compute_metric(df, preds):\\n\\n y = np.array(df['pressure'].values.tolist())\\n\\n # inspiratory phase\\n mask = 1 - np.array(df['u_out'].values.tolist())\\n\\n # combine with mae calculusse\\n mae = mask * np.abs(y - preds)\\n mae = mae.sum() / mask.sum()\\n\\n return mae\",\n \"def calculate(self):\\n\\n specificity = self.confusion_matrix.tn / (self.confusion_matrix.tn + self.confusion_matrix.fp)\\n\\n false_positive_rate = 1 - specificity\\n\\n true_positive_rate = self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\\n\\n return (true_positive_rate - false_positive_rate + 1) / 2\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n n = self.confusion_matrix.n\\n\\n fn_tp = fn + tp\\n fp_tp = fp + tp\\n\\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\\n\\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\\n\\n p00 = 1 if tn == 0 else (tn / n)\\n p01 = 1 if fn == 0 else (fn / n)\\n p10 = 1 if fp == 0 else (fp / n)\\n p11 = 1 if tp == 0 else (tp / n)\\n\\n h12 = -((tn / n) * math.log2(p00) +\\n (fn / n) * math.log2(p01) +\\n (fp / n) * math.log2(p10) +\\n (tp / n) * math.log2(p11))\\n\\n mi = h1 + h2 - h12\\n\\n vi = h1 + h2 - 2 * mi\\n return vi\",\n \"def _derivativeTerm(self):\\n\\n\\t\\treturn self._Kd * (self._getErrorFunction() - self._previousError) / self._dt\",\n \"def calculations():\\r\\n\\t\\r\\n\\tpayload, avionics, booster = weight_input()\\r\\n\\r\\n\\tdrogue_size, drogue_force = drogue_calc()\\r\\n\\tmain_size, main_force = main_calc(avionics, booster, drogue_force) #total mass, payload detaches\\r\\n\\r\\n\\tprint(\\\"Drogue is diameter is \\\" + str(drogue_size) + \\\" inches\\\")\\r\\n\\tprint(\\\"Main is diameter is \\\" + str(main_size) + \\\" inches\\\")\",\n \"def compute_metrics(mat,language='English',method ='dimensional',output='data_frame'):\\n language = language.lower()\\n method = method.lower()\\n if language == 'english':\\n if method == 'dimensional':\\n if output == 'data_frame':\\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \\n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \\n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\\n return(mat)\\n elif output == 'array':\\n out_dict = {}\\n out_dict['PosVal'] = mat[:,:,0]\\n out_dict['NegVal'] = mat[:,:,1]\\n out_dict['Arousal'] = mat[:,:,2]\\n out_dict['Dominance'] = mat[:,:,3]\\n out_dict['PosCount'] = mat[:,:,4]\\n out_dict['DetectCount'] = mat[:,:,5]\\n out_dict['TokenCount'] = mat[:,:,6]\\n out_dict['ValSq'] = mat[:,:,7]\\n\\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\\n # Mean Values:\\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DetectCount'])\\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\\n # Percentages:\\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\")\\n elif method == 'discrete':\\n if output == 'data_frame':\\n mat['function_Percent'] = mat.function / mat.TokenCount\\n mat['pronoun_Percent'] = mat.pronoun / mat.TokenCount\\n mat['ppron_Percent'] = mat.ppron / mat.TokenCount\\n mat['i_Percent'] = mat.i / mat.TokenCount\\n mat['we_Percent'] = mat.we / mat.TokenCount\\n mat['you_Percent'] = mat.you / mat.TokenCount\\n mat['shehe_Percent'] = mat.shehe / mat.TokenCount\\n mat['they_Percent'] = mat.they / mat.TokenCount\\n mat['ipron_Percent'] = mat.ipron / mat.TokenCount\\n mat['article_Percent'] = mat.article / mat.TokenCount\\n mat['prep_Percent'] = mat.prep / mat.TokenCount\\n mat['auxverb_Percent'] = mat.auxverb / mat.TokenCount\\n mat['adverb_Percent'] = mat.adverb / mat.TokenCount\\n mat['conj_Percent'] = mat.conj / mat.TokenCount\\n mat['negate_Percent'] = mat.negate / mat.TokenCount\\n mat['verb_Percent'] = mat.verb / mat.TokenCount\\n mat['adj_Percent'] = mat.adj / mat.TokenCount\\n mat['compare_Percent'] = mat.compare / mat.TokenCount\\n mat['interrog_Percent'] = mat.interrog / mat.TokenCount\\n mat['number_Percent'] = mat.number / mat.TokenCount\\n mat['quant_Percent'] = mat.quant / mat.TokenCount\\n mat['affect_Percent'] = mat.affect / mat.TokenCount\\n mat['posemo_Percent'] = mat.posemo / mat.TokenCount\\n mat['negemo_Percent'] = mat.negemo / mat.TokenCount\\n mat['anx_Percent'] = mat.anx / mat.TokenCount\\n mat['anger_Percent'] = mat.anger / mat.TokenCount\\n mat['sad_Percent'] = mat.sad / mat.TokenCount\\n mat['social_Percent'] = mat.social / mat.TokenCount\\n mat['family_Percent'] = mat.family / mat.TokenCount\\n mat['friend_Percent'] = mat.friend / mat.TokenCount\\n mat['female_Percent'] = mat.female / mat.TokenCount\\n mat['male_Percent'] = mat.male / mat.TokenCount\\n mat['cogproc_Percent'] = mat.cogproc / mat.TokenCount\\n mat['insight_Percent'] = mat.insight / mat.TokenCount\\n mat['cause_Percent'] = mat.cause / mat.TokenCount\\n mat['discrep_Percent'] = mat.discrep / mat.TokenCount\\n mat['tentat_Percent'] = mat.tentat / mat.TokenCount\\n mat['certain_Percent'] = mat.certain / mat.TokenCount\\n mat['differ_Percent'] = mat.differ / mat.TokenCount\\n mat['percept_Percent'] = mat.percept / mat.TokenCount\\n mat['see_Percent'] = mat.see / mat.TokenCount\\n mat['hear_Percent'] = mat.hear / mat.TokenCount\\n mat['feel_Percent'] = mat.feel / mat.TokenCount\\n mat['bio_Percent'] = mat.bio / mat.TokenCount\\n mat['body_Percent'] = mat.body / mat.TokenCount\\n mat['health_Percent'] = mat.health / mat.TokenCount\\n mat['sexual_Percent'] = mat.sexual / mat.TokenCount\\n mat['ingest_Percent'] = mat.ingest / mat.TokenCount\\n mat['drives_Percent'] = mat.drives / mat.TokenCount\\n mat['affiliation_Percent'] = mat.affiliation / mat.TokenCount\\n mat['achieve_Percent'] = mat.achieve / mat.TokenCount\\n mat['power_Percent'] = mat.power / mat.TokenCount\\n mat['reward_Percent'] = mat.reward / mat.TokenCount\\n mat['risk_Percent'] = mat.risk / mat.TokenCount\\n mat['focuspast_Percent'] = mat.focuspast / mat.TokenCount\\n mat['focuspresent_Percent'] = mat.focuspresent / mat.TokenCount\\n mat['focusfuture_Percent'] = mat.focusfuture / mat.TokenCount\\n mat['relativ_Percent'] = mat.relativ / mat.TokenCount\\n mat['motion_Percent'] = mat.motion / mat.TokenCount\\n mat['space_Percent'] = mat.space / mat.TokenCount\\n mat['time_Percent'] = mat.time / mat.TokenCount\\n mat['work_Percent'] = mat.work / mat.TokenCount\\n mat['leisure_Percent'] = mat.leisure / mat.TokenCount\\n mat['home_Percent'] = mat.home / mat.TokenCount\\n mat['money_Percent'] = mat.money / mat.TokenCount\\n mat['relig_Percent'] = mat.relig / mat.TokenCount\\n mat['death_Percent'] = mat.death / mat.TokenCount\\n mat['informal_Percent'] = mat.informal / mat.TokenCount\\n mat['swear_Percent'] = mat.swear / mat.TokenCount\\n mat['netspeak_Percent'] = mat.netspeak / mat.TokenCount\\n mat['assent_Percent'] = mat.assent / mat.TokenCount\\n mat['nonflu_Percent'] = mat.nonflu / mat.TokenCount\\n mat['filler_Percent'] = mat.filler / mat.TokenCount\\n mat['Detect_Percent'] = mat.DetectCount / mat.TokenCount\\n return(mat)\\n elif output == 'array':\\n out_dict = {}\\n out_dict['Affect'] = mat[:,:,21]\\n out_dict['Posemo'] = mat[:,:,22]\\n out_dict['Negemo'] = mat[:,:,23]\\n out_dict['Anx'] = mat[:,:,24]\\n out_dict['Anger'] = mat[:,:,25]\\n out_dict['Sad'] = mat[:,:,26]\\n out_dict['Function'] = mat[:,:,0]\\n out_dict['CogProc'] = mat[:,:,32]\\n out_dict['DetectCount'] = mat[:,:,-2]\\n out_dict['TokenCount'] = mat[:,:,-1]\\n\\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\\n\\n\\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\") \\n else:\\n print(\\\"Error: Method not found!\\\")\\n elif language == 'german':\\n if method == 'dimensional':\\n if output == 'data_frame':\\n mat['NegCount'] = mat['DetectCount'] - mat['PosCount']\\n mat['MeanNegVal'] = mat['NegVal'] / mat['NegCount']\\n mat['MeanPosVal'] = mat['PosVal'] / mat['PosCount']\\n mat['MeanArousal'] = mat['Arousal'] / mat['DetectCount']\\n mat['MeanDominance'] = mat['Dominance'] / mat['DetectCount']\\n mat['MeanPotency'] = mat['Potency'] / mat['DetectCount']\\n mat['PosNegValDifference'] = mat['MeanPosVal'] - mat['MeanNegVal']\\n mat['MeanValence'] = (mat['NegVal'] + mat['PosVal'])/ mat['DetectCount'] \\n mat['AbsMeanNegVal'] = abs(mat['MeanNegVal'])\\n mat['DetectPercent'] = mat['DetectCount'] / mat['TokenCount']\\n mat['DensityValence'] =(mat['NegVal'] + mat['PosVal'])/ mat['TokenCount'] \\n mat['DensityNegVal'] = mat['NegVal'] / mat['TokenCount']\\n mat['DensityPosVal'] = mat['PosVal'] / mat['TokenCount']\\n mat['DensityArousal'] = mat['Arousal'] / mat['TokenCount']\\n mat['DensityDominance'] = mat['Dominance'] / mat['TokenCount']\\n mat['MeanSquaredValence'] = mat['ValSq'] / mat['DetectCount']\\n mat['ValenceDeviation'] = np.sqrt(mat['MeanSquaredValence'])\\n return(mat)\\n elif output == 'array':\\n out_dict = {}\\n out_dict['PosVal'] = mat[:,:,0]\\n out_dict['NegVal'] = mat[:,:,1]\\n out_dict['Arousal'] = mat[:,:,2]\\n out_dict['Dominance'] = mat[:,:,3]\\n out_dict['PosCount'] = mat[:,:,4]\\n out_dict['DetectCount'] = mat[:,:,5]\\n out_dict['Imagine'] = mat[:,:,6]\\n out_dict['Potency'] = mat[:,:,7]\\n out_dict['DomPot_Count'] = mat[:,:,8]\\n out_dict['TokenCount'] = mat[:,:,9]\\n out_dict['ValSq'] = mat[:,:,10]\\n\\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'],out_dict['TokenCount'])\\n out_dict['NegCount'] = np.subtract(out_dict['DetectCount'],out_dict['PosCount'])\\n # Mean Values:\\n out_dict['MeanValence'] = np.divide(np.add(out_dict['PosVal'],out_dict['NegVal']),out_dict['DetectCount'])\\n out_dict['MeanNegVal'] = np.divide(out_dict['NegVal'],out_dict['NegCount'])\\n out_dict['MeanPosVal'] = np.divide(out_dict['PosVal'],out_dict['PosCount'])\\n out_dict['MeanArousal'] = np.divide(out_dict['Arousal'],out_dict['DetectCount'])\\n out_dict['MeanDominance'] = np.divide(out_dict['Dominance'],out_dict['DomPot_Count'])\\n out_dict['MeanPotency'] = np.divide(out_dict['Potency'],out_dict['DomPot_Count'])\\n out_dict['PosNegValDifference'] = np.subtract(out_dict['MeanPosVal'] ,out_dict['MeanNegVal'])\\n # Percentages:\\n out_dict['DetectPosPercent'] = np.divide(out_dict['PosCount'],out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['PosCount'],out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['NegCount'],out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['NegCount'],out_dict['TokenCount'])\\n out_dict['MeanSquaredValence'] = np.divide(out_dict['ValSq'],out_dict['DetectCount'])\\n out_dict['ValenceDeviation'] = np.sqrt(out_dict['MeanSquaredValence'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\")\\n elif method == 'discrete':\\n if output == 'data_frame':\\n mat['Pronoun_Percent'] = mat.Pronoun / mat.TokenCount\\n mat['I_Percent'] = mat.I / mat.TokenCount\\n mat['We_Percent'] = mat.We / mat.TokenCount\\n mat['Self_Percent'] = mat.Self / mat.TokenCount\\n mat['You_Percent'] = mat.You / mat.TokenCount\\n mat['Other_Percent'] = mat.Other / mat.TokenCount\\n mat['Negate_Percent'] = mat.Negate / mat.TokenCount\\n mat['Assent_Percent'] = mat.Assent / mat.TokenCount\\n mat['Article_Percent'] = mat.Article / mat.TokenCount\\n mat['Preps_Percent'] = mat.Preps / mat.TokenCount\\n mat['Number_Percent'] = mat.Number / mat.TokenCount\\n mat['Affect_Percent'] = mat.Affect / mat.TokenCount\\n mat['Posemo_Percent'] = mat.Posemo / mat.TokenCount\\n mat['Posfeel_Percent'] = mat.Posfeel / mat.TokenCount\\n mat['Optim_Percent'] = mat.Optim / mat.TokenCount\\n mat['Negemo_Percent'] = mat.Negemo / mat.TokenCount\\n mat['Anx_Percent'] = mat.Anx / mat.TokenCount\\n mat['Anger_Percent'] = mat.Anger / mat.TokenCount\\n mat['Sad_Percent'] = mat.Sad / mat.TokenCount\\n mat['Cogmech_Percent'] = mat.Cogmech / mat.TokenCount\\n mat['Cause_Percent'] = mat.Cause / mat.TokenCount\\n mat['Insight_Percent'] = mat.Insight / mat.TokenCount\\n mat['Discrep_Percent'] = mat.Discrep / mat.TokenCount\\n mat['Inhib_Percent'] = mat.Inhib / mat.TokenCount\\n mat['Tentat_Percent'] = mat.Tentat / mat.TokenCount\\n mat['Certain_Percent'] = mat.Certain / mat.TokenCount\\n mat['Senses_Percent'] = mat.Senses / mat.TokenCount\\n mat['See_Percent'] = mat.See / mat.TokenCount\\n mat['Hear_Percent'] = mat.Hear / mat.TokenCount\\n mat['Feel_Percent'] = mat.Feel / mat.TokenCount\\n mat['Social_Percent'] = mat.Social / mat.TokenCount\\n mat['Comm_Percent'] = mat.Comm / mat.TokenCount\\n mat['Othref_Percent'] = mat.Othref / mat.TokenCount\\n mat['Friends_Percent'] = mat.Friends / mat.TokenCount\\n mat['Family_Percent'] = mat.Family / mat.TokenCount\\n mat['Humans_Percent'] = mat.Humans / mat.TokenCount\\n mat['Time_Percent'] = mat.Time / mat.TokenCount\\n mat['Past_Percent'] = mat.Past / mat.TokenCount\\n mat['Present_Percent'] = mat.Present / mat.TokenCount\\n mat['Future_Percent'] = mat.Future / mat.TokenCount\\n mat['Space_Percent'] = mat.Space / mat.TokenCount\\n mat['Up_Percent'] = mat.Up / mat.TokenCount\\n mat['Down_Percent'] = mat.Down / mat.TokenCount\\n mat['Incl_Percent'] = mat.Incl / mat.TokenCount\\n mat['Excl_Percent'] = mat.Excl / mat.TokenCount\\n mat['Motion_Percent'] = mat.Motion / mat.TokenCount\\n mat['Occup_Percent'] = mat.Occup / mat.TokenCount\\n mat['School_Percent'] = mat.School / mat.TokenCount\\n mat['Job_Percent'] = mat.Job / mat.TokenCount\\n mat['Achieve_Percent'] = mat.Achieve / mat.TokenCount\\n mat['Leisure_Percent'] = mat.Leisure / mat.TokenCount\\n mat['Home_Percent'] = mat.Home / mat.TokenCount\\n mat['Sports_Percent'] = mat.Sports / mat.TokenCount\\n mat['TV_Percent'] = mat.TV / mat.TokenCount\\n mat['Music_Percent'] = mat.Music / mat.TokenCount\\n mat['Money_Percent'] = mat.Money / mat.TokenCount\\n mat['Metaph_Percent'] = mat.Metaph / mat.TokenCount\\n mat['Relig_Percent'] = mat.Relig / mat.TokenCount\\n mat['Death_Percent'] = mat.Death / mat.TokenCount\\n mat['Physcal_Percent'] = mat.Physcal / mat.TokenCount\\n mat['Body_Percent'] = mat.Body / mat.TokenCount\\n mat['Sexual_Percent'] = mat.Sexual / mat.TokenCount\\n mat['Eating_Percent'] = mat.Eating / mat.TokenCount\\n mat['Sleep_Percent'] = mat.Sleep / mat.TokenCount\\n mat['Groom_Percent'] = mat.Groom / mat.TokenCount\\n mat['Swear_Percent'] = mat.Swear / mat.TokenCount\\n mat['Nonfl_Percent'] = mat.Nonfl / mat.TokenCount\\n mat['Fillers_Percent'] = mat.Fillers / mat.TokenCount\\n mat['Swiss_Percent'] = mat.Swiss / mat.TokenCount\\n mat['Ideo_Percent'] = mat.Ideo / mat.TokenCount\\n mat['Personalpronomina_Percent'] = mat.Personalpronomina / mat.TokenCount\\n mat['Indefinitpronomina_Percent'] = mat.Indefinitpronomina / mat.TokenCount\\n mat['AuxiliaryVerbs_Percent'] = mat.AuxiliaryVerbs / mat.TokenCount\\n mat['Konjunktionen_Percent'] = mat.Konjunktionen / mat.TokenCount\\n mat['Adverbien_Percent'] = mat.Adverbien / mat.TokenCount\\n mat['Detect_Percent'] = mat.LIWC_Counter / mat.TokenCount\\n mat['Bedrohung_Percent'] = mat.Bedrohung / mat.TokenCount\\n return(mat)\\n\\n elif output == 'array':\\n out_dict = {}\\n out_dict['Affect'] = mat[:,:,11]\\n out_dict['Posemo'] = mat[:,:,12]\\n out_dict['Posfeel'] = mat[:,:,13]\\n out_dict['Optim'] = mat[:,:,14]\\n out_dict['Negemo'] = mat[:,:,15]\\n out_dict['Anx'] = mat[:,:,16]\\n out_dict['Anger'] = mat[:,:,17]\\n out_dict['Sad'] = mat[:,:,18]\\n out_dict['Function'] = mat[:,:,0]\\n out_dict['CogProc'] = mat[:,:,32]\\n out_dict['DetectCount'] = mat[:,:,-2]\\n out_dict['TokenCount'] = mat[:,:,-1]\\n\\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\\n out_dict['DetectPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['DetectCount'])\\n out_dict['OverallPosfeelPercent'] = np.divide(out_dict['Posfeel'], out_dict['TokenCount'])\\n out_dict['DetectOptimPercent'] = np.divide(out_dict['Optim'], out_dict['DetectCount'])\\n out_dict['OverallOptimPercent'] = np.divide(out_dict['Optim'], out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\\n\\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\") \\n else:\\n print(\\\"Error: Method not found!\\\") \\n elif language == 'chinese':\\n if method == 'dimensional':\\n if output == 'data_frame':\\n print(\\\"Error: This combination doesn't exist yet!\\\")\\n elif output == 'array':\\n print(\\\"Error: This combination doesn't exist yet!\\\")\\n else:\\n print(\\\"Error: Output Format not found!\\\")\\n elif method == 'discrete':\\n if output == 'data_frame':\\n print(\\\"Error: This combination doesn't exist yet!\\\")\\n elif output == 'array':\\n out_dict = {}\\n out_dict['Affect'] = mat[:,:,30]\\n out_dict['Posemo'] = mat[:,:,31]\\n out_dict['Negemo'] = mat[:,:,32]\\n out_dict['Anx'] = mat[:,:,33]\\n out_dict['Anger'] = mat[:,:,34]\\n out_dict['Sad'] = mat[:,:,35]\\n out_dict['Function'] = mat[:,:,0]\\n out_dict['CogProc'] = mat[:,:,41]\\n out_dict['DetectCount'] = mat[:,:,-2]\\n out_dict['TokenCount'] = mat[:,:,-1]\\n\\n out_dict['DetectPosPercent'] = np.divide(out_dict['Posemo'], out_dict['DetectCount'])\\n out_dict['OverallPosPercent'] = np.divide(out_dict['Posemo'], out_dict['TokenCount'])\\n out_dict['DetectNegPercent'] = np.divide(out_dict['Negemo'], out_dict['DetectCount'])\\n out_dict['OverallNegPercent'] = np.divide(out_dict['Negemo'], out_dict['TokenCount'])\\n out_dict['EmoPosPercent'] = np.divide(out_dict['Posemo'],np.add(out_dict['Posemo'],out_dict['Negemo']))\\n out_dict['DetectAnxPercent'] = np.divide(out_dict['Anx'], out_dict['DetectCount'])\\n out_dict['OverallAnxPercent'] = np.divide(out_dict['Anx'], out_dict['TokenCount'])\\n out_dict['DetectAngerPercent'] = np.divide(out_dict['Anger'], out_dict['DetectCount'])\\n out_dict['OverallAngerPercent'] = np.divide(out_dict['Anger'], out_dict['TokenCount'])\\n out_dict['DetectSadPercent'] = np.divide(out_dict['Sad'], out_dict['DetectCount'])\\n out_dict['OverallSadPercent'] = np.divide(out_dict['Sad'], out_dict['TokenCount'])\\n out_dict['DetectAffectPercent'] = np.divide(out_dict['Affect'], out_dict['DetectCount'])\\n out_dict['OverallAffectPercent'] = np.divide(out_dict['Affect'], out_dict['TokenCount'])\\n out_dict['DetectPercent'] = np.divide(out_dict['DetectCount'], out_dict['TokenCount'])\\n\\n out_dict['DetectFunctionPercent'] = np.divide(out_dict['Function'], out_dict['DetectCount'])\\n out_dict['OverallFunctionPercent'] = np.divide(out_dict['Function'], out_dict['TokenCount'])\\n out_dict['DetectCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['DetectCount'])\\n out_dict['OverallCogprocPercent'] = np.divide(out_dict['CogProc'], out_dict['TokenCount'])\\n return(out_dict)\\n else:\\n print(\\\"Error: Output Format not found!\\\") \\n else:\\n print(\\\"Error: Method not found!\\\") \\n else:\\n print(\\\"Error: Language not found!\\\")\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n n = tp + tn + fp + fn\\n e1 = (fn * (fn + 2 * tp) / (tp + fn) + fp * (fp + 2 * tn) / (tn + fp)) / n\\n e2 = (fp * (fp + 2 * tp) / (tp + fp) + fn * (fn + 2 * tn) / (tn + fn)) / n\\n\\n return min(e1, e2)\",\n \"def calculate(self):\\n\\n return 2 * self.confusion_matrix.tp / \\\\\\n (2 * self.confusion_matrix.tp + self.confusion_matrix.fp + self.confusion_matrix.fn)\",\n \"def test_get_derived_metric(self):\\n pass\",\n \"def get_dps(data_dict, R = 50):\\n p1_ida = iterable_data_array(data_dict, 'p1')\\n p2_ida = iterable_data_array(data_dict, 'p2')\\n worker = data_array_builder()\\n \\n for p1, p2 in zip(p1_ida, p2_ida):\\n worker.append((p1 - p2)/R) \\n \\n return {'time':data_dict['time'], 'dp':worker.build()}\",\n \"def evaluate_viz_metrics(y_emb, dataset, verbose=1):\\n results = {}\\n\\n # results[\\\"trust\\\"] = trustworthiness(dataset.inputs, y_emb, n_neighbors=5, metric=distance_metric)\\n results[\\\"One NN accuracy\\\"] = nearest_neighbours_generalisation_accuracy(y_emb, dataset.labels, 1)\\n results[\\\"Avg graph distance\\\"], results[\\\"Avg feature distance\\\"] = combined_dist_metric(y_emb, dataset.inputs, dataset.adj_matrix, k=5)\\n results['Total distance'] = results[\\\"Avg graph distance\\\"] + results[\\\"Avg feature distance\\\"]\\n\\n if verbose:\\n for k, v in results.items():\\n print(\\\"{} = {:.4f}\\\".format(k, v))\\n return results\",\n \"def getDensityEstimate(self):\\n return self.density\",\n \"def r_d(self, tl):\\n\\t return self.RD0*exp(self.HKR/(R*self.TO)*(1. - self.TO/tl))\",\n \"def ComputeEnergyConsumption(self):\\r\\n pass\",\n \"def total_sdram_requirements(self):\",\n \"def compute(dm,do):\\n mae = MV.average(MV.absolute(MV.subtract(dm,do)))\\n return float(mae)\",\n \"def _calculate(self):\\n source = self.source\\n res = {}\\n l_cols = [[], [], [], []]\\n r_lines = {}\\n dateline=None\\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\\n if source[t.ror].min() > -99.0:\\n pass\\n else:\\n source[t.ror] = np.where(\\n source[t.ror] > -99.0, source[t.ror], -99.0)\\n ###\\n for account in self.accounts:\\n source_account = source[source[t.account] == account]\\n source_account = source_account.reset_index(drop=True)\\n dateline=source_account[t.effective_date]\\n ror=source_account[t.ror]/100\\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\\n # double_return_cum=round(double_return_cum,2)+1\\n returns_cum = returns_cum + 1\\n growth_amounts = returns_cum * self.starting_value\\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\\\\n round(growth_amounts, 2)\\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\\n 'series': l_cols}\\n res['growth_of_unit'] = {'xAxis': list(dateline),\\n 'series': r_lines}\\n return res\\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\\n # return ret_dict\",\n \"def calculate(self):\\n\\n return self.confusion_matrix.tp / (self.confusion_matrix.tp + self.confusion_matrix.fn)\",\n \"def metric(self, i1, i2):\\n xx = self._try_cache(self.i2e[i1[0]])\\n yy = self._try_cache(self.i2e[i2[0]])\\n\\n \\\"\\\"\\\"Don't need to cache the xy similarity because it doesn't have other uses\\\"\\\"\\\"\\n xy = parasail.nw_stats(self.i2e[i1[0]], self.i2e[i2[0]], **self.paraParams).score\\n\\n D = xx + yy - 2 * xy\\n return D\",\n \"def compute_dsc(self, original, shrinked):\\n for i in range(len(original)):\\n x, y = original[i]\\n orig = y-x\\n\\n a, b = shrinked[i]\\n new = b-a\\n\\n dsc = float(new/orig)\\n\\n return dsc\",\n \"def dset(self):\\n\\n a = 0.0\\n b = 0.0\\n sums = np.sum(self.descriptors, axis=0)\\n for sum in sums:\\n if sum > 0:\\n if sum == self.d_length:\\n b += 1.\\n else:\\n a += 1.\\n return a / (a+b)\",\n \"def compute(self) -> Any:\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n support=self.statistics[\\\"support\\\"],\\n zero_division=self.zero_division,\\n )\\n return per_class, micro, macro, weighted\",\n \"def calculateR(sapienses: list) -> float:\\n r = 0\\n for i in sapienses:\\n r = r + i.numberInfected\\n r=r/I0\\n r = r*S/(S+R+D)\\n return r\",\n \"def _compute_recons_metrics(cls, quant_module: StaticGridQuantWrapper, act_func, inp_data: torch.Tensor,\\n out_data: torch.Tensor) -> Tuple[float, float]:\\n adaround_quantizer = quant_module.param_quantizers['weight']\\n\\n # Enable hard rounding and get quantized wrapper module's output\\n adaround_quantizer.use_soft_rounding = False\\n out_data_hard = cls._compute_output_with_adarounded_weights(quant_module, inp_data)\\n\\n # Enable soft rounding and get quantized wrapper module's output\\n adaround_quantizer.use_soft_rounding = True\\n out_data_soft = cls._compute_output_with_adarounded_weights(quant_module, inp_data)\\n\\n # If followed by an activation function\\n if act_func is not None:\\n out_data = act_func(out_data)\\n out_data_soft = act_func(out_data_soft)\\n out_data_hard = act_func(out_data_hard)\\n\\n recons_err_soft = functional.mse_loss(out_data_soft, out_data)\\n recons_err_hard = functional.mse_loss(out_data_hard, out_data)\\n\\n return float(recons_err_hard), float(recons_err_soft)\",\n \"def evaluate_de_res(de_res, de_genes, adj_p_cutoff=0.05):\\n n_genes = de_res.shape[0]\\n called_pos = np.logical_and(de_res['tested'], de_res['adjusted_p_value'] <= adj_p_cutoff)\\n actual_pos = np.array([g in de_genes for g in xrange(n_genes)], dtype=bool)\\n true_pos = np.logical_and(called_pos, actual_pos)\\n sens = true_pos.sum().astype(float) / actual_pos.sum()\\n ppv = true_pos.sum().astype(float) / called_pos.sum()\\n\\n return sens, ppv\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n n = self.confusion_matrix.n\\n\\n fn_tp = fn + tp\\n fp_tp = fp + tp\\n\\n h1 = -((fn_tp / n) * math.log2(fn_tp / n) +\\n (1 - fn_tp / n) * math.log2(1 - fn_tp / n))\\n\\n h2 = -((fp_tp / n) * math.log2(fp_tp / n) +\\n (1 - fp_tp / n) * math.log2(1 - fp_tp / n))\\n\\n p00 = 1 if tn == 0 else (tn / n)\\n p01 = 1 if fn == 0 else (fn / n)\\n p10 = 1 if fp == 0 else (fp / n)\\n p11 = 1 if tp == 0 else (tp / n)\\n\\n h12 = -((tn / n) * math.log2(p00) +\\n (fn / n) * math.log2(p01) +\\n (fp / n) * math.log2(p10) +\\n (tp / n) * math.log2(p11))\\n\\n mi = h1 + h2 - h12\\n return mi\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def get_fractional_degradation(bt):\\n\\n\\n\\n NomIch = 0.125 # Nominal charge current\\n NomId = 0.25 # Nominal discharge current\\n NomSoC = 0.5 # Nominal state of charge_mode\\n NomDoD = 1.0 # Nominal depth of discharge\\n B = 5 #Battery capacity\\n qt = 5 * 0.5 # Amount of energy in the battery at the start\\n # Determin charge of discharge\\n if bt > 0:\\n Id = bt/(B*1) # time interval differnece is 1\\n Ich = NomIch\\n else:\\n Ich = bt/(B*1)\\n Id = NomId\\n\\n #Calculate average State of Charge\\n SoC = 100 * (qt - 0.5*bt)/B\\n\\n #Calculate Depth of Discharge\\n DoD = 100 * bt /B\\n\\n # Functions\\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\\n nCL = nCL1 * nCL2 * nCL3\\n Fractional_D = (0.5/3650)/ nCL\\n return Fractional_D\",\n \"def _calc_r2(self):\\n sse = np.sum((self.data.y - self.predict(self.data.x))**2)\\n sst = np.sum((self.data.y - self.data.y.mean())**2)\\n return (1. - sse/sst)\",\n \"def calc_metrics(self, data, output):\\n\\n L1NormITAE = self.calcL1NormITAE(data)\\n L1NormAbs = self.calcL1NormAbs(data)\\n #\\n # print 'ITAE score: ', errorIntegral\\n print 'L1NormITAE: ', L1NormITAE\\n print 'L1NormAbs: ', L1NormAbs\\n print '\\\\n'\\n output.update({'L1NormITAE': L1NormITAE, 'L1NormAbs': L1NormAbs})\",\n \"def _calculate_metrics(self):\\n metrics = {}\\n precision, recall = self.calc_precision_recall()\\n metrics[\\\"precision\\\"] = precision\\n metrics[\\\"recall\\\"] = recall\\n metrics[\\\"entropy\\\"] = self.calc_entropy()\\n metrics[\\\"component_entropy\\\"] = self.calc_component_entropy()\\n metrics[\\\"num_comps\\\"] = len(self.get_components())\\n metrics[\\\"num_diagnoses\\\"] = len(self.diagnoses)\\n metrics[\\\"distinct_diagnoses_scores\\\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\\n metrics[\\\"num_tests\\\"] = len(self.get_tests())\\n metrics[\\\"num_distinct_traces\\\"] = len(self.get_distinct_traces())\\n metrics[\\\"num_failed_tests\\\"] = len(self._get_tests_by_error(1))\\n metrics[\\\"num_passed_tests\\\"] = len(self._get_tests_by_error(0))\\n passed_comps = set(self._get_components_by_error(0))\\n failed_comps = set(self.get_components_in_failed_tests())\\n metrics[\\\"num_failed_comps\\\"] = len(failed_comps)\\n metrics[\\\"only_failed_comps\\\"] = len(failed_comps - passed_comps)\\n metrics[\\\"only_passed_comps\\\"] = len(passed_comps - failed_comps)\\n metrics[\\\"num_bugs\\\"] = len(self.get_bugs())\\n metrics[\\\"wasted\\\"] = self.calc_wasted_components()\\n metrics[\\\"top_k\\\"] = self.calc_top_k()\\n metrics[\\\"num_comps_in_diagnoses\\\"] = len(self._get_comps_in_diagnoses())\\n metrics[\\\"bugs_cover_ratio\\\"] = self._get_bugs_cover_ratio()\\n metrics[\\\"average_trace_size\\\"] = self._get_average_trace_size()\\n metrics[\\\"average_component_activity\\\"] = self._get_average_component_activity()\\n metrics[\\\"average_diagnosis_size\\\"] = self._get_average_diagnosis_size()\\n metrics[\\\"bugs_scores_average\\\"], metrics[\\\"bugs_scores_std\\\"], metrics[\\\"bugs_scores_entropy\\\"] = self._get_bugs_scores()\\n metrics[\\\"non_bugs_scores_average\\\"], metrics[\\\"non_bugs_scores_std\\\"], metrics[\\\"non_bugs_scores_entropy\\\"] = self._get_non_bugs_scores()\\n metrics.update(self.cardinality())\\n # metrics[\\\"ochiai\\\"] = self.calc_ochiai_values()\\n return metrics\",\n \"def calculate_batch_metrics(self):\\n pass\",\n \"def calc_metric3(K_tilda):\\n trace = np.trace(K_tilda)\\n # determinant = np.linalg.det(K_tilda)\\n _, log_determinant = np.linalg.slogdet(K_tilda)\\n diff = trace - log_determinant\\n print(trace, log_determinant, diff)\\n return diff\",\n \"def evaluate(pred_file, ref_file):\\n ref_dict, pred_dict, query_dict, id_dict = build_pred_ref_dict(ref_file, pred_file, ref_file)\\n total, acc, scores = res_eval_with_type_acc(query_dict, pred_dict, ref_dict, id_dict, save=False)\\n em = calculate_exact_match(pred_dict, ref_dict)\\n print('Comp Acc: {:.3f}%\\\\tBleu-4: {:.3f}\\\\tRouge-L: {:.3f}'.format(acc, scores['Bleu-4'], scores['Rouge-L']))\\n print('EM: {:.3f}%'.format(em))\\n # calculate_sketch_type_acc(ref_file, pred_file)\\n # calculate_exact_match_for_each_q_type(ref_file, pred_file)\\n return total, acc, scores, em\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n n = self.confusion_matrix.n\\n\\n fp_tn = tn + fp\\n tp_fn = fn + tp\\n tn_fn = tn + fn\\n tp_fp = fp + tp\\n nis = tn_fn * tn_fn + tp_fp * tp_fp\\n njs = fp_tn * fp_tn + tp_fn * tp_fn\\n sum_of_squares = tp * tp + tn * tn + fp * fp + fn * fn\\n\\n a = (tp * (tp - 1) + fp * (fp - 1) + tn * (tn - 1) + fn * (fn - 1)) / 2.\\n b = (njs - sum_of_squares) / 2.\\n c = (nis - sum_of_squares) / 2.\\n d = (n * n + sum_of_squares - nis - njs) / 2.\\n\\n x1 = a - ((a + c) * (a + b) / (a + b + c + d))\\n x2 = ((a + c) + (a + b)) / 2.\\n x3 = ((a + c) * (a + b)) / (a + b + c + d)\\n denominator = x2 - x3\\n\\n if denominator != 0:\\n return x1 / denominator\\n else:\\n return 0\",\n \"def dc(self):\\n return np.array(self['dc'], dtype=np.float32) / 1000\",\n \"def precalculate():\\n pass\",\n \"def precalculate():\\n pass\",\n \"def _compute_metrics(hits_or_lcs: int, pred_len: int, target_len: int) ->Dict[str, Tensor]:\\n precision = hits_or_lcs / pred_len\\n recall = hits_or_lcs / target_len\\n if precision == recall == 0.0:\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n fmeasure = 2 * precision * recall / (precision + recall)\\n return dict(precision=tensor(precision), recall=tensor(recall), fmeasure=tensor(fmeasure))\",\n \"def get_expected_cost(self):\",\n \"def measure(self):\\n return self._measure\",\n \"def performace_measure(data,pred):\\n true = data['clicks']\\n weights = weighting(data)\\n diff = true-pred.astype(int)\\n return np.sqrt(np.inner(weights,diff*diff)/weights.sum())\",\n \"def compute_key_value(self) -> Dict[str, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = self.compute()\\n metrics = self._convert_metrics_to_kv(\\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\\n )\\n return metrics\",\n \"def calculate_metrics(self):\\n sensitivity = TP + FN\\n sensitivity = TP / sensitivity\\n\\n specificity = TN + FP\\n specificity = TN / specificity\\n\\n accuracy = TP + FP + TN + FN\\n divisor = TP + TN\\n accuracy = divisor / accuracy\\n\\n positive_predictive = TP + FP\\n positive_predictive = TP / positive_predictive\\n\\n negative_predictive = TN + FN\\n negative_predictive = TN / negative_predictive\\n\\n # This is for format decimal in metrics\\n sensitivity = float(\\\"{0:.4f}\\\".format(sensitivity))\\n specificity = float(\\\"{0:.4f}\\\".format(specificity))\\n accuracy = float(\\\"{0:.4f}\\\".format(accuracy))\\n positive_predictive = float(\\\"{0:.4f}\\\".format(positive_predictive))\\n negative_predictive = float(\\\"{0:.4f}\\\".format(negative_predictive))\\n\\n average = (sensitivity + specificity + accuracy + positive_predictive + negative_predictive) / 5\\n\\n average = float(\\\"{0:.4f}\\\".format(average))\\n\\n metrics = [sensitivity, specificity, accuracy,positive_predictive,negative_predictive, average]\\n\\n return metrics\",\n \"def tldiffusion(self, dt):\\n\\n # Reset erosion, depo, trans and flux_in to 0\\n self.erosion[:] = 0.0\\n self.depo[:] = 0.0\\n self.trans[:] = 0.0\\n self.flux_in[:] = 0.0\\n\\n # Downstream steepest slope at node:\\n self.steepest = self.grid.at_node[\\\"topographic__steepest_slope\\\"]\\n # On each node, node ID of downstream receiver node\\n # (on node (i), ID of node that receives flow from node (i)):\\n self.receiver = self.grid.at_node[\\\"flow__receiver_node\\\"]\\n\\n dx = self.grid.dx\\n cores = self.grid.core_nodes\\n\\n # Calculate influx rate on node i = outflux of nodes\\n # whose receiver is i\\n for i in self.grid.core_nodes:\\n self.flux_in[self.receiver[i]] += self.flux_out[i]\\n\\n # Calculate transport coefficient\\n # When S ~ Scrit, d_coeff is set to \\\"infinity\\\", for stability and\\n # so that there is no deposition\\n if self.steepest[i] >= self.slope_crit:\\n self.d_coeff[i] = 1000000000.0\\n else:\\n self.d_coeff[i] = 1 / (\\n 1 - (np.power(((self.steepest[i]) / self.slope_crit), 2))\\n )\\n\\n # Calculate deposition rate on node\\n self.depo[cores] = self.flux_in[cores] / self.d_coeff[cores]\\n\\n # Calculate erosion rate on node (positive value)\\n # If S > Scrit, erosion is simply set for the slope to return to Scrit\\n # Otherwise, erosion is slope times erodibility coefficent\\n for i in self.grid.core_nodes:\\n if self.steepest[i] > self.slope_crit:\\n self.erosion[i] = dx * (self.steepest[i] - self.slope_crit) / (100 * dt)\\n else:\\n self.erosion[i] = self.k * self.steepest[i]\\n\\n # Update elevation\\n self.elev[i] += (-self.erosion[i] + self.depo[i]) * dt\\n\\n # Calculate transfer rate over node\\n self.trans[cores] = self.flux_in[cores] - self.depo[cores]\\n\\n # Calculate outflux rate\\n self.flux_out[:] = self.erosion + self.trans\",\n \"def DW_cal(data, data_sm):\\n n = len(data)\\n numerator = 0\\n denominator = 0\\n for i in range(n):\\n if i == 0:\\n numerator = numerator + 0\\n else:\\n numerator = numerator + ((data[i] - data_sm[i]) - (data[i-1] - data_sm[i-1]))**2\\n denominator = denominator + (data[i] - data_sm[i])**2\\n return numerator/denominator*n/(n - 1)\",\n \"def computePRMeasures(self, targetLabels, actualLabels):\\r\\n if self.basicMeasures is None:\\r\\n self.basicMeasures = self.computeBasicStatistics(targetLabels, actualLabels)\\r\\n if self.basicMeasures[0] == 0:\\r\\n self.prMeasures = (0,0)\\r\\n else:\\r\\n self.prMeasures = ((0.0 + self.basicMeasures[0]) / (self.basicMeasures[0] + self.basicMeasures[1]),\\r\\n (0.0 + self.basicMeasures[0]) / (self.basicMeasures[0] + self.basicMeasures[3]))\\r\\n return self.prMeasures\",\n \"def test_calculate_supervisory_delta_call(self):\\n SDC = calculate_supervisory_delta_call()\\n \\n self.assertEqual(SDC, 0.73)\",\n \"def _df_reg(self):\\n return self.k\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6594812","0.65652555","0.647981","0.647346","0.63362116","0.62262213","0.6224595","0.618598","0.61559206","0.6152622","0.61477774","0.6140981","0.61260253","0.61076653","0.6089313","0.60319406","0.60208917","0.59696853","0.5940918","0.59328157","0.59270597","0.5926883","0.590515","0.590515","0.5860092","0.5846103","0.582652","0.5809938","0.5807385","0.5788959","0.57857585","0.5770826","0.5766159","0.5759158","0.5757527","0.5738876","0.5727232","0.5727232","0.57269853","0.5724303","0.57215774","0.57004845","0.5694584","0.5694022","0.56929445","0.5691002","0.56899214","0.5674154","0.5671199","0.566174","0.5648299","0.56385","0.56251895","0.56099033","0.56099015","0.56061935","0.56050724","0.5598219","0.55930763","0.55926406","0.5591708","0.5578496","0.5576069","0.55741394","0.55596596","0.5559042","0.55467093","0.55432326","0.55430156","0.5542387","0.5542298","0.5541264","0.55404663","0.553962","0.55378175","0.5536428","0.5534574","0.5530079","0.552935","0.5525403","0.5510374","0.5503211","0.55012035","0.5496375","0.5494377","0.54934275","0.5491775","0.54901385","0.54901385","0.54895866","0.5487486","0.5486207","0.5484212","0.54791605","0.547835","0.54772925","0.5468326","0.5466757","0.5465491","0.5462701"],"string":"[\n \"0.6594812\",\n \"0.65652555\",\n \"0.647981\",\n \"0.647346\",\n \"0.63362116\",\n \"0.62262213\",\n \"0.6224595\",\n \"0.618598\",\n \"0.61559206\",\n \"0.6152622\",\n \"0.61477774\",\n \"0.6140981\",\n \"0.61260253\",\n \"0.61076653\",\n \"0.6089313\",\n \"0.60319406\",\n \"0.60208917\",\n \"0.59696853\",\n \"0.5940918\",\n \"0.59328157\",\n \"0.59270597\",\n \"0.5926883\",\n \"0.590515\",\n \"0.590515\",\n \"0.5860092\",\n \"0.5846103\",\n \"0.582652\",\n \"0.5809938\",\n \"0.5807385\",\n \"0.5788959\",\n \"0.57857585\",\n \"0.5770826\",\n \"0.5766159\",\n \"0.5759158\",\n \"0.5757527\",\n \"0.5738876\",\n \"0.5727232\",\n \"0.5727232\",\n \"0.57269853\",\n \"0.5724303\",\n \"0.57215774\",\n \"0.57004845\",\n \"0.5694584\",\n \"0.5694022\",\n \"0.56929445\",\n \"0.5691002\",\n \"0.56899214\",\n \"0.5674154\",\n \"0.5671199\",\n \"0.566174\",\n \"0.5648299\",\n \"0.56385\",\n \"0.56251895\",\n \"0.56099033\",\n \"0.56099015\",\n \"0.56061935\",\n \"0.56050724\",\n \"0.5598219\",\n \"0.55930763\",\n \"0.55926406\",\n \"0.5591708\",\n \"0.5578496\",\n \"0.5576069\",\n \"0.55741394\",\n \"0.55596596\",\n \"0.5559042\",\n \"0.55467093\",\n \"0.55432326\",\n \"0.55430156\",\n \"0.5542387\",\n \"0.5542298\",\n \"0.5541264\",\n \"0.55404663\",\n \"0.553962\",\n \"0.55378175\",\n \"0.5536428\",\n \"0.5534574\",\n \"0.5530079\",\n \"0.552935\",\n \"0.5525403\",\n \"0.5510374\",\n \"0.5503211\",\n \"0.55012035\",\n \"0.5496375\",\n \"0.5494377\",\n \"0.54934275\",\n \"0.5491775\",\n \"0.54901385\",\n \"0.54901385\",\n \"0.54895866\",\n \"0.5487486\",\n \"0.5486207\",\n \"0.5484212\",\n \"0.54791605\",\n \"0.547835\",\n \"0.54772925\",\n \"0.5468326\",\n \"0.5466757\",\n \"0.5465491\",\n \"0.5462701\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56650126"},"document_rank":{"kind":"string","value":"49"}}},{"rowIdx":3089,"cells":{"query":{"kind":"string","value":"Method which calculates TS Percentage metric for a player"},"document":{"kind":"string","value":"def set_ts_percentage(self):\n bx = self.get_standard_stats()\n ptos = float(bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tsAttempts = float(tcInt + (0.44*float(bx[\"tl_int\"])))\n result = 0.00\n if tsAttempts > 0.00:\n result = (ptos/(2*tsAttempts))*100\n self.ts_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def pct(self):\n\t\treturn self.bottle.pct()","def percentCheck(currentTimeLabel, totalTimeLabel):\n # Updated 11/19/16\n try:\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\n except (ValueError , ZeroDivisionError):\n progPercent = 0\n \n return progPercent","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def getPercent(*args):","def getPercent(*args):","def percentage_update(self):\n\n self.event_update()\n return self.percentage","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)","async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def as_percent(self):\n if self.dynamic:\n self._update_db_obj()\n return f\"{(self._db_obj.progress / self._db_obj.total) * 100}%\"","def set_usg_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n tcInt = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n a = tcInt + (Decimal('0.44')*bx[\"tl_int\"]) + bx[\"turnovers\"]\n b = team[\"minutes\"]/5\n c = (team[\"t2p_int\"] + team[\"t3p_int\"]) + (Decimal('0.44')*team[\"tl_int\"]) + team[\"turnovers\"]\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((Decimal(a)*Decimal(b))/(bx[\"minutes\"]*c))*100\n self.usg_percentage = \"%.2f\" % round(result, 2)","def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def set_assists_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n team_tc_conv = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n player_tc_conv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0:\n result = (bx[\"assists\"] / (((bx[\"minutes\"] / (team[\"minutes\"] / 5)) * team_tc_conv) - player_tc_conv))*100\n result = result if result <= 100 and result >= 0 else 0\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.assists_percentage = \"%.2f\" % round(result, 2)","def getPercent(self):\n if isinstance(self.score,numbers.Number) and self.getMaximum():\n return (1.0*self.score/self.getMaximum())\n return None","def percentage(self):\n temp = self.cpu_freq_time_spent.copy()\n for i in self.cpu_freq_time_spent:\n total = 0\n for j in self.cpu_freq_time_spent[i]:\n total += self.cpu_freq_time_spent[i][j]\n for j in self.cpu_freq_time_spent[i]:\n if total != 0:\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\n else:\n temp[i][j] = 0\n return temp","def get_score_percent(self, value):\n qs_related = RoundData.objects.prefetch_related(\n 'shotdata').select_related('shotdata')\n\n round_holes = int(self.round_type)\n\n if value == 'par':\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'birdie_better':\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'tbogey_worse':\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\n if isinstance(value, int):\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def percent_passing(self) -> float:\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\n num_pass = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: m.passed)\n .count(lambda p: bool(p) is True)\n )\n return float(100 * num_pass / num_meas)","def percentage(count, total):\n return count / total * 100","def get_percent(self):\n return self.percent","def get_percentage(self):\n return self.percentage","def get_percentage(self):\n return self.percentage","def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress","def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress","def get_win_percentage(self) -> float:\n if self.wins == 0:\n return 0.0\n else:\n return round((self.wins / (self.wins + self.losses)) * 100, 2)","def as_counts_and_pcts(self):\n if self.e_pct is None:\n self.calculate_percentages()\n\n score_str = 'E: ' + str(self.e_score) + '(' + str(self.e_pct) + '%)/'\n score_str += 'I: ' + str(self.i_score) + '(' + str(self.i_pct) + '%) - '\n score_str += 'N: ' + str(self.n_score) + '(' + str(self.n_pct) + '%)/'\n score_str += 'S: ' + str(self.s_score) + '(' + str(self.s_pct) + '%) - '\n score_str += 'F: ' + str(self.f_score) + '(' + str(self.f_pct) + '%)/'\n score_str += 'T: ' + str(self.t_score) + '(' + str(self.t_pct) + '%) - '\n score_str += 'J: ' + str(self.j_score) + '(' + str(self.j_pct) + '%)/'\n score_str += 'P: ' + str(self.p_score) + '(' + str(self.p_pct) + '%)'\n return score_str","def update_percent(self):","def p(party, vote_count, s):\n return t(party, vote_count) / d(s)","def calcMetrics(TP, P, T, percent=True):\r\n precision = TP / P if P else 0\r\n recall = TP / T if T else 0\r\n FB1 = 2 * precision * recall / (precision + recall) if precision + recall else 0\r\n if percent:\r\n return 100 * precision, 100 * recall, 100 * FB1\r\n else:\r\n return precision, recall, FB1","def calculate_progress_percentage(d):\n successcounter = 0\n for test in d:\n if d[test][\"status\"] != \"not yet run\":\n successcounter += 1\n totalcounter = 0\n for test in d:\n totalcounter += 1\n return int(successcounter / totalcounter * 100)","def get_song_percent_remaining(result):\n return int((1 - (get_song_elapsed_milliseconds(result) / get_song_length_milliseconds(result))) * 100)","def set_steals_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n poss = self.get_team_possessions()\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((bx[\"steals\"] * (team[\"minutes\"]/Decimal('5'))) / Decimal(float(bx[\"minutes\"]) * poss)) * 100\n self.steals_percentage = \"%.2f\" % round(result, 2)","def percent(self):\r\n return self._percent","def value_to_percent(value):\n return ...","def test_percentage(self):\n metric = self.metric()\n sources = [\n self.source(metric, value=\"10\", total=\"70\"),\n self.source(metric, value=\"20\", total=\"50\"),\n ]\n measurement = self.measurement(metric, sources=sources)\n self.assertEqual(\"25\", measurement[\"percentage\"][\"value\"])","def pct_status(self):\r\n # DEPRECATED: self.info.n_answers will be removed\r\n # DEPRECATED: use self.t.n_answers instead\r\n if (self.info.get('n_answers')):\r\n self.n_answers = int(self.info['n_answers'])\r\n if self.n_answers != 0 and self.n_answers != None:\r\n return float(len(self.task_runs)) / self.n_answers\r\n else: # pragma: no cover\r\n return float(0)","def per100_top_stat_players(game_type, stat, player_pk, excluded_pks, season_id=None):\n season = None\n if season_id:\n season = bmodels.Season.objects.get(id=season_id)\n\n if player_pk:\n players = bmodels.Player.objects.filter(pk=player_pk)\n else:\n players = bmodels.Player.objects.all().exclude(\n Q(first_name__contains=\"Team\") | Q(pk__in=excluded_pks))\n player_list = []\n for player in players:\n if season:\n result = player.statline_set.filter(game__game_type=game_type, game__date__range=(\n season.start_date, season.end_date)).aggregate(Sum(stat), Sum('off_pos'))\n else:\n result = player.statline_set.filter(\n game__game_type=game_type).aggregate(Sum(stat), Sum('off_pos'))\n if result['off_pos__sum'] and result['off_pos__sum'] is not 0:\n percentage = (result[stat + '__sum'] /\n result['off_pos__sum']) * 100\n else:\n percentage = 0.0\n player_list.append((player.first_name, percentage))\n return sorted(player_list, key=lambda x: x[1], reverse=True)","def percentage(self) -> str:\n return ranged_value_to_percentage(\n self._device.fan_speed_limits, self._device.fan_speed\n )","def pct_helper(self,k,d,total):\n if k in d:\n return 100.0*d[k]/total\n else:\n return -100.0","def pulsewidth2pct(pw): \n shifted = pw - 500.0\n scaled = shifted / 2000.0 * 100.0\n pct = scaled\n return pct","def percent_processed(self):\n try:\n return (self.pos / self.data_encap.size) * 100.0\n except ZeroDivisionError:\n return 100.0","def per_hour(self):\n if self.is_salary():\n return 0.0\n return self.wage_cents / 100.0","def percentage_used(self):\n return self.volume_used/self.total_volume * 100.0","def percentage(a, b):\n return (a * 100.0) / b","def percent_usage(value, total):\n if total:\n return float(value) * 100.0 / (float(total) + float(value))\n else:\n return 100.0","def compute_stats(self):\n if self.stats is not None:\n return\n self.stats = np.zeros(STEPS_MAX + 1)\n for m in self.missions:\n m.compute_stats()\n self.stats += 100 * m.stats\n self.stats /= len(self.missions)","def percentage(self):\n return sum(self.chunk_percentage) / self.total_steps","def get_cpu_percent():\n return psutil.cpu_percent(interval=1, percpu=True)","def calculate(self):\n\n s_sum = 0\n class_num = len(self.scores)\n \n for i in range(class_num):\n s_sum += self.scores[i]\n\n av = float(s_sum)/class_num\n if av >= 90:\n return 'O'\n elif av >= 80:\n return 'E'\n elif av >= 70:\n return 'A'\n elif av >= 55:\n return 'P'\n elif av >= 40:\n return 'D'\n else:\n return 'T'","def percent_frequencies(self):\n word_count = 0\n local = self.frequencies()\n for key in local.keys():\n i = local[key]\n word_count += int(i)\n for key in local.keys():\n i = local[key]\n percentage = float(i) / float(word_count)\n local[key] = percentage\n return local","def unit_of_measurement(self) -> Any:\n return PERCENTAGE","def ucbScore(self,totalPlayedTimes):\n winRate = self.winRate()\n #print totalPlayedTimes\n #print self.playedTimes\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\n \n return winRate + confidenceInterval","def percent(value, total):\n if total:\n return float(value) * 100.0 / float(total)\n else:\n return 100.0","def _percent(self, lines_total, lines_covered):\n\n if lines_total == 0:\n return '0.0'\n return str(float(float(lines_covered) / float(lines_total)))","def walkout_percentage_average(df,start_year, end_year,bat_met, player_name):\n base_fields = ['PA']\n emp_list = check_base_fields(df,base_fields)\n\n if not emp_list:\n bb_val = round((pd.to_numeric(df['BB.'].str.split('%').str[0])/100)*df['PA'],0).sum()\n pa_total = df['PA'].fillna(0).sum()\n return \"{:.2%}\".format(bb_val / pa_total)\n else:\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\n return walkout_percentage_average(df,start_year, end_year,bat_met, player_name)","def get_player_stats() -> List[BaseStat]:\n return [BoostStat(),\n PositionalTendencies(),\n Averages(),\n BallDistanceStat(),\n ControlsStat(),\n SpeedTendencies(),\n CarryStat(),\n PerPossessionStat(),\n SpeedTendencies(),\n RumbleItemStat(),\n KickoffStat(),\n DropshotStats(),\n DemoStat()\n ]","def GetResult(self, playerjm):\n return self.score / len(self.scores)","def _get_cpu_percent(self):\n cpu_delta = None\n total_delta = None\n cpu_usage = 0\n try:\n cpu_usage2_time = time.time()\n cpu_usage2_usec = self._get_cgroups_cpu_usage_snapshot()\n if cpu_usage2_usec and self._cpu_usage1_usec:\n # elapsed cpu time our cgroup consumed in time period between measurements\n cpu_delta = cpu_usage2_usec - self._cpu_usage1_usec\n if self._cpu_usage1_time:\n time_delta = cpu_usage2_time - self._cpu_usage1_time\n # max possible cpu usage per one second adjusted to elapsed time between measurements\n total_delta = self._max_cpu_usage * time_delta\n if cpu_delta and total_delta:\n cpu_usage = round((cpu_delta / total_delta) * 100, 1)\n self._cpu_usage1_usec = cpu_usage2_usec\n self._cpu_usage1_time = cpu_usage2_time\n except BaseException:\n self._log.warning(f'Unable to determine cpu usage', exc_info=True)\n return cpu_usage","def pulse_width_percent(self) -> float:","def get_percentage_sf_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_sf)/(votes_f + votes_sf)\n return round(ratio * 100, 1)","def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)","def calculatePercentChange(self, oldValue, newValue):\n return (((newValue - oldValue)/oldValue)*100)","def percent_updated(self):\n return self.percent_complete - self.previous_percent_complete","def cps(self):\n return self.datacounts / self.exptime","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def unit_of_measurement(self):\n return \"%\"","def as_percentages(self):\n if self.e_pct is None:\n self.calculate_percentages()\n\n score_str = 'E/I: ' + str(self.e_pct) + '%/' + str(self.i_pct) + '%; '\n score_str += 'N/S: ' + str(self.n_pct) + '%/' + str(self.s_pct) + '%; '\n score_str += 'F/T: ' + str(self.f_pct) + '%/' + str(self.t_pct) + '%; '\n score_str += 'J/P: ' + str(self.j_pct) + '%/' + str(self.p_pct) + '%'\n return score_str","def percentage(part, whole):\n return round((100 * float(part)/float(whole)),2)","def get_percentage_f_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_f)/(votes_f + votes_sf)\n return round(ratio * 100, 1)","def get_rate(timestamps):\n return (timestamps[1, 1] - timestamps[0, 1]) / (timestamps[1, 0])","def percent_change(ts, ax=-1):\r\n ts = np.asarray(ts)\r\n\r\n return (ts / np.expand_dims(np.mean(ts, ax), ax) - 1) * 100","def profile(self):\n return NumericStatsMixin.profile(self)","def calc_stats(hits, misses):\n try:\n result = (float(misses) / float(hits)) * 100.0\n except ZeroDivisionError:\n if misses == 0:\n result = 0.0\n else:\n result = 100.0\n return result","def _get_pace_percentage(pace: time) -> float:\n pace_values = list(reversed(\n [time(minute=x // 2, second=30 if isinstance(x / 2, float) else 0) for x in range(5, 16)]))\n\n if pace < pace_values[0]:\n return 1\n\n if pace > pace_values[-1]:\n return 2\n\n for i in range(1, len(pace_values)):\n if pace_values[i - 1] <= pace <= pace_values[i]:\n return 1 + i / 10","def tsVs(self):\n self.__percentuale = self.ui.percentualeTs.value()","def percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"percentage\")","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def represent_total_percent(self, length):\n numpkgs = self.totals['numpkgs']\n dlpkgs = self.totals['dlpkgs']\n return self.represent_percent(dlpkgs, numpkgs, length)","def get_estimated_percentage(self):\n now_id = now_as_id()\n message_id = self.last_message_id\n if message_id >= now_id:\n return 100.0\n \n channel_id = self.source_channel.id\n if channel_id >= message_id:\n return 0.0\n \n if self.is_polling_done():\n return 100.0\n \n return (1.0 - (now_id - message_id) / (now_id - channel_id)) * 100.0","def winRate(DF):\r\n df = DF[\"return\"]\r\n pos = df[df>1]\r\n neg = df[df<1]\r\n return (len(pos) / len(pos + neg)) * 100","def percent_of(part, whole):\n return part * 100 / whole","def get_percentage(self):\n return self.PotTax_percentage","def get_online_price_diff_percent_method(self):\n try:\n if self.overclockerskz and self.overclockerskz.online_price:\n return int((self.get_online_price_diff_method() / self.overclockerskz.online_price) * 100)\n else:\n return 0\n except (TypeError, ValueError):\n return 0","def test_percentage_is_100(self):\n metric = self.metric(direction=\">\")\n sources = [self.source(metric, value=\"0\", total=\"0\")]\n measurement = self.measurement(metric, sources=sources)\n self.assertEqual(\"100\", measurement[\"percentage\"][\"value\"])","def _get_percentages(games_table: pd.DataFrame, stats_table: pd.DataFrame,\n grouping_column: str) -> pd.DataFrame:\n stats_table[\n [\n \"total_free_throws_achieved\",\n \"total_free_throws_attempted\",\n \"total_two_point_achieved\",\n \"total_two_point_attempted\",\n \"total_three_point_achieved\",\n \"total_three_point_attempted\",\n ]\n ] = (\n games_table[\n [\n grouping_column,\n \"free_throws_achieved\",\n \"free_throws_attempted\",\n \"two_point_achieved\",\n \"two_point_attempted\",\n \"three_point_achieved\",\n \"three_point_attempted\",\n ]\n ]\n .groupby(grouping_column)\n .sum()\n .reset_index()\n .drop(grouping_column, axis=1)\n )\n\n stats_table[\"free_throws_pct\"] = (\n stats_table[\"total_free_throws_achieved\"] / stats_table[\"total_free_throws_attempted\"]\n )\n stats_table[\"two_point_pct\"] = (\n stats_table[\"total_two_point_achieved\"] / stats_table[\"total_two_point_attempted\"]\n )\n stats_table[\"three_point_pct\"] = (\n stats_table[\"total_three_point_achieved\"] / stats_table[\"total_three_point_attempted\"]\n )\n return stats_table","def pc_throughput_avg(self) -> \"float\":\n return _beamforming_swig.doaesprit_sptr_pc_throughput_avg(self)","def get_servo_pct(pi, pin):\n return pulsewidth2pct(pi.get_servo_pulsewidth(pin))","def calculate_percent(self, total_number, some_number):\n\t\treturn (some_number * 100) / total_number","def pc_throughput_avg(self) -> \"float\":\n return _beamforming_swig.randomsampler_sptr_pc_throughput_avg(self)","def displayed_percent(self):\n return (self.displayed_words / self.total_words) * 100","def _calculate_hours_percent(used_hours, estimated_hours):\n percent = (used_hours * 100) / estimated_hours\n return percent","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def compute_drift_score(ref_col_prob, col_prob):\n\n return sum(abs(np.asarray(ref_col_prob) - np.array(col_prob)) * 100)","def calculate_emission_prob(cls, w, t):\n #\n # p_w_t = cls._emission_counts[w, t]\n # p_t = cls._uni_transition_counts[t]\n\n return float(cls._emission_counts[w, t] / cls._uni_transition_counts[t])","def cpu_percent(self):\n self.monitoring_object['cpu_percent'] = \\\n psutil.cpu_percent(interval=1, percpu=True)","def get_vacuum_powerpercentact(self) -> int:\n\n return self.send(self.cmd.GET_VACUUM_POWERPERCENTACT)","def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )","def set_effective_field_goal_percentage(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tcConv = float(bx[\"t2p_conv\"] + bx[\"t3p_conv\"])\n result = 0.00\n if tcInt > 0:\n result = ((tcConv + (0.5 * float(bx[\"t3p_conv\"]))) / tcInt) * 100\n self.effective_field_goal_percentage = \"%.2f\" % round(result, 2)"],"string":"[\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def percentCheck(currentTimeLabel, totalTimeLabel):\\n # Updated 11/19/16\\n try:\\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\\n except (ValueError , ZeroDivisionError):\\n progPercent = 0\\n \\n return progPercent\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def percentage_update(self):\\n\\n self.event_update()\\n return self.percentage\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\",\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def as_percent(self):\\n if self.dynamic:\\n self._update_db_obj()\\n return f\\\"{(self._db_obj.progress / self._db_obj.total) * 100}%\\\"\",\n \"def set_usg_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n tcInt = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n a = tcInt + (Decimal('0.44')*bx[\\\"tl_int\\\"]) + bx[\\\"turnovers\\\"]\\n b = team[\\\"minutes\\\"]/5\\n c = (team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]) + (Decimal('0.44')*team[\\\"tl_int\\\"]) + team[\\\"turnovers\\\"]\\n result = 0.00\\n if bx[\\\"minutes\\\"] > 0:\\n result = ((Decimal(a)*Decimal(b))/(bx[\\\"minutes\\\"]*c))*100\\n self.usg_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def set_assists_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n team_tc_conv = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n player_tc_conv = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0:\\n result = (bx[\\\"assists\\\"] / (((bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * team_tc_conv) - player_tc_conv))*100\\n result = result if result <= 100 and result >= 0 else 0\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.assists_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def getPercent(self):\\n if isinstance(self.score,numbers.Number) and self.getMaximum():\\n return (1.0*self.score/self.getMaximum())\\n return None\",\n \"def percentage(self):\\n temp = self.cpu_freq_time_spent.copy()\\n for i in self.cpu_freq_time_spent:\\n total = 0\\n for j in self.cpu_freq_time_spent[i]:\\n total += self.cpu_freq_time_spent[i][j]\\n for j in self.cpu_freq_time_spent[i]:\\n if total != 0:\\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\\n else:\\n temp[i][j] = 0\\n return temp\",\n \"def get_score_percent(self, value):\\n qs_related = RoundData.objects.prefetch_related(\\n 'shotdata').select_related('shotdata')\\n\\n round_holes = int(self.round_type)\\n\\n if value == 'par':\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'birdie_better':\\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'tbogey_worse':\\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\\n if isinstance(value, int):\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def percent_passing(self) -> float:\\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\\n num_pass = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: m.passed)\\n .count(lambda p: bool(p) is True)\\n )\\n return float(100 * num_pass / num_meas)\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def get_percent(self):\\n return self.percent\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def percentage_progress(self):\\n\\n if self.total_progress != 0:\\n return float(self.progress) / self.total_progress\\n return self.progress\",\n \"def percentage_progress(self):\\n\\n if self.total_progress != 0:\\n return float(self.progress) / self.total_progress\\n return self.progress\",\n \"def get_win_percentage(self) -> float:\\n if self.wins == 0:\\n return 0.0\\n else:\\n return round((self.wins / (self.wins + self.losses)) * 100, 2)\",\n \"def as_counts_and_pcts(self):\\n if self.e_pct is None:\\n self.calculate_percentages()\\n\\n score_str = 'E: ' + str(self.e_score) + '(' + str(self.e_pct) + '%)/'\\n score_str += 'I: ' + str(self.i_score) + '(' + str(self.i_pct) + '%) - '\\n score_str += 'N: ' + str(self.n_score) + '(' + str(self.n_pct) + '%)/'\\n score_str += 'S: ' + str(self.s_score) + '(' + str(self.s_pct) + '%) - '\\n score_str += 'F: ' + str(self.f_score) + '(' + str(self.f_pct) + '%)/'\\n score_str += 'T: ' + str(self.t_score) + '(' + str(self.t_pct) + '%) - '\\n score_str += 'J: ' + str(self.j_score) + '(' + str(self.j_pct) + '%)/'\\n score_str += 'P: ' + str(self.p_score) + '(' + str(self.p_pct) + '%)'\\n return score_str\",\n \"def update_percent(self):\",\n \"def p(party, vote_count, s):\\n return t(party, vote_count) / d(s)\",\n \"def calcMetrics(TP, P, T, percent=True):\\r\\n precision = TP / P if P else 0\\r\\n recall = TP / T if T else 0\\r\\n FB1 = 2 * precision * recall / (precision + recall) if precision + recall else 0\\r\\n if percent:\\r\\n return 100 * precision, 100 * recall, 100 * FB1\\r\\n else:\\r\\n return precision, recall, FB1\",\n \"def calculate_progress_percentage(d):\\n successcounter = 0\\n for test in d:\\n if d[test][\\\"status\\\"] != \\\"not yet run\\\":\\n successcounter += 1\\n totalcounter = 0\\n for test in d:\\n totalcounter += 1\\n return int(successcounter / totalcounter * 100)\",\n \"def get_song_percent_remaining(result):\\n return int((1 - (get_song_elapsed_milliseconds(result) / get_song_length_milliseconds(result))) * 100)\",\n \"def set_steals_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n poss = self.get_team_possessions()\\n result = 0.00\\n if bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"steals\\\"] * (team[\\\"minutes\\\"]/Decimal('5'))) / Decimal(float(bx[\\\"minutes\\\"]) * poss)) * 100\\n self.steals_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def percent(self):\\r\\n return self._percent\",\n \"def value_to_percent(value):\\n return ...\",\n \"def test_percentage(self):\\n metric = self.metric()\\n sources = [\\n self.source(metric, value=\\\"10\\\", total=\\\"70\\\"),\\n self.source(metric, value=\\\"20\\\", total=\\\"50\\\"),\\n ]\\n measurement = self.measurement(metric, sources=sources)\\n self.assertEqual(\\\"25\\\", measurement[\\\"percentage\\\"][\\\"value\\\"])\",\n \"def pct_status(self):\\r\\n # DEPRECATED: self.info.n_answers will be removed\\r\\n # DEPRECATED: use self.t.n_answers instead\\r\\n if (self.info.get('n_answers')):\\r\\n self.n_answers = int(self.info['n_answers'])\\r\\n if self.n_answers != 0 and self.n_answers != None:\\r\\n return float(len(self.task_runs)) / self.n_answers\\r\\n else: # pragma: no cover\\r\\n return float(0)\",\n \"def per100_top_stat_players(game_type, stat, player_pk, excluded_pks, season_id=None):\\n season = None\\n if season_id:\\n season = bmodels.Season.objects.get(id=season_id)\\n\\n if player_pk:\\n players = bmodels.Player.objects.filter(pk=player_pk)\\n else:\\n players = bmodels.Player.objects.all().exclude(\\n Q(first_name__contains=\\\"Team\\\") | Q(pk__in=excluded_pks))\\n player_list = []\\n for player in players:\\n if season:\\n result = player.statline_set.filter(game__game_type=game_type, game__date__range=(\\n season.start_date, season.end_date)).aggregate(Sum(stat), Sum('off_pos'))\\n else:\\n result = player.statline_set.filter(\\n game__game_type=game_type).aggregate(Sum(stat), Sum('off_pos'))\\n if result['off_pos__sum'] and result['off_pos__sum'] is not 0:\\n percentage = (result[stat + '__sum'] /\\n result['off_pos__sum']) * 100\\n else:\\n percentage = 0.0\\n player_list.append((player.first_name, percentage))\\n return sorted(player_list, key=lambda x: x[1], reverse=True)\",\n \"def percentage(self) -> str:\\n return ranged_value_to_percentage(\\n self._device.fan_speed_limits, self._device.fan_speed\\n )\",\n \"def pct_helper(self,k,d,total):\\n if k in d:\\n return 100.0*d[k]/total\\n else:\\n return -100.0\",\n \"def pulsewidth2pct(pw): \\n shifted = pw - 500.0\\n scaled = shifted / 2000.0 * 100.0\\n pct = scaled\\n return pct\",\n \"def percent_processed(self):\\n try:\\n return (self.pos / self.data_encap.size) * 100.0\\n except ZeroDivisionError:\\n return 100.0\",\n \"def per_hour(self):\\n if self.is_salary():\\n return 0.0\\n return self.wage_cents / 100.0\",\n \"def percentage_used(self):\\n return self.volume_used/self.total_volume * 100.0\",\n \"def percentage(a, b):\\n return (a * 100.0) / b\",\n \"def percent_usage(value, total):\\n if total:\\n return float(value) * 100.0 / (float(total) + float(value))\\n else:\\n return 100.0\",\n \"def compute_stats(self):\\n if self.stats is not None:\\n return\\n self.stats = np.zeros(STEPS_MAX + 1)\\n for m in self.missions:\\n m.compute_stats()\\n self.stats += 100 * m.stats\\n self.stats /= len(self.missions)\",\n \"def percentage(self):\\n return sum(self.chunk_percentage) / self.total_steps\",\n \"def get_cpu_percent():\\n return psutil.cpu_percent(interval=1, percpu=True)\",\n \"def calculate(self):\\n\\n s_sum = 0\\n class_num = len(self.scores)\\n \\n for i in range(class_num):\\n s_sum += self.scores[i]\\n\\n av = float(s_sum)/class_num\\n if av >= 90:\\n return 'O'\\n elif av >= 80:\\n return 'E'\\n elif av >= 70:\\n return 'A'\\n elif av >= 55:\\n return 'P'\\n elif av >= 40:\\n return 'D'\\n else:\\n return 'T'\",\n \"def percent_frequencies(self):\\n word_count = 0\\n local = self.frequencies()\\n for key in local.keys():\\n i = local[key]\\n word_count += int(i)\\n for key in local.keys():\\n i = local[key]\\n percentage = float(i) / float(word_count)\\n local[key] = percentage\\n return local\",\n \"def unit_of_measurement(self) -> Any:\\n return PERCENTAGE\",\n \"def ucbScore(self,totalPlayedTimes):\\n winRate = self.winRate()\\n #print totalPlayedTimes\\n #print self.playedTimes\\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\\n \\n return winRate + confidenceInterval\",\n \"def percent(value, total):\\n if total:\\n return float(value) * 100.0 / float(total)\\n else:\\n return 100.0\",\n \"def _percent(self, lines_total, lines_covered):\\n\\n if lines_total == 0:\\n return '0.0'\\n return str(float(float(lines_covered) / float(lines_total)))\",\n \"def walkout_percentage_average(df,start_year, end_year,bat_met, player_name):\\n base_fields = ['PA']\\n emp_list = check_base_fields(df,base_fields)\\n\\n if not emp_list:\\n bb_val = round((pd.to_numeric(df['BB.'].str.split('%').str[0])/100)*df['PA'],0).sum()\\n pa_total = df['PA'].fillna(0).sum()\\n return \\\"{:.2%}\\\".format(bb_val / pa_total)\\n else:\\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\\n return walkout_percentage_average(df,start_year, end_year,bat_met, player_name)\",\n \"def get_player_stats() -> List[BaseStat]:\\n return [BoostStat(),\\n PositionalTendencies(),\\n Averages(),\\n BallDistanceStat(),\\n ControlsStat(),\\n SpeedTendencies(),\\n CarryStat(),\\n PerPossessionStat(),\\n SpeedTendencies(),\\n RumbleItemStat(),\\n KickoffStat(),\\n DropshotStats(),\\n DemoStat()\\n ]\",\n \"def GetResult(self, playerjm):\\n return self.score / len(self.scores)\",\n \"def _get_cpu_percent(self):\\n cpu_delta = None\\n total_delta = None\\n cpu_usage = 0\\n try:\\n cpu_usage2_time = time.time()\\n cpu_usage2_usec = self._get_cgroups_cpu_usage_snapshot()\\n if cpu_usage2_usec and self._cpu_usage1_usec:\\n # elapsed cpu time our cgroup consumed in time period between measurements\\n cpu_delta = cpu_usage2_usec - self._cpu_usage1_usec\\n if self._cpu_usage1_time:\\n time_delta = cpu_usage2_time - self._cpu_usage1_time\\n # max possible cpu usage per one second adjusted to elapsed time between measurements\\n total_delta = self._max_cpu_usage * time_delta\\n if cpu_delta and total_delta:\\n cpu_usage = round((cpu_delta / total_delta) * 100, 1)\\n self._cpu_usage1_usec = cpu_usage2_usec\\n self._cpu_usage1_time = cpu_usage2_time\\n except BaseException:\\n self._log.warning(f'Unable to determine cpu usage', exc_info=True)\\n return cpu_usage\",\n \"def pulse_width_percent(self) -> float:\",\n \"def get_percentage_sf_votes(self):\\n\\n votes_f = self.get_num_f_votes()\\n votes_sf = self.get_num_sf_votes()\\n\\n # avoid dividing by zero\\n if votes_f + votes_sf == 0:\\n return 0\\n else:\\n ratio = float(votes_sf)/(votes_f + votes_sf)\\n return round(ratio * 100, 1)\",\n \"def set_total_reb_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n player_rebounds = bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"]\\n team_rebounds = team[\\\"reb_def\\\"] + team[\\\"reb_of\\\"]\\n opp_team_rebounds = opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((player_rebounds * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team_rebounds + opp_team_rebounds)))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def calculatePercentChange(self, oldValue, newValue):\\n return (((newValue - oldValue)/oldValue)*100)\",\n \"def percent_updated(self):\\n return self.percent_complete - self.previous_percent_complete\",\n \"def cps(self):\\n return self.datacounts / self.exptime\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def unit_of_measurement(self):\\n return \\\"%\\\"\",\n \"def as_percentages(self):\\n if self.e_pct is None:\\n self.calculate_percentages()\\n\\n score_str = 'E/I: ' + str(self.e_pct) + '%/' + str(self.i_pct) + '%; '\\n score_str += 'N/S: ' + str(self.n_pct) + '%/' + str(self.s_pct) + '%; '\\n score_str += 'F/T: ' + str(self.f_pct) + '%/' + str(self.t_pct) + '%; '\\n score_str += 'J/P: ' + str(self.j_pct) + '%/' + str(self.p_pct) + '%'\\n return score_str\",\n \"def percentage(part, whole):\\n return round((100 * float(part)/float(whole)),2)\",\n \"def get_percentage_f_votes(self):\\n\\n votes_f = self.get_num_f_votes()\\n votes_sf = self.get_num_sf_votes()\\n\\n # avoid dividing by zero\\n if votes_f + votes_sf == 0:\\n return 0\\n else:\\n ratio = float(votes_f)/(votes_f + votes_sf)\\n return round(ratio * 100, 1)\",\n \"def get_rate(timestamps):\\n return (timestamps[1, 1] - timestamps[0, 1]) / (timestamps[1, 0])\",\n \"def percent_change(ts, ax=-1):\\r\\n ts = np.asarray(ts)\\r\\n\\r\\n return (ts / np.expand_dims(np.mean(ts, ax), ax) - 1) * 100\",\n \"def profile(self):\\n return NumericStatsMixin.profile(self)\",\n \"def calc_stats(hits, misses):\\n try:\\n result = (float(misses) / float(hits)) * 100.0\\n except ZeroDivisionError:\\n if misses == 0:\\n result = 0.0\\n else:\\n result = 100.0\\n return result\",\n \"def _get_pace_percentage(pace: time) -> float:\\n pace_values = list(reversed(\\n [time(minute=x // 2, second=30 if isinstance(x / 2, float) else 0) for x in range(5, 16)]))\\n\\n if pace < pace_values[0]:\\n return 1\\n\\n if pace > pace_values[-1]:\\n return 2\\n\\n for i in range(1, len(pace_values)):\\n if pace_values[i - 1] <= pace <= pace_values[i]:\\n return 1 + i / 10\",\n \"def tsVs(self):\\n self.__percentuale = self.ui.percentualeTs.value()\",\n \"def percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"percentage\\\")\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def represent_total_percent(self, length):\\n numpkgs = self.totals['numpkgs']\\n dlpkgs = self.totals['dlpkgs']\\n return self.represent_percent(dlpkgs, numpkgs, length)\",\n \"def get_estimated_percentage(self):\\n now_id = now_as_id()\\n message_id = self.last_message_id\\n if message_id >= now_id:\\n return 100.0\\n \\n channel_id = self.source_channel.id\\n if channel_id >= message_id:\\n return 0.0\\n \\n if self.is_polling_done():\\n return 100.0\\n \\n return (1.0 - (now_id - message_id) / (now_id - channel_id)) * 100.0\",\n \"def winRate(DF):\\r\\n df = DF[\\\"return\\\"]\\r\\n pos = df[df>1]\\r\\n neg = df[df<1]\\r\\n return (len(pos) / len(pos + neg)) * 100\",\n \"def percent_of(part, whole):\\n return part * 100 / whole\",\n \"def get_percentage(self):\\n return self.PotTax_percentage\",\n \"def get_online_price_diff_percent_method(self):\\n try:\\n if self.overclockerskz and self.overclockerskz.online_price:\\n return int((self.get_online_price_diff_method() / self.overclockerskz.online_price) * 100)\\n else:\\n return 0\\n except (TypeError, ValueError):\\n return 0\",\n \"def test_percentage_is_100(self):\\n metric = self.metric(direction=\\\">\\\")\\n sources = [self.source(metric, value=\\\"0\\\", total=\\\"0\\\")]\\n measurement = self.measurement(metric, sources=sources)\\n self.assertEqual(\\\"100\\\", measurement[\\\"percentage\\\"][\\\"value\\\"])\",\n \"def _get_percentages(games_table: pd.DataFrame, stats_table: pd.DataFrame,\\n grouping_column: str) -> pd.DataFrame:\\n stats_table[\\n [\\n \\\"total_free_throws_achieved\\\",\\n \\\"total_free_throws_attempted\\\",\\n \\\"total_two_point_achieved\\\",\\n \\\"total_two_point_attempted\\\",\\n \\\"total_three_point_achieved\\\",\\n \\\"total_three_point_attempted\\\",\\n ]\\n ] = (\\n games_table[\\n [\\n grouping_column,\\n \\\"free_throws_achieved\\\",\\n \\\"free_throws_attempted\\\",\\n \\\"two_point_achieved\\\",\\n \\\"two_point_attempted\\\",\\n \\\"three_point_achieved\\\",\\n \\\"three_point_attempted\\\",\\n ]\\n ]\\n .groupby(grouping_column)\\n .sum()\\n .reset_index()\\n .drop(grouping_column, axis=1)\\n )\\n\\n stats_table[\\\"free_throws_pct\\\"] = (\\n stats_table[\\\"total_free_throws_achieved\\\"] / stats_table[\\\"total_free_throws_attempted\\\"]\\n )\\n stats_table[\\\"two_point_pct\\\"] = (\\n stats_table[\\\"total_two_point_achieved\\\"] / stats_table[\\\"total_two_point_attempted\\\"]\\n )\\n stats_table[\\\"three_point_pct\\\"] = (\\n stats_table[\\\"total_three_point_achieved\\\"] / stats_table[\\\"total_three_point_attempted\\\"]\\n )\\n return stats_table\",\n \"def pc_throughput_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_throughput_avg(self)\",\n \"def get_servo_pct(pi, pin):\\n return pulsewidth2pct(pi.get_servo_pulsewidth(pin))\",\n \"def calculate_percent(self, total_number, some_number):\\n\\t\\treturn (some_number * 100) / total_number\",\n \"def pc_throughput_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.randomsampler_sptr_pc_throughput_avg(self)\",\n \"def displayed_percent(self):\\n return (self.displayed_words / self.total_words) * 100\",\n \"def _calculate_hours_percent(used_hours, estimated_hours):\\n percent = (used_hours * 100) / estimated_hours\\n return percent\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def compute_drift_score(ref_col_prob, col_prob):\\n\\n return sum(abs(np.asarray(ref_col_prob) - np.array(col_prob)) * 100)\",\n \"def calculate_emission_prob(cls, w, t):\\n #\\n # p_w_t = cls._emission_counts[w, t]\\n # p_t = cls._uni_transition_counts[t]\\n\\n return float(cls._emission_counts[w, t] / cls._uni_transition_counts[t])\",\n \"def cpu_percent(self):\\n self.monitoring_object['cpu_percent'] = \\\\\\n psutil.cpu_percent(interval=1, percpu=True)\",\n \"def get_vacuum_powerpercentact(self) -> int:\\n\\n return self.send(self.cmd.GET_VACUUM_POWERPERCENTACT)\",\n \"def score( self ):\\r\\n result = 0.0\\r\\n for rr in self.ee.getRsrcs( ):\\r\\n value = self.scoreRsrc( rr )\\r\\n result += value\\r\\n print( \\\"INFO: Value for the schedule is %s \\\" % ( rr, result ) )\\r\\n return( result )\",\n \"def set_effective_field_goal_percentage(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tcConv = float(bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"])\\n result = 0.00\\n if tcInt > 0:\\n result = ((tcConv + (0.5 * float(bx[\\\"t3p_conv\\\"]))) / tcInt) * 100\\n self.effective_field_goal_percentage = \\\"%.2f\\\" % round(result, 2)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67912775","0.67874295","0.66820705","0.6615735","0.6549017","0.65139776","0.65139776","0.6465816","0.64634633","0.6446837","0.64173675","0.64117974","0.6390257","0.63858217","0.6356354","0.6316925","0.6298419","0.62818795","0.6281119","0.6268235","0.6221657","0.62200534","0.6174268","0.6174268","0.61564356","0.61564356","0.61437255","0.6129586","0.61163414","0.6111541","0.60880846","0.6076288","0.6063487","0.60439956","0.6023627","0.6006266","0.5997345","0.5974105","0.5964852","0.5962612","0.59543926","0.59269553","0.592581","0.5922709","0.59221375","0.59043634","0.590287","0.58928597","0.5870334","0.5866686","0.5859223","0.5853675","0.5846657","0.5822112","0.58171606","0.5810143","0.580316","0.5796781","0.5795917","0.5795528","0.5784395","0.57841456","0.5766687","0.57578266","0.5743189","0.5740383","0.57392","0.5735312","0.57305497","0.5728495","0.5719273","0.5712585","0.5706635","0.56964844","0.56941295","0.568894","0.5687575","0.56737196","0.56710786","0.56656027","0.56603515","0.5659293","0.5659241","0.56558007","0.5654754","0.56520814","0.5633315","0.5631197","0.5629281","0.5623366","0.56229657","0.5622891","0.5621765","0.5619767","0.5617763","0.56176233","0.5615678","0.56156546","0.56130385","0.5603134"],"string":"[\n \"0.67912775\",\n \"0.67874295\",\n \"0.66820705\",\n \"0.6615735\",\n \"0.6549017\",\n \"0.65139776\",\n \"0.65139776\",\n \"0.6465816\",\n \"0.64634633\",\n \"0.6446837\",\n \"0.64173675\",\n \"0.64117974\",\n \"0.6390257\",\n \"0.63858217\",\n \"0.6356354\",\n \"0.6316925\",\n \"0.6298419\",\n \"0.62818795\",\n \"0.6281119\",\n \"0.6268235\",\n \"0.6221657\",\n \"0.62200534\",\n \"0.6174268\",\n \"0.6174268\",\n \"0.61564356\",\n \"0.61564356\",\n \"0.61437255\",\n \"0.6129586\",\n \"0.61163414\",\n \"0.6111541\",\n \"0.60880846\",\n \"0.6076288\",\n \"0.6063487\",\n \"0.60439956\",\n \"0.6023627\",\n \"0.6006266\",\n \"0.5997345\",\n \"0.5974105\",\n \"0.5964852\",\n \"0.5962612\",\n \"0.59543926\",\n \"0.59269553\",\n \"0.592581\",\n \"0.5922709\",\n \"0.59221375\",\n \"0.59043634\",\n \"0.590287\",\n \"0.58928597\",\n \"0.5870334\",\n \"0.5866686\",\n \"0.5859223\",\n \"0.5853675\",\n \"0.5846657\",\n \"0.5822112\",\n \"0.58171606\",\n \"0.5810143\",\n \"0.580316\",\n \"0.5796781\",\n \"0.5795917\",\n \"0.5795528\",\n \"0.5784395\",\n \"0.57841456\",\n \"0.5766687\",\n \"0.57578266\",\n \"0.5743189\",\n \"0.5740383\",\n \"0.57392\",\n \"0.5735312\",\n \"0.57305497\",\n \"0.5728495\",\n \"0.5719273\",\n \"0.5712585\",\n \"0.5706635\",\n \"0.56964844\",\n \"0.56941295\",\n \"0.568894\",\n \"0.5687575\",\n \"0.56737196\",\n \"0.56710786\",\n \"0.56656027\",\n \"0.56603515\",\n \"0.5659293\",\n \"0.5659241\",\n \"0.56558007\",\n \"0.5654754\",\n \"0.56520814\",\n \"0.5633315\",\n \"0.5631197\",\n \"0.5629281\",\n \"0.5623366\",\n \"0.56229657\",\n \"0.5622891\",\n \"0.5621765\",\n \"0.5619767\",\n \"0.5617763\",\n \"0.56176233\",\n \"0.5615678\",\n \"0.56156546\",\n \"0.56130385\",\n \"0.5603134\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.745896"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3090,"cells":{"query":{"kind":"string","value":"Method which calculate USG% for each player from each team"},"document":{"kind":"string","value":"def set_usg_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n tcInt = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n a = tcInt + (Decimal('0.44')*bx[\"tl_int\"]) + bx[\"turnovers\"]\n b = team[\"minutes\"]/5\n c = (team[\"t2p_int\"] + team[\"t3p_int\"]) + (Decimal('0.44')*team[\"tl_int\"]) + team[\"turnovers\"]\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((Decimal(a)*Decimal(b))/(bx[\"minutes\"]*c))*100\n self.usg_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)","def simulate(team, N=100):\n\n total_score = 0.0\n for player in team:\n simulation_score = []\n for i in range(N):\n simulation_score.append(get_player_score(player))\n total_score += np.mean(simulation_score)\n\n return total_score","def get_team_results(usrs, sched):\t\n\t\n\ttotal_consistency = 0\n\ttotal_completion = 0\n\tfor user in usrs:\n\t\tresult = get_consistency(user, sched)\n\t\t\n\t\ttotal_consistency += result[\"consistency\"]\n\t\ttotal_completion += result[\"completion\"]\n\t\n\tteam_consistency = 0\n\tteam_completion = 0\n\t\t\n\tif(len(usrs) != 0):\n\t\tteam_consistency = total_consistency / float(len(usrs))\n\t\tteam_completion = total_completion / float(len(usrs))\n\t\t\n\treturn { \"consistency\" : team_consistency, \"completion\" : team_completion }","def getStats(population, masterList):\n for team in population:\n for i in range(13): #13 are the number of roster spots?\n team.totHr += masterList[team.roster[i]].hr\n team.totAvg += masterList[team.roster[i]].avg\n team.totRuns += masterList[team.roster[i]].runs\n team.totSb += masterList[team.roster[i]].sb\n team.totRbi += masterList[team.roster[i]].rbi\n if i == 12:\n team.totAvg = team.totAvg / 13\n return population","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def set_assists_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n team_tc_conv = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n player_tc_conv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0:\n result = (bx[\"assists\"] / (((bx[\"minutes\"] / (team[\"minutes\"] / 5)) * team_tc_conv) - player_tc_conv))*100\n result = result if result <= 100 and result >= 0 else 0\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.assists_percentage = \"%.2f\" % round(result, 2)","def main(simulations, userschoice):\n # The teams data are obtained from FIFA statistics\n # Team Name, Attack, Defence\n quarters = ['quarter1', 'quarter2', 'quarter3', 'quarter4', 'quarter5', 'quarter6', 'quarter7', 'quarter8']\n semifinalists = ['semifinalist1', 'semifinalist2', 'semifinalist3', 'semifinalist4']\n finalists = ['finalist1', 'finalist2']\n\n df = pd.read_csv('FifaRankings.csv', index_col=\"Ranking\")\n a_set = set()\n while True:\n a_set.add(randint(42, 85))\n if len(a_set) == 32:\n break\n lst1 = sorted(list(a_set), reverse=True)\n\n a_set = set()\n while True:\n a_set.add(randint(38, 83))\n if len(a_set) == 32:\n break\n lst2 = sorted(list(a_set), reverse=True)\n print(\"\\n\")\n df['Attack'] = lst1\n df['Defence'] = lst2\n a = list(df[\"Team\"])\n\n avgScored = 0\n avgConceded = 0\n avgScored = df['Attack'].sum()\n avgConceded = df['Defence'].sum()\n\n avgScored = avgScored / len(df)\n avgConceded = avgConceded / len(df)\n print(\"\\n\")\n avgattack = []\n avgdefense = []\n\n for i in range(1, 33):\n if df['Matches Played'][i] != 0:\n win_rate = (df['WorldCup Wins'][i] / df['Matches Played'][i])\n else:\n win_rate = 0\n avgattack.append((df['Attack'][i] / avgScored) + win_rate)\n avgdefense.append((df['Defence'][i] / avgConceded) + win_rate)\n\n df['Avg Attack'] = avgattack\n df['Avg Defense'] = avgdefense\n\n\n teamstats=[]\n for i in range(1,len(df)+1):\n teaminfo=[]\n teaminfo = (df[\"Team\"][i], df['Avg Attack'][i], df['Avg Defense'][i])\n teaminfo=list(teaminfo)\n teamstats.append(teaminfo)\n\n germany = WorldCupTeam(\"GERMANY\", teamstats)\n brazil = WorldCupTeam(\"BRAZIL\", teamstats)\n belgium = WorldCupTeam(\"BELGIUM\", teamstats)\n portugal = WorldCupTeam(\"PORTUGAL\", teamstats)\n argentina = WorldCupTeam(\"ARGENTINA\", teamstats)\n france = WorldCupTeam(\"FRANCE\", teamstats)\n switzerland = WorldCupTeam(\"SWITZERLAND\", teamstats)\n spain = WorldCupTeam(\"SPAIN\", teamstats)\n russia = WorldCupTeam(\"RUSSIA\", teamstats)\n japan = WorldCupTeam(\"JAPAN\", teamstats)\n polland=WorldCupTeam(\"POLLAND\", teamstats)\n korea_republic = WorldCupTeam(\"KOREA REPUBLIC\", teamstats)\n england = WorldCupTeam(\"ENGLAND\", teamstats)\n denmark= WorldCupTeam(\"DENMARK\", teamstats)\n peru= WorldCupTeam(\"PERU\", teamstats)\n tunisia=WorldCupTeam(\"TUNISIA\", teamstats)\n mexico = WorldCupTeam(\"MEXICO\", teamstats)\n colombia = WorldCupTeam(\"COLOMBIA\", teamstats)\n uruguay = WorldCupTeam(\"URUGUAY\", teamstats)\n croatia = WorldCupTeam(\"CROATIA\", teamstats)\n australia = WorldCupTeam(\"AUSTRALIA\", teamstats)\n iceland=WorldCupTeam(\"ICELAND\", teamstats)\n sweden=WorldCupTeam(\"SWEDEN\", teamstats)\n costa_rica = WorldCupTeam(\"COSTA RICA\", teamstats)\n senegal=WorldCupTeam(\"SENEGAL\", teamstats)\n serbia=WorldCupTeam(\"SERBIA\", teamstats)\n morrocco=WorldCupTeam(\"MORROCCO\", teamstats)\n egypt=WorldCupTeam(\"EGYPT\", teamstats)\n nigeria = WorldCupTeam(\"NIGERIA\", teamstats)\n saudi_arabia=WorldCupTeam(\"SAUDI ARABIA\", teamstats)\n panama=WorldCupTeam(\"PANAMA\", teamstats)\n iran = WorldCupTeam(\"IRAN\", teamstats)\n\n\n #INPUT USERS CHOICE FOR FIXED CHOICE\n choices= [\"random\", \"Random\", \"RANDOM\"]\n choicess = [\"fixed\", \"Fixed\", \"FIXED\"]\n if userschoice in choices:\n countries = [germany, brazil, belgium, portugal, argentina, france, switzerland, spain, russia, japan, polland,\n korea_republic, england, denmark, peru, tunisia, mexico, colombia, uruguay, croatia, australia,\n iceland, sweden, costa_rica, senegal, serbia, morrocco, egypt, nigeria, saudi_arabia, panama, iran]\n finalresults = {}\n\n GroupA, GroupB, GroupC, GroupD, GroupE, GroupF, GroupG, GroupH = ([] for i in range(8))\n\n Groups = [GroupA, GroupB, GroupC, GroupD, GroupE, GroupF, GroupG, GroupH]\n for i in Groups:\n for j in range(4):\n teamname = choice(countries)\n i.append(teamname)\n countries.remove(teamname)\n\n print(\"DRAWS for the WorldCup 2018 are:\")\n print(\"\\n\")\n for i in range(simulations):\n # Play first stage\n print(\"Result of\", i + 1, \"simulations\")\n print(\"--------------------------------------------\")\n print(\"This is GROUP STAGE\")\n print(\"\\n\")\n print(\"GROUP A RESULTS\")\n print(\"\\n\")\n groupA = TeamPool(Groups[0])\n print(\"\\n\")\n print(\"GROUP B RESULTS\")\n print(\"\\n\")\n groupB = TeamPool(Groups[1])\n print(\"\\n\")\n print(\"GROUP C RESULTS\")\n print(\"\\n\")\n groupC = TeamPool(Groups[2])\n print(\"\\n\")\n print(\"GROUP D RESULTS\")\n print(\"\\n\")\n groupD = TeamPool(Groups[3])\n print(\"\\n\")\n print(\"GROUP E RESULTS\")\n print(\"\\n\")\n groupE = TeamPool(Groups[4])\n print(\"\\n\")\n print(\"GROUP F RESULTS\")\n print(\"\\n\")\n groupF = TeamPool(Groups[5])\n print(\"\\n\")\n print(\"GROUP G RESULTS\")\n print(\"\\n\")\n groupG = TeamPool(Groups[6])\n print(\"\\n\")\n print(\"GROUP H RESULTS\")\n print(\"\\n\")\n groupH = TeamPool(Groups[7])\n\n # Play second stage\n print(\"\\n\")\n print(\"ROUND OF 16\")\n print(\"\\n\")\n r16 = [groupA.first_qualified, groupA.second_qualified, groupB.first_qualified, groupB.second_qualified,\n groupC.first_qualified, groupC.second_qualified, groupD.first_qualified, groupD.second_qualified,\n groupE.first_qualified, groupE.second_qualified, groupF.first_qualified, groupF.second_qualified,\n groupG.first_qualified, groupG.second_qualified, groupH.first_qualified, groupH.second_qualified]\n\n\n GroupP, GroupQ, GroupR, GroupS, GroupT, GroupU, GroupV, GroupW =([] for i in range(8))\n\n round16groups = [GroupP, GroupQ, GroupR, GroupS, GroupT, GroupU, GroupV, GroupW]\n\n for k in round16groups:\n for j in range(2):\n teamname = choice(r16)\n k.append(teamname)\n r16.remove(teamname)\n\n for i in range(8):\n quarters[i]=WorldCupMatch(round16groups[i][0], round16groups[i][1], False).winner\n\n # Quarters\n print(\"\\n\")\n print(\"QUARTER - FINALS\")\n print(\"\\n\")\n quarterfinal = [quarters[0], quarters[1], quarters[2], quarters[3], quarters[4], quarters[5], quarters[6],\n quarters[7]]\n GroupA1, GroupB1, GroupC1, GroupD1 = ([] for i in range(4))\n\n quarterfinalgroups = [GroupA1, GroupB1, GroupC1, GroupD1]\n\n i = 0\n for i in quarterfinalgroups:\n for j in range(2):\n teamname = choice(quarterfinal)\n i.append(teamname)\n quarterfinal.remove(teamname)\n\n for i in range(4):\n semifinalists[i] = WorldCupMatch(quarterfinalgroups[i][0], quarterfinalgroups[i][1], False).winner\n\n # Semifinals\n print(\"\\n\")\n print(\"SEMI - FINALS\")\n print(\"\\n\")\n\n semifinal = [semifinalists[0], semifinalists[1], semifinalists[2], semifinalists[3]]\n GroupP1, GroupQ1 = ([] for i in range(2))\n semifinalgroups = [GroupP1, GroupQ1]\n\n i = 0\n for i in semifinalgroups:\n for j in range(2):\n teamname = choice(semifinal)\n i.append(teamname)\n semifinal.remove(teamname)\n\n for i in range(2):\n finalists[i] = WorldCupMatch(semifinalgroups[i][0], semifinalgroups[i][1], False).winner\n # Finals\n print(\"\\n\")\n print(\"WORLD-CUP FINAL\")\n print(\"\\n\")\n winner = WorldCupMatch(finalists[0], finalists[1], False).winner\n print(\"\\n\")\n\n if winner.name in finalresults:\n finalresults[winner.name] += 1\n else:\n finalresults[winner.name] = 1\n\n for key in sorted(finalresults, key=finalresults.get, reverse=True):\n print(key + \": \" + str(finalresults[key] / simulations))\n ro=(finalresults[key] / simulations) * 100\n print(str(ro) + \"% chance of winning the worldcup\")\n print(\"\\n\")\n print(\"\\n\")\n\n\n elif userschoice in choicess:\n\n print(\"\\n\")\n finalresults = {}\n groupA1 = [russia , saudi_arabia,egypt, uruguay]\n groupB1 = [portugal, spain, morrocco, iran]\n groupC1 = [france, australia, peru, denmark]\n groupD1 = [argentina, iceland, croatia, nigeria]\n groupE1 = [brazil, switzerland, costa_rica, serbia]\n groupF1 = [germany, mexico, sweden, korea_republic]\n groupG1 = [belgium, panama, tunisia, england]\n groupH1 = [polland, senegal, colombia, japan]\n print(\"\\n\")\n for i in range(simulations):\n # Play first stage\n print(\"Result of\", i+1 ,\"simulations\")\n print(\"--------------------------------------------\")\n print(\"This is GROUP STAGE\")\n print(\"\\n\")\n print(\"GROUP A RESULTS\")\n print(\"\\n\")\n groupA = TeamPool(groupA1)\n print(\"\\n\")\n print(\"GROUP B RESULTS\")\n print(\"\\n\")\n groupB = TeamPool(groupB1)\n print(\"\\n\")\n print(\"GROUP C RESULTS\")\n print(\"\\n\")\n groupC = TeamPool(groupC1)\n print(\"\\n\")\n print(\"GROUP D RESULTS\")\n print(\"\\n\")\n groupD = TeamPool(groupD1)\n print(\"\\n\")\n print(\"GROUP E RESULTS\")\n print(\"\\n\")\n groupE = TeamPool(groupE1)\n print(\"\\n\")\n print(\"GROUP F RESULTS\")\n print(\"\\n\")\n groupF = TeamPool(groupF1)\n print(\"\\n\")\n print(\"GROUP G RESULTS\")\n print(\"\\n\")\n groupG = TeamPool(groupG1)\n print(\"\\n\")\n print(\"GROUP H RESULTS\")\n print(\"\\n\")\n groupH = TeamPool(groupH1)\n print(\"Qualifies teams:\", groupH.first_qualified.name)\n\n # Play second stage\n print(\"\\n\")\n print(\"ROUND OF 16\")\n print(\"\\n\")\n\n quarter1 = WorldCupMatch(groupA.first_qualified, groupA.second_qualified, False).winner\n quarter2 = WorldCupMatch(groupB.first_qualified, groupB.second_qualified, False).winner\n quarter3 = WorldCupMatch(groupC.first_qualified, groupC.second_qualified, False).winner\n quarter4 = WorldCupMatch(groupD.first_qualified, groupD.second_qualified, False).winner\n quarter5 = WorldCupMatch(groupE.first_qualified, groupE.second_qualified, False).winner\n quarter6 = WorldCupMatch(groupF.first_qualified, groupF.second_qualified, False).winner\n quarter7 = WorldCupMatch(groupG.first_qualified, groupG.second_qualified, False).winner\n quarter8 = WorldCupMatch(groupH.first_qualified, groupH.second_qualified, False).winner\n\n # Quarters\n print(\"\\n\")\n print(\"QUARTER - FINALS\")\n print(\"\\n\")\n\n semifinalist1 = WorldCupMatch(quarter1, quarter2, False).winner\n semifinalist2 = WorldCupMatch(quarter3, quarter4, False).winner\n semifinalist3 = WorldCupMatch(quarter5, quarter6, False).winner\n semifinalist4 = WorldCupMatch( quarter7, quarter8, False).winner\n\n # Semifinals\n print(\"\\n\")\n print(\"SEMI - FINALS\")\n print(\"\\n\")\n finalist1 = WorldCupMatch(semifinalist1, semifinalist2, False).winner\n finalist2 = WorldCupMatch(semifinalist3, semifinalist4, False).winner\n\n # Final\n print(\"\\n\")\n print(\"WORLD-CUP FINAL\")\n print(\"\\n\")\n winner = WorldCupMatch(finalist1, finalist2, False).winner\n print(\"\\n\")\n\n\n if winner.name in finalresults:\n finalresults[winner.name] += 1\n else:\n finalresults[winner.name] = 1\n\n for key in sorted(finalresults, key=finalresults.get, reverse=True):\n print(key + \": \" + str(finalresults[key] / simulations))\n rou = (finalresults[key] / simulations) * 100\n print(str(rou) + \"% chance of winning the worldcup\")\n print(\"\\n\")\n print(\"\\n\")\n else:\n print(\"Please enter correct input and try again\")\n pass","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def get_team_stats(players: list[Player]) -> dict[int]:\n\n team_stats = {}\n\n total_reaction = 0\n total_mechanical_skill = 0\n total_tactical_skill = 0\n total_game_knowledge = 0\n total_xp = 0\n\n for player in players:\n total_reaction += player.reaction\n total_mechanical_skill += player.mechanical_skill\n total_tactical_skill += player.tactical_skill\n total_game_knowledge += player.game_knowledge\n total_xp += player.xp\n\n team_stats.update(\n {\"reaction\": total_reaction,\n \"mechanical_skill\": total_mechanical_skill,\n \"tactical_skill\": total_tactical_skill,\n \"game_knowledge\": total_game_knowledge,\n \"xp\": total_xp})\n\n return team_stats","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def _get_percentages(games_table: pd.DataFrame, stats_table: pd.DataFrame,\n grouping_column: str) -> pd.DataFrame:\n stats_table[\n [\n \"total_free_throws_achieved\",\n \"total_free_throws_attempted\",\n \"total_two_point_achieved\",\n \"total_two_point_attempted\",\n \"total_three_point_achieved\",\n \"total_three_point_attempted\",\n ]\n ] = (\n games_table[\n [\n grouping_column,\n \"free_throws_achieved\",\n \"free_throws_attempted\",\n \"two_point_achieved\",\n \"two_point_attempted\",\n \"three_point_achieved\",\n \"three_point_attempted\",\n ]\n ]\n .groupby(grouping_column)\n .sum()\n .reset_index()\n .drop(grouping_column, axis=1)\n )\n\n stats_table[\"free_throws_pct\"] = (\n stats_table[\"total_free_throws_achieved\"] / stats_table[\"total_free_throws_attempted\"]\n )\n stats_table[\"two_point_pct\"] = (\n stats_table[\"total_two_point_achieved\"] / stats_table[\"total_two_point_attempted\"]\n )\n stats_table[\"three_point_pct\"] = (\n stats_table[\"total_three_point_achieved\"] / stats_table[\"total_three_point_attempted\"]\n )\n return stats_table","def processed_overall(self):\n self.processed_overall = (\n self.combine_both_winning_losing_games_stats\n .rename(columns={\"WTeamID\":\"TeamID\"})\n .pipe(lambda x:x.assign(fgp = x.total_fgm/x.total_fga))\n .pipe(lambda x:x.assign(fg3p = x.total_fg3m/x.total_fg3a))\n .pipe(lambda x:x.assign(ftp = x.total_ftm/x.total_fta))\n [['Season','TeamID','win_rate','total_score','total_opponent_score','fgp','fg3p','ftp', 'total_rebounds','total_off_rebounds','total_def_rebounds',\n 'total_off_rebounds_percent','total_def_rebounds_percent','total_rebound_possession_percent','total_rebound_possessiongain_percent','total_blocks',\n 'total_assists','total_steals','total_turnover','total_personalfoul','total_block_opp_FGA_percent','total_assist_per_fgm','total_assist_turnover_ratio',\n 'expectation_per_game','avg_lose_score_by','avg_win_score_by']]\n )","def get_player_stats_from_game(team, year, week):","def compute_stats(self):\n if self.stats is not None:\n return\n self.stats = np.zeros(STEPS_MAX + 1)\n for m in self.missions:\n m.compute_stats()\n self.stats += 100 * m.stats\n self.stats /= len(self.missions)","def cal_hit_ratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n score = 0.0\n # golden items hit in the top_K items\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\n score = score_1 - score_2\n return score/full['user'].nunique()","def ucbScore(self,totalPlayedTimes):\n winRate = self.winRate()\n #print totalPlayedTimes\n #print self.playedTimes\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\n \n return winRate + confidenceInterval","def winning_games_stats(self):\n self.winning_games_up_to_2013 = (\n self.df\n .pipe(lambda x:x.assign(winning_num_counts = 1))\n .query(\"Season <= 2013\")\n .groupby(['Season','WTeamID'])\n .agg({\"WScore\":\"sum\",\"WFGM\":\"sum\",\"WFGA\":\"sum\",\"WFGM3\":\"sum\",\"WFGA3\":\"sum\",\"WFTM\":\"sum\",\"WFTA\":\"sum\",\"LScore\":\"sum\",\"winning_num_counts\":\"sum\",\n \"WOR\":\"sum\",\"WDR\":\"sum\",\"LFGM\":\"sum\",\"LFGA\":\"sum\",\n \"WAst\":\"sum\",\"WTO\":\"sum\",\"WStl\":\"sum\",\"WBlk\":\"sum\",\"WPF\":\"sum\"})\n .reset_index()\n .rename(columns={\"LScore\":\"losing_opponent_score\"})\n # rebounds\n .pipe(lambda x:x.assign(total_winning_rebounds = x.WOR + x.WDR))\n .pipe(lambda x:x.assign(winning_off_rebounds_percent = x.WOR/x.total_winning_rebounds))\n .pipe(lambda x:x.assign(winning_def_rebounds_percent = x.WDR/x.total_winning_rebounds))\n .pipe(lambda x:x.assign(team_missed_attempts = x.WFGA - x.WFGM))\n .pipe(lambda x:x.assign(opp_team_missed_attempts = x.LFGA - x.LFGM))\n .pipe(lambda x:x.assign(winning_rebound_possession_percent = x.WOR/x.team_missed_attempts))\n .pipe(lambda x:x.assign(winning_rebound_possessiongain_percent = x.WDR/x.opp_team_missed_attempts))\n # blocks, steals, assists and turnovers\n .pipe(lambda x:x.assign(winning_block_opp_FGA_percent = x.WBlk/x.LFGA))\n .pipe(lambda x:x.assign(winning_assist_per_fgm = x.WAst/x.WFGM))\n .pipe(lambda x:x.assign(winning_assist_turnover_ratio = x.WAst/x.WTO))\n # rename columns to prevent duplication when joining with losing stats. example: WFGM_x\n .rename(columns={\"LFGA\":\"LFGA_opp\",\"LFGM\":\"LFGM_opp\"})\n )","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def advancedStats():","def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)","def get_stats(self):\n\n win_points = 0\n lose_points = 0\n\n for username in self.bets:\n bet_for_win, points = self.bets[username]\n if bet_for_win:\n win_points += points\n else:\n lose_points += points\n\n return win_points, lose_points","def calculate_scores(players):\n scores = {}\n for player in players.tuple_:\n scores[player.id_] = player.score()\n return scores","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def calculateWinRate():\n times = 10\n winRate = 0.0\n for i in range(times):\n game = Game('user', 6, 6)\n winRate += game.play(5, False, True, False, False)\n winRate = winRate/times\n print \"Winrate:\", winRate","def gamestats(self, table, curr_team):\n\n # Drop unneeded header \n tmp = table.iloc[1:,]\n # Fix the column names by reading line 0\n tmp.columns = [x.replace(\" \", \"\").replace(\"/\",\"\").replace(\".\",\"\") for x in tmp.iloc[0]]\n # Drop row zero which held the header row\n tmp = tmp.drop(tmp.index[0])\n # Forward fill the dates for defensive split later \n tmp['Date'].fillna(method='ffill', inplace = True)\n # Add in the team \n tmp['Team'] = curr_team\n # Create an offense/defense variable\n tmp['OffenseDefense'] = tmp['Opponent']\n # If it's not a defensive total then it's offense - set that in the offensedefense variable\n tmp['OffenseDefense'] = tmp['OffenseDefense'].apply(lambda x: \"Defense\" if x == \"Defensive Totals\" else \"Offense\")\n # Set the defensive totals in the opponent varaible to nullls\n tmp['Opponent'] = tmp['Opponent'].apply(lambda x: None if x == \"Defensive Totals\" else x)\n # Forward fill the opponents in for analysis later\n tmp['Opponent'].fillna(method='ffill', inplace = True)\n # Forward fill the results in for analysis later \n tmp['Result'].fillna(method='ffill', inplace = True)\n return tmp","def calculate(self):\n\n s_sum = 0\n class_num = len(self.scores)\n \n for i in range(class_num):\n s_sum += self.scores[i]\n\n av = float(s_sum)/class_num\n if av >= 90:\n return 'O'\n elif av >= 80:\n return 'E'\n elif av >= 70:\n return 'A'\n elif av >= 55:\n return 'P'\n elif av >= 40:\n return 'D'\n else:\n return 'T'","def test_get_team_strength(self):\n pass","def update_mean_and_count(self, strat_profile, game_outcome):\n self.total_interactions += 1\n for k in range(self.G.n_players):\n self.mu[k][strat_profile] *= self.count[k][strat_profile]\n self.mu[k][strat_profile] += game_outcome[k]\n self.count[k][strat_profile] += 1\n self.mu[k][strat_profile] /= self.count[k][strat_profile]\n\n for s in self.V:\n self.count_history[s].append(self.count[0][s] /\n float(self.total_interactions))","def stats(detections, faces):\n vp, fp, fn, vn = 0, 0, 0, 0\n max_label = np.max(faces[:, 0])\n for i in range(max_label + 1):\n detections_i = get_label_with_index(detections, i)\n faces_i = get_label_with_index(faces, i)\n local_vp = 0\n for face in faces_i:\n found = False\n for detection in detections_i:\n if intersection_ratio(face, detection) >= 0.5:\n found = True\n break\n if found:\n vp += 1\n local_vp += 1\n else:\n fn += 1\n fp += len(detections_i) - local_vp\n\n precision = vp / (vp + fp)\n rappel = vp / (vp + fn)\n f_score = 2 * ((precision * rappel) / (precision + rappel))\n\n return precision, rappel, f_score","def find_pcts_multi(P, start_b = [], iter = 10000):\n assert len(P) >= 2\n wins_per_player = [0] * len(P)\n all_hole = reduce(lambda x,y: x+y, P)\n for i in range(iter):\n deck = Deck()\n need = 5 - len(start_b)\n b2 = draw_sure(deck, need, all_hole+start_b)\n s = [evaluator.evaluate(start_b+b2, h) for h in P]\n for i, e in enumerate(s):\n if e == min(s):\n wins_per_player[i] += 1\n return [float(x) / sum(wins_per_player) for x in wins_per_player]","def cal_hit_gbratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\n score = 0.0\n # golden items hit in the top_K items\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\n\n #print(np.mean(score_ratio))\n #print(score_1)\n #score = score_1 + score_2\n return np.mean(score_ratio)","def pct(self):\n\t\treturn self.bottle.pct()","def per100_top_stat_players(game_type, stat, player_pk, excluded_pks, season_id=None):\n season = None\n if season_id:\n season = bmodels.Season.objects.get(id=season_id)\n\n if player_pk:\n players = bmodels.Player.objects.filter(pk=player_pk)\n else:\n players = bmodels.Player.objects.all().exclude(\n Q(first_name__contains=\"Team\") | Q(pk__in=excluded_pks))\n player_list = []\n for player in players:\n if season:\n result = player.statline_set.filter(game__game_type=game_type, game__date__range=(\n season.start_date, season.end_date)).aggregate(Sum(stat), Sum('off_pos'))\n else:\n result = player.statline_set.filter(\n game__game_type=game_type).aggregate(Sum(stat), Sum('off_pos'))\n if result['off_pos__sum'] and result['off_pos__sum'] is not 0:\n percentage = (result[stat + '__sum'] /\n result['off_pos__sum']) * 100\n else:\n percentage = 0.0\n player_list.append((player.first_name, percentage))\n return sorted(player_list, key=lambda x: x[1], reverse=True)","def percentage_40(set_):\n db = TinyDB(CARD_DATA_FILE)\n card_data = db.table('card_data')\n total = card_data.count(where('set') == set_)\n q = Query()\n num_forties = card_data.count((q.set == set_) & (q.commons == 4) & (q.rares == 1))\n\n print(num_forties/total)","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n #Between 1-8\n return own_moves / opp_moves","async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def update_stats(home_player: Player, away_player: Player,\n home_score: int, away_score: int) -> None:\n home_player.goals_for += home_score\n home_player.goals_against += away_score\n away_player.goals_for += away_score\n away_player.goals_against += home_score\n\n # home won\n if (home_score > away_score):\n home_player.wins += 1\n away_player.losses += 1\n # away won\n elif (home_score < away_score):\n home_player.losses += 1\n away_player.wins += 1\n # draw\n else:\n home_player.draws += 1\n away_player.draws += 1","def calculate_uptake_rate(team_members, issues):\n team_uptake_rate = {name: len([issue for issue in issues.values() if issue['assigned_to'] == name])/\n float(len([issue for issue in issues.values() if issue['assigned_to']]))\n for name in team_members}\n return team_uptake_rate","def getPercent(*args):","def getPercent(*args):","def percentage(count, total):\n return count / total * 100","def add_player_derived_stats(pl_stats, team_stats, opp_stats):\n pl_stats['FGP'] = gen_derived_var(pl_stats['FG'], pl_stats['FGA'])\n pl_stats['FTP'] = gen_derived_var(pl_stats['FT'], pl_stats['FTA'])\n pl_stats['THRP'] = gen_derived_var(pl_stats['THR'], pl_stats['THRA'])\n pl_stats['EFGP'] = gen_derived_var(pl_stats['FG'] + 0.5 *\n pl_stats['THR'], pl_stats['FGA'])\n pl_stats['TSA'] = pl_stats['FGA'] + 0.44 * pl_stats['FTA']\n pl_stats['TSP'] = gen_derived_var(pl_stats['PTS'], 2 * pl_stats['TSA'])\n pl_stats['THRAr'] = gen_derived_var(pl_stats['THRA'], pl_stats['FGA'])\n pl_stats['FTAr'] = gen_derived_var(pl_stats['FTA'], pl_stats['FGA'])\n pl_stats['TWOAr'] = gen_derived_var(pl_stats['TWOA'], pl_stats['FGA'])\n pl_stats['TWOP'] = gen_derived_var(pl_stats['TWO'], pl_stats['TWOA'])\n pl_stats['ORBr'] = gen_derived_var(pl_stats['ORB'], pl_stats['TRB'])\n pl_stats['DRBr'] = gen_derived_var(pl_stats['DRB'], pl_stats['TRB'])\n pl_stats['AST_to_TOV'] = gen_derived_var(pl_stats['AST'], pl_stats['TOV'])\n pl_stats['STL_to_TOV'] = gen_derived_var(pl_stats['STL'], pl_stats['TOV'])\n pl_stats['FIC'] = (pl_stats['PTS'] + pl_stats['ORB'] + 0.75 * pl_stats['DRB'] +\n pl_stats['AST'] + pl_stats['STL'] + pl_stats['BLK'] - 0.75 *\n pl_stats['FGA'] - 0.375 * pl_stats['FTA'] -\n pl_stats['TOV'] - 0.5 * pl_stats['PF'])\n pl_stats['FT_to_FGA'] = gen_derived_var(pl_stats['FT'], pl_stats['FGA'])\n\n team_stats['OPOS'] = gen_possessions(pl_stats, opp_stats)\n team_stats['DPOS'] = gen_possessions(opp_stats, pl_stats)\n team_stats['PACE'] = 48 * ((team_stats['OPOS'] + team_stats['DPOS']) / (2 * (float(team_stats['MP']) / 5)))\n\n # test for None\n pl_stats['ORBP'] = 100.0 * (pl_stats['ORB'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (team_stats['ORB'] + opp_stats['DRB']))\n pl_stats['DRBP'] = 100.0 * (pl_stats['DRB'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (team_stats['DRB'] + opp_stats['ORB']))\n pl_stats['TRBP'] = 100.0 * (pl_stats['TRB'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (team_stats['TRB'] + opp_stats['TRB']))\n pl_stats['ASTP'] = 100.0 * pl_stats['AST'] / (((float(pl_stats['MP']) / (team_stats['MP'] / 5)) * team_stats['FG']) - pl_stats['FG'])\n pl_stats['STLP'] = 100.0 * (pl_stats['STL'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * team_stats['DPOS'])\n pl_stats['BLKP'] = 100.0 * (pl_stats['BLK'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (opp_stats['FGA'] - opp_stats['THRA']))\n try:\n pl_stats['TOVP'] = 100.0 * pl_stats['TOV'] / (pl_stats['FGA'] + 0.44 * pl_stats['FTA'] + pl_stats['TOV'])\n except ZeroDivisionError:\n pl_stats['TOVP'] = None\n pl_stats['HOB'] = gen_derived_var(pl_stats['FG'] + pl_stats['AST'], team_stats['FG'])\n # pl_stats['+/-'] = pl_stats['+/-'] / pl_stats['N']","def __countPlayers(self, players):\n\n numLow = sum(map(lambda p: p.lowFps, players))\n numHigh = sum(map(lambda p: p.highFps, players))\n numMed = len(players) - numLow - numHigh\n\n return '%s, %s, %s' % (numLow, numMed, numHigh)","def get_score_percent(self, value):\n qs_related = RoundData.objects.prefetch_related(\n 'shotdata').select_related('shotdata')\n\n round_holes = int(self.round_type)\n\n if value == 'par':\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'birdie_better':\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'tbogey_worse':\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\n if isinstance(value, int):\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)","def walkout_percentage_average(df,start_year, end_year,bat_met, player_name):\n base_fields = ['PA']\n emp_list = check_base_fields(df,base_fields)\n\n if not emp_list:\n bb_val = round((pd.to_numeric(df['BB.'].str.split('%').str[0])/100)*df['PA'],0).sum()\n pa_total = df['PA'].fillna(0).sum()\n return \"{:.2%}\".format(bb_val / pa_total)\n else:\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\n return walkout_percentage_average(df,start_year, end_year,bat_met, player_name)","def get_fool_ratio(self, test_acc, attack_accs):\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]","def calc_stats(hits, misses):\n try:\n result = (float(misses) / float(hits)) * 100.0\n except ZeroDivisionError:\n if misses == 0:\n result = 0.0\n else:\n result = 100.0\n return result","def calculate_score(player_cards):\n score = sum(player_cards)\n return score","def scoreTeams(curTeams, oppTeam, pokedex, league, minDistWanted):\n battleData, htmlData = loadBattleData(league)\n similarities = loadSims() \n \n #If not given an opponent team then simply randomly choose losers from the dataset to compare to.\n if len(oppTeam) == 0:\n picks = set([])\n while (len(picks) < NUMLOSINGTEAMS and (not len(picks) == len(battleData))):\n picks.add(random.randint(0,len(battleData)-1))\n\n losers = []\n loserDict = {}\n for i in picks:\n entry = battleData[i]\n winner,loser = determineWinner(entry)\n loserDict[str(loser)] = [winner]\n losers.append( (loser,0) )\n\n #Given opponent team then find similar teams\n else:\n oppTeam = [getSimPokemon(opp,similarities) for opp in oppTeam]\n\n #create dictionary from losers team to the team that beat them.\n loserDict = {}\n sims = []\n for d in battleData:\n winner, loser = determineWinner(d)\n\n wTeam = teamToArray(winner,pokedex)\n lTeam = np.array(teamToArray(loser, pokedex))\n\n score = 0\n for oppNp in oppTeam:\n score+= np.amax(lTeam*oppNp) \n\n if str(loser) in loserDict:\n loserDict[str(loser)].append(winner)\n else:\n #new to dictonary\n loserDict[str(loser)] = [winner]\n\n sims.append((loser, score))\n\n\n sims = sorted(sims, key = lambda x : x[1], reverse = True)\n\n cutoff = min(len(sims),NUMLOSINGTEAMS)\n losers = sims[:cutoff]\n\n #Gather winners to losing teams\n winnersComp = []\n for loser,_ in losers:\n for winner in loserDict[str(loser)]:\n winnersComp.append(teamToArray(winner,pokedex))\n \n topScore = len(winnersComp)*6 #pkmn team size\n\n results = []\n inverted_idx = {}\n\n existsSet = []\n\n #Creates inverted index for teams, while simoultaneously weeding out any teams that are exactly similar.\n for i in range(len(curTeams)):\n team = curTeams[i]\n results.append((team,0))\n sTeam = set(team)\n if not (sTeam in existsSet):\n existsSet.append(sTeam)\n for pkm in team:\n if pkm != EMPTY:\n if pkm in inverted_idx:\n inverted_idx[pkm].append(i)\n else:\n inverted_idx[pkm] = [i]\n \n #Giving the similiarity scores to the winners based off of the inverted index.\n for pkm in inverted_idx:\n for winner in winnersComp:\n wArr = np.array(winner)\n #tArr = getSimPokemon(pkm,similarities)\n tArr = similarities[pkm]\n \n vals = wArr * tArr\n\n score = np.amax(vals)\n\n for i in inverted_idx[pkm]:\n results[i] = (results[i][0],results[i][1]+(score/topScore))\n\n results = sorted(results, key = lambda x : x[1], reverse = True)\n\n if len(results) < NUMTEAMSRETURN:\n if len(results) == 0:\n returnTeams = [[] for x in range(NUMTEAMSRETURN)]\n teamScores = [0 for x in range(NUMTEAMSRETURN)]\n\n else:\n returnTeams = [result[0] for result in results]\n teamScores = [result[1] for result in results]\n else:\n firstResult, firstScore = results[0]\n returnTeams = [firstResult]\n teamScores = [round(firstScore*100,1)]\n returnSets = [set(firstResult)]\n \n i = 1\n\n #Loops through results and adds teams with the proper edit distance away.\n while(len(returnTeams) < NUMTEAMSRETURN and minDistWanted > 0):\n teamToConsider,teamToConsiderScore = results[i]\n \n considerSet = set(teamToConsider)\n add = True\n ##checks the edit distance of teams is above wanted\n for team in returnSets:\n if len(team.union(considerSet)) < len(team)+minDistWanted:\n add = False\n\n ##If indeed above wanted levels then add\n if add:\n returnTeams.append(teamToConsider)\n returnSets.append(considerSet)\n teamScores.append(round(teamToConsiderScore*100,1))\n \n i+=1\n\n if i >= len(results):\n i = 1\n minDistWanted -= 1 \n \n winHtmls = []\n if htmlData != None:\n for team,_ in losers:\n for winner in loserDict[str(team)]:\n winHtmls.extend(htmlData[str(sorted(winner))])\n \n\n return returnTeams, teamScores, winHtmls","def updateSuit(self, playersView: Player, ofPlayer: Player, suit: Suit):\n deck = [Card(suit, val) for val in range(2, 14 + 1)]\n\n playersProb = self[playersView, ofPlayer, :]\n\n for otherPlayer in Player:\n if otherPlayer != playersView and otherPlayer != ofPlayer:\n for card in deck:\n self[playersView, otherPlayer, card] += (playersProb[card.__hash__()] / 2)\n\n for card in deck:\n self[playersView, ofPlayer, card] = 0","def marcels_players(goalie, date, df):\n # 0 = that year, 1 is year b4 ....\n marcel_weights = [.36, .29, .21, .14]\n reg_const = 2000\n reg_avg = 0 # Where to regress to\n\n # Use past 3 season to weight games played -> Just take weighted average\n gp_weights = [8, 4, 2, 0]\n\n season = int(helpers.get_season(date))\n\n weighted_goals_sum, weighted_fen_sum, weighted_xg_sum, weights_marcel_sum = 0, 0, 0, 0\n weighted_gp_sum, weights_gp_sum = 0, 0\n\n # Past 4 Seasons\n for i in range(0, 4):\n if season - i > 2006:\n # Subset from stats df\n df_goalie = df[(df['player'] == goalie) & (df['season'] == (season - i))]\n\n # Sanity Check\n if df_goalie.shape[0] > 1:\n print(\"Too many rows!!!!!!!\")\n exit()\n\n # If he played that year\n if not df_goalie.empty:\n weighted_goals_sum += df_goalie.iloc[0]['goals_a'] * marcel_weights[i]\n weighted_fen_sum += df_goalie.iloc[0]['fenwick_a'] * marcel_weights[i]\n weighted_xg_sum += df_goalie.iloc[0]['xg_a'] * marcel_weights[i]\n weighted_gp_sum += df_goalie.iloc[0]['games'] * gp_weights[i]\n\n # -> To divide by at end...normalize everything\n weights_marcel_sum += marcel_weights[i]\n weights_gp_sum += gp_weights[i]\n\n # Normalize weighted sums\n weighted_xg_sum = weighted_xg_sum / weights_marcel_sum if weights_marcel_sum != 0 else 0\n weighted_goals_sum = weighted_goals_sum / weights_marcel_sum if weights_marcel_sum != 0 else 0\n weighted_fen_sum = weighted_fen_sum / weights_marcel_sum if weights_marcel_sum != 0 else 0\n\n # Get Regressed fsv%\n if weighted_fen_sum != 0:\n weighted_adj_fsv = ((1 - weighted_goals_sum / weighted_fen_sum) - (1 - weighted_xg_sum / weighted_fen_sum)) * 100\n else:\n weighted_adj_fsv = 0\n reg_adj_fsv = weighted_adj_fsv - ((weighted_adj_fsv - reg_avg) * (reg_const / (reg_const + weighted_fen_sum)))\n\n # Get weighted gp\n weighted_gp_sum = weighted_gp_sum / weights_gp_sum if weights_gp_sum != 0 else 0\n\n return {'fsv': reg_adj_fsv, 'gp': weighted_gp_sum}","def set_steals_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n poss = self.get_team_possessions()\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((bx[\"steals\"] * (team[\"minutes\"]/Decimal('5'))) / Decimal(float(bx[\"minutes\"]) * poss)) * 100\n self.steals_percentage = \"%.2f\" % round(result, 2)","def set_tichu_percentage(threshold):\n tichu_threshold = threshold\n tichu_cnt = 0\n deck = Deck()\n players = [Player(id=0), Player(id=1), Player(id=2), Player(id=3)]\n for i in range(100):\n myhands = deck.shuffle_and_deal()\n for idx in range(4):\n players[idx].assign_hand(myhands[idx])\n score = players[idx].hand_rating\n if score > tichu_threshold:\n tichu_cnt += 1\n players[idx].hand.show()\n print('Player calls Tichu with a hand rating of {:.1f}.'.format(score))\n print('\\n')\n print('Tichu percentage: {:.2f}'.format(tichu_cnt/100))","def get_effective_team_stats(team_stats: dict) -> int:\n\n # TODO: Problem effective stats <-> value\n # value = int((reaction * 0.5 + technical_skill * 1.5 + tactical_skill * 1.5 + game_knowledge) * xp)\n\n stats_sum = 0\n\n for value in team_stats.values():\n stats_sum += value * random.uniform(0.5, 1.5)\n\n return stats_sum","def get_scores(self, tournament: Tournament):\n self.model.eval()\n # collate_fn = lambda x: collate_teams(x, tournament.max_members)\n dl_rank = DataLoader(tournament.ranking, num_workers=self.jobs, batch_size=self.bs, shuffle=False)\n iterator = tqdm(dl_rank, position=0, desc=f'{tournament.tournament_id} ranking', disable=True)\n scores = []\n for i, team in enumerate(iterator):\n score = self.model.get_team_score(team.to(self.device))\n scores.append(score.cpu().numpy())\n\n scores = np.concatenate(scores)\n return scores.flatten()","def get_team_scores(self, team, include_home=True, include_away=True):\n if include_away:\n away_games = list(filter(lambda g: team == g.AwayTeam, self.games))\n else:\n away_games = []\n\n if include_home:\n home_games = list(filter(lambda g: team == g.HomeTeam, self.games))\n else:\n home_games = []\n\n scored_h = [g.FTHG for g in home_games]\n scored_a = [g.FTAG for g in away_games]\n\n conceded_h = [g.FTAG for g in home_games]\n conceded_a = [g.FTHG for g in away_games]\n\n try:\n mean_gd = mean(scored_h + scored_a) - mean(conceded_h + conceded_a)\n home_gd = mean(scored_h) - mean(conceded_h)\n home_adv = home_gd - mean_gd\n except Exception:\n home_adv = 0\n\n return {\n \"scored_xg\": scored_h + scored_a,\n \"conceded_xg\": conceded_h + conceded_a,\n \"home_adv\": home_adv,\n \"expected_points\": self.get_table(metric='points')[team] /\n len(home_games + away_games)\n }","def set_assists_per_turnover(self):\n bx = self.get_standard_stats()\n ratio = bx[\"assists\"]\n if bx[\"turnovers\"] > 0:\n ratio = bx[\"assists\"] / bx[\"turnovers\"]\n self.assists_per_turnover = \"%.2f\" % round(ratio, 2)","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def get_new_ratings(players, teams):\n nb_players_team0 = len(teams[0])\n nb_players_team1 = len(teams[1])\n winner = players[teams[0][0]]\n loser = players[teams[1][0]]\n if nb_players_team0 == 1 and nb_players_team1 == 1:\n new_r1, new_r3 = rate_1vs1(winner,loser)\n elif nb_players_team0 == 1 and nb_players_team1 > 1:\n team_loser = [loser, players[teams[1][1]]]\n (new_r1), (new_r3, new_r4) = rate([winner, team_loser], ranks=[0, 1]) \n elif nb_players_team0 > 1 and nb_players_team1 == 1:\n team_winner = [winner, players[teams[0][1]]]\n (new_r1, new_r2), (new_r3) = rate([team_winner, loser], ranks=[0, 1]) \n else:\n team_loser = [loser, players[teams[1][1]]]\n team_winner = [winner, players[teams[0][1]]]\n (new_r1, new_r2), (new_r3, new_r4) = rate([team_winner, team_loser], ranks=[0, 1]) \n player1 = {'name': teams[0][0], 'mu': new_r1.mu, 'sigma': new_r1.sigma}\n player3 = {'name': teams[1][0], 'mu': new_r3.mu, 'sigma': new_r3.sigma}\n if nb_players_team0 > 1:\n player2 = {'name': teams[0][1], 'mu': new_r2.mu, 'sigma': new_r2.sigma}\n if nb_players_team1 > 1:\n player4 = {'name': teams[1][1], 'mu': new_r4.mu, 'sigma': new_r4.sigma}\n if nb_players_team0 > 1:\n return [player1, player2, player3, player4]\n return [player1, player2, player4]\n return [player1, player3]","def U_Function(currentPlayer, oppositePlayer, N, maxEntity):\n EndPointPlayer1 = Posisi.Posisi(N - 1, N - 1)\n EndPointPlayer2 = Posisi.Posisi(0, 0)\n \n sumPionPlayer1 = 0\n sumPionPlayer2 = 0\n\n if (currentPlayer.noPlayer == 1):\n for Pion in currentPlayer.arrayPion:\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\n for Pion in oppositePlayer.arrayPion:\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\n \n if (currentPlayer.noPlayer == 2):\n for Pion in currentPlayer.arrayPion:\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\n for Pion in oppositePlayer.arrayPion:\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\n\n if (maxEntity == 1):\n return -sumPionPlayer1 + sumPionPlayer2\n else:\n return -sumPionPlayer2 + sumPionPlayer1","def add_team_derived_stats(stats, opp_stats):\n stats['FGP'] = gen_derived_var(stats['FG'], stats['FGA'])\n stats['FTP'] = gen_derived_var(stats['FT'], stats['FTA'])\n stats['THRP'] = gen_derived_var(stats['THR'], stats['THRA'])\n stats['EFGP'] = gen_derived_var(stats['FG'] + 0.5 *\n stats['THR'], stats['FGA'])\n stats['TSA'] = stats['FGA'] + 0.44 * stats['FTA']\n stats['TSP'] = gen_derived_var(stats['PTS'], 2 * stats['TSA'])\n stats['THRAr'] = gen_derived_var(stats['THRA'], stats['FGA'])\n stats['FTAr'] = gen_derived_var(stats['FTA'], stats['FGA'])\n stats['TWOAr'] = gen_derived_var(stats['TWOA'], stats['FGA'])\n stats['TWOP'] = gen_derived_var(stats['TWO'], stats['TWOA'])\n stats['ORBr'] = gen_derived_var(stats['ORB'], stats['TRB'])\n stats['DRBr'] = gen_derived_var(stats['DRB'], stats['TRB'])\n stats['AST_to_TOV'] = gen_derived_var(stats['AST'], stats['TOV'])\n stats['STL_to_TOV'] = gen_derived_var(stats['STL'], stats['TOV'])\n stats['FIC'] = (stats['PTS'] + stats['ORB'] + 0.75 * stats['DRB'] +\n stats['AST'] + stats['STL'] + stats['BLK'] - 0.75 *\n stats['FGA'] - 0.375 * stats['FTA'] -\n stats['TOV'] - 0.5 * stats['PF'])\n stats['FT_to_FGA'] = gen_derived_var(stats['FT'], stats['FGA'])\n\n stats['OPOS'] = gen_possessions(stats, opp_stats)\n stats['DPOS'] = gen_possessions(opp_stats, stats)\n stats['PACE'] = 48 * ((stats['OPOS'] + stats['DPOS']) / (2 * (float(stats['MP']) / 5)))\n\n stats['ORBP'] = stats['ORB'] / (stats['ORB'] + opp_stats['DRB'])\n stats['DRBP'] = stats['DRB'] / (stats['DRB'] + opp_stats['ORB'])\n stats['TRBP'] = stats['TRB'] / (stats['TRB'] + opp_stats['TRB'])\n stats['ASTP'] = stats['AST'] / stats['FG']\n stats['STLP'] = stats['STL'] / stats['DPOS']\n stats['BLKP'] = stats['BLK'] / opp_stats['TWOA']\n stats['TOVP'] = stats['TOV'] / stats['OPOS']\n # stats['+/-'] = stats['+/-'] / stats['N']","def score(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= SQUARE_WEIGHTS[i]\r\n else:\r\n numOpp+=SQUARE_WEIGHTS[i]\r\n return numPlayer-numOpp","def calc_adv_U(self):\n num_U = 0\n adv_U = numpy.zeros((3,3), float)\n\n for atm in self:\n ## use the atom's U matrix if it exists, otherwise use the\n ## temperature factor\n\n if atm.U is not None:\n adv_U += atm.U\n num_U += 1\n\n return adv_U / num_U","def recalculate_popularity(self):\n self.voters = 0\n for x in self.votes:\n self.voters += 1\n if x.good:\n self.popularity += 1\n else:\n self.popularity -= 1","def find_pcts(p1, p2, start_b = [], iter = 10000):\n win_record = []\n for i in range(iter):\n deck = Deck()\n need = 5 - len(start_b)\n b2 = draw_sure(deck, need, p1+p2+start_b)\n win_record.append(_who_wins(start_b + b2, p1, p2, printout = False))\n return [win_record.count(1) / float(len(win_record)), \n win_record.count(2) / float(len(win_record))\n ]","def _compute_global_stats():\n global_stats = []\n \n wmt16_group = Group.objects.filter(name='WMT16')\n wmt16_users = _get_active_users_for_group(wmt16_group)\n \n # Check how many HITs have been completed. We now consider a HIT to be\n # completed once it has been annotated by one or more annotators.\n #\n # Before we required `hit.users.count() >= 3` for greater overlap.\n hits_completed = HIT.objects.filter(mturk_only=False, completed=True).count()\n \n # Check any remaining active HITs which are not yet marked complete.\n for hit in HIT.objects.filter(active=True, mturk_only=False, completed=False):\n if hit.users.count() >= 1:\n hits_completed = hits_completed + 1\n hit.completed = True\n hit.save()\n \n # Compute remaining HITs for all language pairs.\n hits_remaining = HIT.compute_remaining_hits()\n \n # Compute number of results contributed so far.\n ranking_results = RankingResult.objects.filter(\n item__hit__completed=True, item__hit__mturk_only=False)\n \n from math import factorial\n system_comparisons = 0\n for result in ranking_results:\n result.reload_dynamic_fields()\n # TODO: this implicitly counts A=B comparisons for multi systems.\n # Basically, inflating the number of pairwise comparisons... Fix!\n combinations = factorial(result.systems)/(factorial(result.systems-2) * 2) if result.systems > 2 else 0\n system_comparisons = system_comparisons + combinations\n \n # Aggregate information about participating groups.\n groups = set()\n for user in wmt16_users:\n for group in _identify_groups_for_user(user):\n groups.add(group)\n \n # Compute average/total duration over all results.\n durations = RankingResult.objects.all().values_list('duration', flat=True)\n total_time = sum([datetime_to_seconds(x) for x in durations])\n avg_time = total_time / float(hits_completed or 1)\n avg_user_time = total_time / float(3 * hits_completed or 1)\n \n global_stats.append(('Users', len(wmt16_users)))\n global_stats.append(('Groups', len(groups)))\n global_stats.append(('HITs completed', '{0:,}'.format(hits_completed)))\n global_stats.append(('HITs remaining', '{0:,}'.format(hits_remaining)))\n global_stats.append(('Ranking results', '{0:,}'.format(ranking_results.count())))\n global_stats.append(('System comparisons', '{0:,}'.format(system_comparisons)))\n global_stats.append(('Average duration (per HIT)', seconds_to_timedelta(avg_time)))\n global_stats.append(('Average duration (per task)', seconds_to_timedelta(avg_user_time)))\n global_stats.append(('Total duration', seconds_to_timedelta(total_time)))\n \n # Create new status data snapshot\n TimedKeyValueData.update_status_if_changed('users', str(len(wmt16_users)))\n TimedKeyValueData.update_status_if_changed('groups', str(len(groups)))\n TimedKeyValueData.update_status_if_changed('hits_completed', str(hits_completed))\n TimedKeyValueData.update_status_if_changed('hits_remaining', str(hits_remaining))\n TimedKeyValueData.update_status_if_changed('ranking_results', str(ranking_results.count()))\n TimedKeyValueData.update_status_if_changed('system_comparisons', str(system_comparisons))\n TimedKeyValueData.update_status_if_changed('duration_per_hit', str(seconds_to_timedelta(avg_time)))\n TimedKeyValueData.update_status_if_changed('duration_per_task', str(seconds_to_timedelta(avg_user_time)))\n TimedKeyValueData.update_status_if_changed('duration_total', str(seconds_to_timedelta(total_time)))\n \n return global_stats","def get_team_stats() -> List[BaseStat]:\n return [PossessionStat(),\n TeamTendencies(),\n RelativeTendencies(),\n PerPossessionStat(),\n RumbleItemStat(),\n PreRumbleGoals(),\n DropshotStats()\n ]","def evaluate_power(soldier_list: List[Soldier]):\n inf_count = 0\n inf_avg_weapon = 0.0\n inf_avg_armor = 0.0\n arc_count = 0\n arc_avg_weapon = 0.0\n arc_avg_armor = 0.0\n cvl_count = 0\n cvl_avg_weapon = 0.0\n cvl_avg_armor = 0.0\n \n for soldier in soldier_list:\n ################################# YOUR CODE HERE #################################\n if soldier.typecode == \"ARC\":\n arc_count += 1\n arc_avg_armor += soldier.armor\n arc_avg_weapon += soldier.weapon\n elif soldier.typecode == \"INF\":\n inf_count += 1\n inf_avg_armor += soldier.armor\n inf_avg_weapon += soldier.weapon\n elif soldier.typecode == \"CVL\":\n cvl_count += 1\n cvl_avg_armor += soldier.armor\n cvl_avg_weapon += soldier.weapon\n if arc_count != 0:\n arc_avg_armor /= arc_count\n arc_avg_weapon /= arc_count\n\n if cvl_count != 0:\n cvl_avg_armor /= cvl_count\n cvl_avg_weapon /= cvl_count\n\n if inf_count != 0:\n inf_avg_armor /= inf_count\n inf_avg_weapon /= inf_count\n ##################################################################################\n return (inf_count, inf_avg_weapon, inf_avg_armor), (arc_count, arc_avg_weapon, arc_avg_armor), (cvl_count, cvl_avg_weapon, cvl_avg_armor)","def __calculateNormalizedScores(self):\n year_scores = {0 : []}\n for venue in self.venue_scores:\n v_scores = []\n for year in self.venue_scores[venue]:\n v_scores.append(self.venue_scores[venue][year])\n if year not in year_scores:\n year_scores[year] = []\n year_scores[year].append(self.venue_scores[venue][year])\n x_year = np.average(np.array(v_scores))\n self.venue_scores[venue][0] = x_year\n year_scores[0].append(x_year)\n \n ##for standardization\n #year_metrics = {x : (np.average(np.array(year_scores[x])), np.std(np.array(year_scores[x]))) for x in year_scores}\n ##for normalization\n year_metrics = {x: (max(year_scores[x]), min(year_scores[x])) for x in year_scores}\n \n #print year_metrics\n \n for venue in self.venue_scores:\n self.normalized_scores[venue] = dict()\n for year in self.venue_scores[venue]:\n #self.standard_scores[venue][year] = round((self.venue_scores[venue][year] - year_metrics[year][0]) / year_metrics[year][1],5)\n #self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1]) / (year_metrics[year][0] - year_metrics[year][1]) + eps\n self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1] + self.epsilon) / (year_metrics[year][0] - year_metrics[year][1] + self.epsilon)","def get_total_health(self,obs):\n total_health = 0\n for unit in obs.observation.raw_units:\n if(unit.alliance == PlayerRelative.SELF):\n total_health += unit[FeatureUnit.health]\n return total_health","def percentage(self):\n temp = self.cpu_freq_time_spent.copy()\n for i in self.cpu_freq_time_spent:\n total = 0\n for j in self.cpu_freq_time_spent[i]:\n total += self.cpu_freq_time_spent[i][j]\n for j in self.cpu_freq_time_spent[i]:\n if total != 0:\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\n else:\n temp[i][j] = 0\n return temp","def calculate_profit(self):","def get_list_team_scores(self):\n scores = defaultdict(lambda: {\n \"scored_xg\": [],\n \"conceded_xg\": [],\n \"home_adv\": 0,\n \"expected_points\": 0\n })\n\n for g in self.games:\n scores[g.HomeTeam][\"scored_xg\"].append(g.FTHG)\n scores[g.HomeTeam][\"conceded_xg\"].append(g.FTAG)\n scores[g.AwayTeam][\"scored_xg\"].append(g.FTAG)\n scores[g.AwayTeam][\"conceded_xg\"].append(g.FTHG)\n\n for team in scores.keys():\n scores[team][\"expected_points\"] = (self.get_table(metric='points')[team] /\n len(scores[team][\"scored_xg\"]))\n\n return scores","def get_percentage_sf_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_sf)/(votes_f + votes_sf)\n return round(ratio * 100, 1)","def set_offensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0 and (bx[\"t2p_int\"] + bx[\"t3p_int\"]) > 0:\n fgm = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n fga = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n team_fgm = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n team_fga = team[\"t2p_int\"] + team[\"t3p_int\"]\n team_points = team[\"t2p_conv\"]*2 + team[\"t3p_conv\"]*3 + team[\"tl_conv\"]\n points = bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"]\n\n try:\n qAST = (Decimal(bx[\"minutes\"] / (team[\"minutes\"] / 5)) * (Decimal('1.14') * Decimal((team[\"assists\"] - bx[\"assists\"]) / team_fgm))) + \\\n Decimal((((team[\"assists\"] / team[\"minutes\"]) * bx[\"minutes\"] * 5 - bx[\"assists\"]) / ((team_fgm / team[\"minutes\"]) * bx[\"minutes\"] * 5 - fgm)) * (1 - (bx[\"minutes\"] / (team[\"minutes\"] / 5))))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n qAST = 1\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n qAST = 1\n\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2*(team_fga - fga))) * bx[\"assists\"]\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n ast_part = 0\n\n if bx[\"tl_int\"] > 0:\n ft_part = Decimal(1 - (1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_part = 0\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\"tl_conv\"] / team[\"tl_int\"]))**2) * team[\"tl_int\"] * Decimal('0.4'))\n try:\n team_orb_percentage = Decimal(team[\"reb_of\"] / (team[\"reb_of\"] + ((opp_team[\"reb_def\"] + opp_team[\"reb_of\"]) - opp_team[\"reb_of\"])))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\"tl_int\"] * Decimal('0.4') + team[\"turnovers\"]))\n try:\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_weight = 0\n\n orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage\n\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\n if bx[\"tl_conv\"] > 0:\n ft_x_poss = Decimal((1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_x_poss = Decimal(1 - (bx[\"tl_conv\"] / 1)**2) * Decimal('0.4') * bx[\"tl_int\"]\n try:\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n sc_poss =0\n\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\"turnovers\"]\n\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\"t3p_conv\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\"t3p_conv\"] - bx[\"t3p_conv\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2 * (team_fga - fga))) * bx[\"assists\"]\n except:\n pprod_ast_part = 0\n\n pprod_orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\"tl_conv\"] / team[\"tl_int\"])**2) * Decimal('0.4') * team[\"tl_int\"]))\n try:\n pprod = (pprod_fg_part + pprod_ast_part + bx[\"tl_conv\"]) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n pprod = 0\n\n try:\n result = 100 * (pprod / tot_poss)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n result = 0\n\n # print(\"fgm: \" + str(fgm))\n # print(\"fga: \" + str(fga))\n # print(\"team_fgm: \" + str(team_fgm))\n # print(\"team_fga: \" + str(team_fga))\n # print(\"team_points: \" + str(team_points))\n # print(\"points: \" + str(points))\n # print(\"qAST: \" + str(qAST))\n # print(\"fg_part: \" + str(fg_part))\n # print(\"ast_part: \" + str(ast_part))\n # print(\"ft_part: \" + str(ft_part))\n # print(\"team_scoring_poss: \" + str(team_scoring_poss))\n # print(\"team_orb_percentage: \" + str(team_orb_percentage))\n # print(\"team_play_percentage: \" + str(team_play_percentage))\n # print(\"team_orb_weight: \" + str(team_orb_weight))\n # print(\"orb_part: \" + str(orb_part))\n # print(\"fg_x_poss: \" + str(fg_x_poss))\n # print(\"ft_x_poss: \" + str(ft_x_poss))\n # print(\"sc_poss: \" + str(sc_poss))\n # print(\"tot_poss: \" + str(tot_poss))\n # print(\"pprod_fg_part: \" + str(pprod_fg_part))\n # print(\"pprod_ast_part: \" + str(pprod_ast_part))\n # print(\"pprod_orb_part: \" + str(pprod_orb_part))\n # print(\"pprod: \" + str(pprod))\n # print(\"result: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n\n self.ortg = \"%.2f\" % round(result, 2)\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\n \"\"\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \n using team's formula\"\"\"\n print(BCOLORS.OKBLUE + \"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\" + BCOLORS.ENDC)\n bx = self.get_standard_stats()\n result = round((bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])/self.get_team_possessions(), 2)\n self.ortg = \"%.2f\" % result","def cumulative_stats_for_teams_each_year(self):\n self.cumulative_stats_for_team_each_year = (\n self.combine_both_winning_losing_games_stats\n .sort_values(['WTeamID','Season'])\n .groupby(['WTeamID'])\n .cumsum()\n .pipe(lambda x:x.assign(Season = self.combine_both_winning_losing_games_stats.Season.values))\n .pipe(lambda x:x.assign(TeamID = self.combine_both_winning_losing_games_stats.WTeamID.values))\n .drop(['LTeamID','win_rate'],1)\n .pipe(lambda x:x.assign(win_rate = x.winning_num_counts/(x.winning_num_counts + x.losing_num_counts)))\n .pipe(lambda x:x.assign(WFGP = x.WFGM/x.WFGA))\n .pipe(lambda x:x.assign(WFG3P = x.WFGM3/x.WFGA3))\n .pipe(lambda x:x.assign(WFTP = x.WFTM/x.WFTA))\n .pipe(lambda x:x.assign(LFGP = x.LFGM/x.LFGA))\n .pipe(lambda x:x.assign(LFG3P = x.LFGM3/x.LFGA3))\n .pipe(lambda x:x.assign(LFTP = x.LFTM/x.LFTA))\n .pipe(lambda x:x.assign(fgp = x.total_fgm/x.total_fga))\n .pipe(lambda x:x.assign(fg3p = x.total_fg3m/x.total_fg3a))\n .pipe(lambda x:x.assign(ftp = x.total_ftm/x.total_fta))\n # rebounds cumsum stats\n .pipe(lambda x:x.assign(total_def_rebounds_percent = x.total_def_rebounds/x.total_rebounds))\n .pipe(lambda x:x.assign(total_off_rebounds_percent = x.total_off_rebounds/x.total_rebounds))\n .pipe(lambda x:x.assign(total_rebound_possession_percent = x.total_off_rebounds/x.total_team_missed_attempts))\n .pipe(lambda x:x.assign(total_rebound_possessiongain_percent = x.total_def_rebounds/x.total_opp_team_missed_attempts))\n # assists, turnovers, steals, blocks and personal fouls\n .pipe(lambda x:x.assign(total_block_opp_FGA_percent = x.total_blocks/x.total_opp_fga))\n .pipe(lambda x:x.assign(total_assist_per_fgm = x.total_assists/x.total_fgm))\n .pipe(lambda x:x.assign(total_assist_turnover_ratio = x.total_assists/x.total_turnover))\n # win or lose by how many points\n .pipe(lambda x:x.assign(lose_rate = 1-x.win_rate))\n .pipe(lambda x:x.assign(win_score_by = x.WScore - x.losing_opponent_score))\n .pipe(lambda x:x.assign(lose_score_by = x.LScore - x.winning_opponent_score))\n .pipe(lambda x:x.assign(expectation_per_game = x.win_rate * x.win_score_by/x.winning_num_counts + x.lose_rate * x.lose_score_by/x.losing_num_counts))\n .pipe(lambda x:x.assign(avg_win_score_by = x.win_score_by/x.winning_num_counts))\n .pipe(lambda x:x.assign(avg_lose_score_by = x.lose_score_by/x.losing_num_counts))\n )","def __call__(self, outcome):\n if not hasattr(self, 'total'):\n self.total = sum(self.values())\n return self[outcome] / self.total","def _compute_user_stats():\n user_stats = []\n \n wmt16_group = Group.objects.filter(name='WMT16')\n wmt16_users = _get_active_users_for_group(wmt16_group)\n \n for user in wmt16_users:\n _user_stats = HIT.compute_status_for_user(user)\n _name = user.username\n _avg_time = seconds_to_timedelta(_user_stats[1])\n _total_time = seconds_to_timedelta(_user_stats[2])\n _data = (_name, _user_stats[0], _avg_time, _total_time)\n \n if _data[0] > 0:\n user_stats.append(_data)\n \n # Sort by total number of completed HITs.\n user_stats.sort(key=lambda x: x[1])\n user_stats.reverse()\n \n return user_stats","def mutual_info_score(self):\n _, _, I_CK = self._entropies()\n return I_CK / self.grand_total","def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )","def expected_value(held_dice, num_die_sides, num_free_dice):\n list_scores = []\n die_sides = [die for die in range(1, num_die_sides + 1)]\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\n for item in possible_seq:\n list_scores.append(score(held_dice + item))\n \n return float(sum(list_scores)) / len(list_scores)","def getTeamStat(self, year = 2014):\r\n \r\n year_next = (year % 100) + 1\r\n season = str(year) + '-' + str(year_next)\r\n \r\n stat_url = 'http://stats.nba.com/stats/leaguedashteamstats?Conference=&'\\\r\n 'DateFrom=&DateTo=&Division=&GameScope=&GameSegment=&'\\\r\n 'LastNGames=0&LeagueID=00&Location=&MeasureType=Base&'\\\r\n 'Month=0&OpponentTeamID=0&Outcome=&PORound=0&PaceAdjust=N&'\\\r\n 'PerMode=PerGame&Period=0&PlayerExperience=&PlayerPosition=&'\\\r\n 'PlusMinus=N&Rank=N&Season=' + season + '&SeasonSegment=&'\\\r\n 'SeasonType=Regular+Season&ShotClockRange=&StarterBench=&'\\\r\n 'TeamID=0&VsConference=&VsDivision='\r\n \r\n response = requests.get(stat_url)\r\n data = json.loads(response.text)\r\n \r\n headers = data['resultSets'][0]['headers']\r\n stat_data = data['resultSets'][0]['rowSet']\r\n df = pd.DataFrame(stat_data,columns=headers) \r\n \r\n team_df = df[[\"TEAM_ID\",\"TEAM_NAME\",\"GP\",\"W\",\"L\",\"W_PCT\",\"MIN\",\"FGM\",\r\n \"FGA\",\"FG_PCT\",\"FG3M\",\"FG3A\",\"FG3_PCT\",\"FTM\",\"FTA\",\"FT_PCT\",\r\n \"OREB\",\"DREB\",\"REB\",\"AST\",\"TOV\",\"STL\",\"BLK\",\"BLKA\",\"PF\",\r\n \"PFD\",\"PTS\",\"PLUS_MINUS\"]]\r\n \r\n return team_df","def as_counts_and_pcts(self):\n if self.e_pct is None:\n self.calculate_percentages()\n\n score_str = 'E: ' + str(self.e_score) + '(' + str(self.e_pct) + '%)/'\n score_str += 'I: ' + str(self.i_score) + '(' + str(self.i_pct) + '%) - '\n score_str += 'N: ' + str(self.n_score) + '(' + str(self.n_pct) + '%)/'\n score_str += 'S: ' + str(self.s_score) + '(' + str(self.s_pct) + '%) - '\n score_str += 'F: ' + str(self.f_score) + '(' + str(self.f_pct) + '%)/'\n score_str += 'T: ' + str(self.t_score) + '(' + str(self.t_pct) + '%) - '\n score_str += 'J: ' + str(self.j_score) + '(' + str(self.j_pct) + '%)/'\n score_str += 'P: ' + str(self.p_score) + '(' + str(self.p_pct) + '%)'\n return score_str","def collect_stats(games: List[BaseGame], date_min = None, date_max = None):\n if not games: games = self.games\n\n under2_5 = len(list(filter(lambda g: g.is_total_under(), games)))\n under3_5 = len(list(filter(lambda g: g.is_total_under(3.5), games)))\n under1_5 = len(list(filter(lambda g: g.is_total_under(1.5), games)))\n\n home_score = sum([g.FTHG for g in games])\n away_score = sum([g.FTAG for g in games])\n\n home_wins = sum(1 for _ in filter(lambda g: g.is_home_win(), games))\n away_wins = sum(1 for _ in filter(lambda g: g.is_away_win(), games))\n draws = sum(1 for _ in filter(lambda g: g.is_draw(), games))\n\n return {\n 'under2.5': float(under2_5) / len(games),\n 'under3.5': float(under3_5) / len(games),\n 'under1.5': float(under1_5) / len(games),\n 'avgScoredHome': float(home_score) / len(games),\n 'avgScoredAway': float(away_score) / len(games),\n \"home_wins\": float(home_wins) / len(games),\n \"away_wins\": float(away_wins) / len(games),\n \"draws\": float(draws) / len(games),\n }","def _calculate_result(found, total):\n return (found * 100) / total","def play_game(game,standings_):\n rand_nmr = random.random()\n\n standings_.loc[standings_.TEAMS==game['Home'],'MP'] += 1\n standings_.loc[standings_.TEAMS==game['Away'],'MP'] += 1\n\n if rand_nmr < game['Prob Home']:\n n_goals = goals() # a random number of goals is added to the goal tally, all games and in 1-0,2-0,3-0 or 4-0. This can be improved\n standings_.loc[standings_.TEAMS==game['Home'],'W'] += 1\n standings_.loc[standings_.TEAMS==game['Home'],'F'] += n_goals\n standings_.loc[standings_.TEAMS==game['Away'],'L'] += 1\n standings_.loc[standings_.TEAMS==game['Away'],'A'] += n_goals\n standings_.loc[standings_.TEAMS==game['Home']][\"h2h\"].apply(lambda x:x.append(game['Away']))\n\n return 0\n\n elif rand_nmr < game['Prob Home'] + game['Prob Draw']:\n # all draws end in 0-0 this can be improved\n standings_.loc[standings_.TEAMS==game['Home'],'D'] += 1\n standings_.loc[standings_.TEAMS==game['Away'],'D'] += 1\n\n return 1\n\n else:\n n_goals = goals() # a random number of goals is added to the goal tally, all games and in 1-0,2-0,3-0 or 4-0. This can be improved\n standings_.loc[standings_.TEAMS==game['Away'],'W'] += 1\n standings_.loc[standings_.TEAMS==game['Away'],'F'] += n_goals\n standings_.loc[standings_.TEAMS==game['Home'],'A'] += 1\n standings_.loc[standings_.TEAMS==game['Home'],'L'] += n_goals\n standings_.loc[standings_.TEAMS==game['Away']][\"h2h\"].apply(lambda x:x.append(game['Home']))\n\n return 2","def display_stats(self):\n print(\"Simulation took: {:.2f} seconds to execute\".format(time.time() - self.start_time))\n for i, win in enumerate(self.wins):\n average = 0\n if win:\n average = float(self.tries[i]) / win\n print(\"Player {} wins: {} with (average number of rounds: {:.2f})\".format(i+1, win, average))","def _compute_winrates(synergy, counter, heroes_released):\n for i in range(heroes_released):\n for j in range(heroes_released):\n if i != j and i != 23 and j != 23:\n if synergy['games'][i, j] != 0:\n synergy['winrate'][i, j] = synergy['wins'][i, j] / \\\n float(synergy['games'][i, j])\n\n if counter['games'][i, j] != 0:\n counter['winrate'][i, j] = counter['wins'][i, j] / \\\n float(counter['games'][i, j])","def grade_inst(inst, population):\n \n # Initialize to keep track of score \n inst_score = 0\n \n # Battle against each instance in population\n for i in range(len(population)):\n battle_result = inst.battle(population[i])\n inst_score += battle_result[0]\n \n # Also record the score in the instance\n inst.set_score(inst_score)\n\n return inst_score","def calculate_scores():\n all_people = models.Leaderboard.query.order_by(\n models.Leaderboard.score.desc()).all()\n print(all_people)\n users = []\n scores = []\n for person in all_people:\n users.append(person.username)\n scores.append(person.score)\n return users, scores","def winrate(matches):\n if not matches:\n print('no matches')\n return None\n\n win_loss = [match['result'] for match in matches]\n return sum(win_loss)/len(win_loss)","def set_total_reb_of_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"reb_of\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_of\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_of\"] + opp_team[\"reb_def\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n self.total_reb_of_percentage = \"%.2f\" % round(result, 2)","def update_scores(self):\r\n totals = [0, 0, 0, 0]\r\n for player in range(0, 4):\r\n for round_num in range(0, 17):\r\n try:\r\n bid = int(self.spin_bids[player][round_num].get())\r\n tricks = int(self.spin_tricks[player][round_num].get())\r\n except ValueError:\r\n bid = -1\r\n tricks = -1\r\n score = calc_score(min(round_num+1, 13), bid, tricks)\r\n self.lbl_scores[player][round_num].configure(text=str(score))\r\n totals[player] += score\r\n for player in range(0, 4):\r\n self.lbl_totals[player].configure(text=str(totals[player]))\r\n return totals[0] + totals[1] + totals[2] + totals[3]","def TeamScores(level,team_N):\r\n \r\n groupresults = Combined_Non_Compound_Results(level).groupby('Club') \r\n # groups clubs together in a big list just for NMR\r\n # will need to generalise for all categories\r\n\r\n LoR = [ frame for LoRs, frame in groupresults ]\r\n \r\n TeamTable = pd.DataFrame({},columns=['Club','Total Score', # initial empty\r\n 'Total Golds', 'Total Hits']) # dataframe\r\n \r\n# Uni = pd.DataFrame({},columns=['Name','Club','Score','Golds', 'Hits'])\r\n TeamComposition = [[],[],[],[]]\r\n for j in range(4): # only four clubs in the dataframe\r\n\r\n Uni = LoR[j][0:team_N] # jth club in index, gets top team_N archers\r\n Uni = Uni.reset_index(drop=True) # resets the index for UCL sublist\r\n UniName = Uni.loc[0,'Club']\r\n\r\n Scores=0\r\n Golds=0\r\n Hits=0\r\n \r\n TeamComposition[j].append(UniName)\r\n\r\n for i in range(team_N): # sums the score,golds and hits for uni club j\r\n Scores += Uni.loc[i,'Score']\r\n Golds += Uni.loc[i,'Golds']\r\n Hits += Uni.loc[i,'Hits']\r\n\r\n TeamComposition[j].append(Uni.loc[i,'Name'])\r\n \r\n TeamTable2 = pd.DataFrame({'Club': [UniName], \r\n 'Total Score': [Scores],\r\n 'Total Golds': [Golds], \r\n 'Total Hits': [Hits]},\r\n columns=['Club','Total Score', \r\n 'Total Golds', 'Total Hits'])\r\n \r\n TeamTable = TeamTable.append(TeamTable2) # appends each club data\r\n\r\n TeamTable = TeamTable.sort_values(['Total Score','Total Golds',\r\n 'Total Hits'],ascending=[False,False,\r\n False],na_position='last')\r\n TeamTable = TeamTable.reset_index(drop=True)\r\n print()\r\n print(TeamTable)\r\n print()\r\n \r\n \r\n FinalList = [[],[],[],[]]\r\n \r\n for h in range(4):\r\n for g in range(4):\r\n if TeamTable.iloc[h,0] == TeamComposition[g][0]:\r\n FinalList[h] = TeamComposition[g]\r\n\r\n \r\n for k in range(4):\r\n print(FinalList[k])\r\n print()\r\n\r\n if level == NovCategories:\r\n \r\n return print(\"----- End of Novice Team Scores -----\")\r\n \r\n if level == AllCategories:\r\n \r\n return print(\"----- End of Experienced Team Scores -----\")","def percenter(rank, max_rank):\n\treturn 100 * (rank/(max_rank or 1))","def expected_value(held_dice, num_die_sides, num_free_dice):\n result = 0\n outcomes = range(1, num_die_sides + 1)\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\n for hand in possible:\n result += score(held_dice + hand)\n return float(result)/len(possible)","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def calc_stat_values(self):","def rate(self, neighbors, labels):\n num = 0\n den = 0\n for neighbor in neighbors:\n lable = self.labels[neighbor[1]]\n dest_to_neighbor = neighbor[0]\n num += lable / dest_to_neighbor\n den += 1 / dest_to_neighbor\n return num/den"],"string":"[\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\",\n \"def simulate(team, N=100):\\n\\n total_score = 0.0\\n for player in team:\\n simulation_score = []\\n for i in range(N):\\n simulation_score.append(get_player_score(player))\\n total_score += np.mean(simulation_score)\\n\\n return total_score\",\n \"def get_team_results(usrs, sched):\\t\\n\\t\\n\\ttotal_consistency = 0\\n\\ttotal_completion = 0\\n\\tfor user in usrs:\\n\\t\\tresult = get_consistency(user, sched)\\n\\t\\t\\n\\t\\ttotal_consistency += result[\\\"consistency\\\"]\\n\\t\\ttotal_completion += result[\\\"completion\\\"]\\n\\t\\n\\tteam_consistency = 0\\n\\tteam_completion = 0\\n\\t\\t\\n\\tif(len(usrs) != 0):\\n\\t\\tteam_consistency = total_consistency / float(len(usrs))\\n\\t\\tteam_completion = total_completion / float(len(usrs))\\n\\t\\t\\n\\treturn { \\\"consistency\\\" : team_consistency, \\\"completion\\\" : team_completion }\",\n \"def getStats(population, masterList):\\n for team in population:\\n for i in range(13): #13 are the number of roster spots?\\n team.totHr += masterList[team.roster[i]].hr\\n team.totAvg += masterList[team.roster[i]].avg\\n team.totRuns += masterList[team.roster[i]].runs\\n team.totSb += masterList[team.roster[i]].sb\\n team.totRbi += masterList[team.roster[i]].rbi\\n if i == 12:\\n team.totAvg = team.totAvg / 13\\n return population\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def set_assists_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n team_tc_conv = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n player_tc_conv = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0:\\n result = (bx[\\\"assists\\\"] / (((bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * team_tc_conv) - player_tc_conv))*100\\n result = result if result <= 100 and result >= 0 else 0\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.assists_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def main(simulations, userschoice):\\n # The teams data are obtained from FIFA statistics\\n # Team Name, Attack, Defence\\n quarters = ['quarter1', 'quarter2', 'quarter3', 'quarter4', 'quarter5', 'quarter6', 'quarter7', 'quarter8']\\n semifinalists = ['semifinalist1', 'semifinalist2', 'semifinalist3', 'semifinalist4']\\n finalists = ['finalist1', 'finalist2']\\n\\n df = pd.read_csv('FifaRankings.csv', index_col=\\\"Ranking\\\")\\n a_set = set()\\n while True:\\n a_set.add(randint(42, 85))\\n if len(a_set) == 32:\\n break\\n lst1 = sorted(list(a_set), reverse=True)\\n\\n a_set = set()\\n while True:\\n a_set.add(randint(38, 83))\\n if len(a_set) == 32:\\n break\\n lst2 = sorted(list(a_set), reverse=True)\\n print(\\\"\\\\n\\\")\\n df['Attack'] = lst1\\n df['Defence'] = lst2\\n a = list(df[\\\"Team\\\"])\\n\\n avgScored = 0\\n avgConceded = 0\\n avgScored = df['Attack'].sum()\\n avgConceded = df['Defence'].sum()\\n\\n avgScored = avgScored / len(df)\\n avgConceded = avgConceded / len(df)\\n print(\\\"\\\\n\\\")\\n avgattack = []\\n avgdefense = []\\n\\n for i in range(1, 33):\\n if df['Matches Played'][i] != 0:\\n win_rate = (df['WorldCup Wins'][i] / df['Matches Played'][i])\\n else:\\n win_rate = 0\\n avgattack.append((df['Attack'][i] / avgScored) + win_rate)\\n avgdefense.append((df['Defence'][i] / avgConceded) + win_rate)\\n\\n df['Avg Attack'] = avgattack\\n df['Avg Defense'] = avgdefense\\n\\n\\n teamstats=[]\\n for i in range(1,len(df)+1):\\n teaminfo=[]\\n teaminfo = (df[\\\"Team\\\"][i], df['Avg Attack'][i], df['Avg Defense'][i])\\n teaminfo=list(teaminfo)\\n teamstats.append(teaminfo)\\n\\n germany = WorldCupTeam(\\\"GERMANY\\\", teamstats)\\n brazil = WorldCupTeam(\\\"BRAZIL\\\", teamstats)\\n belgium = WorldCupTeam(\\\"BELGIUM\\\", teamstats)\\n portugal = WorldCupTeam(\\\"PORTUGAL\\\", teamstats)\\n argentina = WorldCupTeam(\\\"ARGENTINA\\\", teamstats)\\n france = WorldCupTeam(\\\"FRANCE\\\", teamstats)\\n switzerland = WorldCupTeam(\\\"SWITZERLAND\\\", teamstats)\\n spain = WorldCupTeam(\\\"SPAIN\\\", teamstats)\\n russia = WorldCupTeam(\\\"RUSSIA\\\", teamstats)\\n japan = WorldCupTeam(\\\"JAPAN\\\", teamstats)\\n polland=WorldCupTeam(\\\"POLLAND\\\", teamstats)\\n korea_republic = WorldCupTeam(\\\"KOREA REPUBLIC\\\", teamstats)\\n england = WorldCupTeam(\\\"ENGLAND\\\", teamstats)\\n denmark= WorldCupTeam(\\\"DENMARK\\\", teamstats)\\n peru= WorldCupTeam(\\\"PERU\\\", teamstats)\\n tunisia=WorldCupTeam(\\\"TUNISIA\\\", teamstats)\\n mexico = WorldCupTeam(\\\"MEXICO\\\", teamstats)\\n colombia = WorldCupTeam(\\\"COLOMBIA\\\", teamstats)\\n uruguay = WorldCupTeam(\\\"URUGUAY\\\", teamstats)\\n croatia = WorldCupTeam(\\\"CROATIA\\\", teamstats)\\n australia = WorldCupTeam(\\\"AUSTRALIA\\\", teamstats)\\n iceland=WorldCupTeam(\\\"ICELAND\\\", teamstats)\\n sweden=WorldCupTeam(\\\"SWEDEN\\\", teamstats)\\n costa_rica = WorldCupTeam(\\\"COSTA RICA\\\", teamstats)\\n senegal=WorldCupTeam(\\\"SENEGAL\\\", teamstats)\\n serbia=WorldCupTeam(\\\"SERBIA\\\", teamstats)\\n morrocco=WorldCupTeam(\\\"MORROCCO\\\", teamstats)\\n egypt=WorldCupTeam(\\\"EGYPT\\\", teamstats)\\n nigeria = WorldCupTeam(\\\"NIGERIA\\\", teamstats)\\n saudi_arabia=WorldCupTeam(\\\"SAUDI ARABIA\\\", teamstats)\\n panama=WorldCupTeam(\\\"PANAMA\\\", teamstats)\\n iran = WorldCupTeam(\\\"IRAN\\\", teamstats)\\n\\n\\n #INPUT USERS CHOICE FOR FIXED CHOICE\\n choices= [\\\"random\\\", \\\"Random\\\", \\\"RANDOM\\\"]\\n choicess = [\\\"fixed\\\", \\\"Fixed\\\", \\\"FIXED\\\"]\\n if userschoice in choices:\\n countries = [germany, brazil, belgium, portugal, argentina, france, switzerland, spain, russia, japan, polland,\\n korea_republic, england, denmark, peru, tunisia, mexico, colombia, uruguay, croatia, australia,\\n iceland, sweden, costa_rica, senegal, serbia, morrocco, egypt, nigeria, saudi_arabia, panama, iran]\\n finalresults = {}\\n\\n GroupA, GroupB, GroupC, GroupD, GroupE, GroupF, GroupG, GroupH = ([] for i in range(8))\\n\\n Groups = [GroupA, GroupB, GroupC, GroupD, GroupE, GroupF, GroupG, GroupH]\\n for i in Groups:\\n for j in range(4):\\n teamname = choice(countries)\\n i.append(teamname)\\n countries.remove(teamname)\\n\\n print(\\\"DRAWS for the WorldCup 2018 are:\\\")\\n print(\\\"\\\\n\\\")\\n for i in range(simulations):\\n # Play first stage\\n print(\\\"Result of\\\", i + 1, \\\"simulations\\\")\\n print(\\\"--------------------------------------------\\\")\\n print(\\\"This is GROUP STAGE\\\")\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP A RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupA = TeamPool(Groups[0])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP B RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupB = TeamPool(Groups[1])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP C RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupC = TeamPool(Groups[2])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP D RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupD = TeamPool(Groups[3])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP E RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupE = TeamPool(Groups[4])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP F RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupF = TeamPool(Groups[5])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP G RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupG = TeamPool(Groups[6])\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP H RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupH = TeamPool(Groups[7])\\n\\n # Play second stage\\n print(\\\"\\\\n\\\")\\n print(\\\"ROUND OF 16\\\")\\n print(\\\"\\\\n\\\")\\n r16 = [groupA.first_qualified, groupA.second_qualified, groupB.first_qualified, groupB.second_qualified,\\n groupC.first_qualified, groupC.second_qualified, groupD.first_qualified, groupD.second_qualified,\\n groupE.first_qualified, groupE.second_qualified, groupF.first_qualified, groupF.second_qualified,\\n groupG.first_qualified, groupG.second_qualified, groupH.first_qualified, groupH.second_qualified]\\n\\n\\n GroupP, GroupQ, GroupR, GroupS, GroupT, GroupU, GroupV, GroupW =([] for i in range(8))\\n\\n round16groups = [GroupP, GroupQ, GroupR, GroupS, GroupT, GroupU, GroupV, GroupW]\\n\\n for k in round16groups:\\n for j in range(2):\\n teamname = choice(r16)\\n k.append(teamname)\\n r16.remove(teamname)\\n\\n for i in range(8):\\n quarters[i]=WorldCupMatch(round16groups[i][0], round16groups[i][1], False).winner\\n\\n # Quarters\\n print(\\\"\\\\n\\\")\\n print(\\\"QUARTER - FINALS\\\")\\n print(\\\"\\\\n\\\")\\n quarterfinal = [quarters[0], quarters[1], quarters[2], quarters[3], quarters[4], quarters[5], quarters[6],\\n quarters[7]]\\n GroupA1, GroupB1, GroupC1, GroupD1 = ([] for i in range(4))\\n\\n quarterfinalgroups = [GroupA1, GroupB1, GroupC1, GroupD1]\\n\\n i = 0\\n for i in quarterfinalgroups:\\n for j in range(2):\\n teamname = choice(quarterfinal)\\n i.append(teamname)\\n quarterfinal.remove(teamname)\\n\\n for i in range(4):\\n semifinalists[i] = WorldCupMatch(quarterfinalgroups[i][0], quarterfinalgroups[i][1], False).winner\\n\\n # Semifinals\\n print(\\\"\\\\n\\\")\\n print(\\\"SEMI - FINALS\\\")\\n print(\\\"\\\\n\\\")\\n\\n semifinal = [semifinalists[0], semifinalists[1], semifinalists[2], semifinalists[3]]\\n GroupP1, GroupQ1 = ([] for i in range(2))\\n semifinalgroups = [GroupP1, GroupQ1]\\n\\n i = 0\\n for i in semifinalgroups:\\n for j in range(2):\\n teamname = choice(semifinal)\\n i.append(teamname)\\n semifinal.remove(teamname)\\n\\n for i in range(2):\\n finalists[i] = WorldCupMatch(semifinalgroups[i][0], semifinalgroups[i][1], False).winner\\n # Finals\\n print(\\\"\\\\n\\\")\\n print(\\\"WORLD-CUP FINAL\\\")\\n print(\\\"\\\\n\\\")\\n winner = WorldCupMatch(finalists[0], finalists[1], False).winner\\n print(\\\"\\\\n\\\")\\n\\n if winner.name in finalresults:\\n finalresults[winner.name] += 1\\n else:\\n finalresults[winner.name] = 1\\n\\n for key in sorted(finalresults, key=finalresults.get, reverse=True):\\n print(key + \\\": \\\" + str(finalresults[key] / simulations))\\n ro=(finalresults[key] / simulations) * 100\\n print(str(ro) + \\\"% chance of winning the worldcup\\\")\\n print(\\\"\\\\n\\\")\\n print(\\\"\\\\n\\\")\\n\\n\\n elif userschoice in choicess:\\n\\n print(\\\"\\\\n\\\")\\n finalresults = {}\\n groupA1 = [russia , saudi_arabia,egypt, uruguay]\\n groupB1 = [portugal, spain, morrocco, iran]\\n groupC1 = [france, australia, peru, denmark]\\n groupD1 = [argentina, iceland, croatia, nigeria]\\n groupE1 = [brazil, switzerland, costa_rica, serbia]\\n groupF1 = [germany, mexico, sweden, korea_republic]\\n groupG1 = [belgium, panama, tunisia, england]\\n groupH1 = [polland, senegal, colombia, japan]\\n print(\\\"\\\\n\\\")\\n for i in range(simulations):\\n # Play first stage\\n print(\\\"Result of\\\", i+1 ,\\\"simulations\\\")\\n print(\\\"--------------------------------------------\\\")\\n print(\\\"This is GROUP STAGE\\\")\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP A RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupA = TeamPool(groupA1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP B RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupB = TeamPool(groupB1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP C RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupC = TeamPool(groupC1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP D RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupD = TeamPool(groupD1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP E RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupE = TeamPool(groupE1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP F RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupF = TeamPool(groupF1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP G RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupG = TeamPool(groupG1)\\n print(\\\"\\\\n\\\")\\n print(\\\"GROUP H RESULTS\\\")\\n print(\\\"\\\\n\\\")\\n groupH = TeamPool(groupH1)\\n print(\\\"Qualifies teams:\\\", groupH.first_qualified.name)\\n\\n # Play second stage\\n print(\\\"\\\\n\\\")\\n print(\\\"ROUND OF 16\\\")\\n print(\\\"\\\\n\\\")\\n\\n quarter1 = WorldCupMatch(groupA.first_qualified, groupA.second_qualified, False).winner\\n quarter2 = WorldCupMatch(groupB.first_qualified, groupB.second_qualified, False).winner\\n quarter3 = WorldCupMatch(groupC.first_qualified, groupC.second_qualified, False).winner\\n quarter4 = WorldCupMatch(groupD.first_qualified, groupD.second_qualified, False).winner\\n quarter5 = WorldCupMatch(groupE.first_qualified, groupE.second_qualified, False).winner\\n quarter6 = WorldCupMatch(groupF.first_qualified, groupF.second_qualified, False).winner\\n quarter7 = WorldCupMatch(groupG.first_qualified, groupG.second_qualified, False).winner\\n quarter8 = WorldCupMatch(groupH.first_qualified, groupH.second_qualified, False).winner\\n\\n # Quarters\\n print(\\\"\\\\n\\\")\\n print(\\\"QUARTER - FINALS\\\")\\n print(\\\"\\\\n\\\")\\n\\n semifinalist1 = WorldCupMatch(quarter1, quarter2, False).winner\\n semifinalist2 = WorldCupMatch(quarter3, quarter4, False).winner\\n semifinalist3 = WorldCupMatch(quarter5, quarter6, False).winner\\n semifinalist4 = WorldCupMatch( quarter7, quarter8, False).winner\\n\\n # Semifinals\\n print(\\\"\\\\n\\\")\\n print(\\\"SEMI - FINALS\\\")\\n print(\\\"\\\\n\\\")\\n finalist1 = WorldCupMatch(semifinalist1, semifinalist2, False).winner\\n finalist2 = WorldCupMatch(semifinalist3, semifinalist4, False).winner\\n\\n # Final\\n print(\\\"\\\\n\\\")\\n print(\\\"WORLD-CUP FINAL\\\")\\n print(\\\"\\\\n\\\")\\n winner = WorldCupMatch(finalist1, finalist2, False).winner\\n print(\\\"\\\\n\\\")\\n\\n\\n if winner.name in finalresults:\\n finalresults[winner.name] += 1\\n else:\\n finalresults[winner.name] = 1\\n\\n for key in sorted(finalresults, key=finalresults.get, reverse=True):\\n print(key + \\\": \\\" + str(finalresults[key] / simulations))\\n rou = (finalresults[key] / simulations) * 100\\n print(str(rou) + \\\"% chance of winning the worldcup\\\")\\n print(\\\"\\\\n\\\")\\n print(\\\"\\\\n\\\")\\n else:\\n print(\\\"Please enter correct input and try again\\\")\\n pass\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def get_team_stats(players: list[Player]) -> dict[int]:\\n\\n team_stats = {}\\n\\n total_reaction = 0\\n total_mechanical_skill = 0\\n total_tactical_skill = 0\\n total_game_knowledge = 0\\n total_xp = 0\\n\\n for player in players:\\n total_reaction += player.reaction\\n total_mechanical_skill += player.mechanical_skill\\n total_tactical_skill += player.tactical_skill\\n total_game_knowledge += player.game_knowledge\\n total_xp += player.xp\\n\\n team_stats.update(\\n {\\\"reaction\\\": total_reaction,\\n \\\"mechanical_skill\\\": total_mechanical_skill,\\n \\\"tactical_skill\\\": total_tactical_skill,\\n \\\"game_knowledge\\\": total_game_knowledge,\\n \\\"xp\\\": total_xp})\\n\\n return team_stats\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def _get_percentages(games_table: pd.DataFrame, stats_table: pd.DataFrame,\\n grouping_column: str) -> pd.DataFrame:\\n stats_table[\\n [\\n \\\"total_free_throws_achieved\\\",\\n \\\"total_free_throws_attempted\\\",\\n \\\"total_two_point_achieved\\\",\\n \\\"total_two_point_attempted\\\",\\n \\\"total_three_point_achieved\\\",\\n \\\"total_three_point_attempted\\\",\\n ]\\n ] = (\\n games_table[\\n [\\n grouping_column,\\n \\\"free_throws_achieved\\\",\\n \\\"free_throws_attempted\\\",\\n \\\"two_point_achieved\\\",\\n \\\"two_point_attempted\\\",\\n \\\"three_point_achieved\\\",\\n \\\"three_point_attempted\\\",\\n ]\\n ]\\n .groupby(grouping_column)\\n .sum()\\n .reset_index()\\n .drop(grouping_column, axis=1)\\n )\\n\\n stats_table[\\\"free_throws_pct\\\"] = (\\n stats_table[\\\"total_free_throws_achieved\\\"] / stats_table[\\\"total_free_throws_attempted\\\"]\\n )\\n stats_table[\\\"two_point_pct\\\"] = (\\n stats_table[\\\"total_two_point_achieved\\\"] / stats_table[\\\"total_two_point_attempted\\\"]\\n )\\n stats_table[\\\"three_point_pct\\\"] = (\\n stats_table[\\\"total_three_point_achieved\\\"] / stats_table[\\\"total_three_point_attempted\\\"]\\n )\\n return stats_table\",\n \"def processed_overall(self):\\n self.processed_overall = (\\n self.combine_both_winning_losing_games_stats\\n .rename(columns={\\\"WTeamID\\\":\\\"TeamID\\\"})\\n .pipe(lambda x:x.assign(fgp = x.total_fgm/x.total_fga))\\n .pipe(lambda x:x.assign(fg3p = x.total_fg3m/x.total_fg3a))\\n .pipe(lambda x:x.assign(ftp = x.total_ftm/x.total_fta))\\n [['Season','TeamID','win_rate','total_score','total_opponent_score','fgp','fg3p','ftp', 'total_rebounds','total_off_rebounds','total_def_rebounds',\\n 'total_off_rebounds_percent','total_def_rebounds_percent','total_rebound_possession_percent','total_rebound_possessiongain_percent','total_blocks',\\n 'total_assists','total_steals','total_turnover','total_personalfoul','total_block_opp_FGA_percent','total_assist_per_fgm','total_assist_turnover_ratio',\\n 'expectation_per_game','avg_lose_score_by','avg_win_score_by']]\\n )\",\n \"def get_player_stats_from_game(team, year, week):\",\n \"def compute_stats(self):\\n if self.stats is not None:\\n return\\n self.stats = np.zeros(STEPS_MAX + 1)\\n for m in self.missions:\\n m.compute_stats()\\n self.stats += 100 * m.stats\\n self.stats /= len(self.missions)\",\n \"def cal_hit_ratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\\n score = score_1 - score_2\\n return score/full['user'].nunique()\",\n \"def ucbScore(self,totalPlayedTimes):\\n winRate = self.winRate()\\n #print totalPlayedTimes\\n #print self.playedTimes\\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\\n \\n return winRate + confidenceInterval\",\n \"def winning_games_stats(self):\\n self.winning_games_up_to_2013 = (\\n self.df\\n .pipe(lambda x:x.assign(winning_num_counts = 1))\\n .query(\\\"Season <= 2013\\\")\\n .groupby(['Season','WTeamID'])\\n .agg({\\\"WScore\\\":\\\"sum\\\",\\\"WFGM\\\":\\\"sum\\\",\\\"WFGA\\\":\\\"sum\\\",\\\"WFGM3\\\":\\\"sum\\\",\\\"WFGA3\\\":\\\"sum\\\",\\\"WFTM\\\":\\\"sum\\\",\\\"WFTA\\\":\\\"sum\\\",\\\"LScore\\\":\\\"sum\\\",\\\"winning_num_counts\\\":\\\"sum\\\",\\n \\\"WOR\\\":\\\"sum\\\",\\\"WDR\\\":\\\"sum\\\",\\\"LFGM\\\":\\\"sum\\\",\\\"LFGA\\\":\\\"sum\\\",\\n \\\"WAst\\\":\\\"sum\\\",\\\"WTO\\\":\\\"sum\\\",\\\"WStl\\\":\\\"sum\\\",\\\"WBlk\\\":\\\"sum\\\",\\\"WPF\\\":\\\"sum\\\"})\\n .reset_index()\\n .rename(columns={\\\"LScore\\\":\\\"losing_opponent_score\\\"})\\n # rebounds\\n .pipe(lambda x:x.assign(total_winning_rebounds = x.WOR + x.WDR))\\n .pipe(lambda x:x.assign(winning_off_rebounds_percent = x.WOR/x.total_winning_rebounds))\\n .pipe(lambda x:x.assign(winning_def_rebounds_percent = x.WDR/x.total_winning_rebounds))\\n .pipe(lambda x:x.assign(team_missed_attempts = x.WFGA - x.WFGM))\\n .pipe(lambda x:x.assign(opp_team_missed_attempts = x.LFGA - x.LFGM))\\n .pipe(lambda x:x.assign(winning_rebound_possession_percent = x.WOR/x.team_missed_attempts))\\n .pipe(lambda x:x.assign(winning_rebound_possessiongain_percent = x.WDR/x.opp_team_missed_attempts))\\n # blocks, steals, assists and turnovers\\n .pipe(lambda x:x.assign(winning_block_opp_FGA_percent = x.WBlk/x.LFGA))\\n .pipe(lambda x:x.assign(winning_assist_per_fgm = x.WAst/x.WFGM))\\n .pipe(lambda x:x.assign(winning_assist_turnover_ratio = x.WAst/x.WTO))\\n # rename columns to prevent duplication when joining with losing stats. example: WFGM_x\\n .rename(columns={\\\"LFGA\\\":\\\"LFGA_opp\\\",\\\"LFGM\\\":\\\"LFGM_opp\\\"})\\n )\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def advancedStats():\",\n \"def set_total_reb_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n player_rebounds = bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"]\\n team_rebounds = team[\\\"reb_def\\\"] + team[\\\"reb_of\\\"]\\n opp_team_rebounds = opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((player_rebounds * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team_rebounds + opp_team_rebounds)))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_stats(self):\\n\\n win_points = 0\\n lose_points = 0\\n\\n for username in self.bets:\\n bet_for_win, points = self.bets[username]\\n if bet_for_win:\\n win_points += points\\n else:\\n lose_points += points\\n\\n return win_points, lose_points\",\n \"def calculate_scores(players):\\n scores = {}\\n for player in players.tuple_:\\n scores[player.id_] = player.score()\\n return scores\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def calculateWinRate():\\n times = 10\\n winRate = 0.0\\n for i in range(times):\\n game = Game('user', 6, 6)\\n winRate += game.play(5, False, True, False, False)\\n winRate = winRate/times\\n print \\\"Winrate:\\\", winRate\",\n \"def gamestats(self, table, curr_team):\\n\\n # Drop unneeded header \\n tmp = table.iloc[1:,]\\n # Fix the column names by reading line 0\\n tmp.columns = [x.replace(\\\" \\\", \\\"\\\").replace(\\\"/\\\",\\\"\\\").replace(\\\".\\\",\\\"\\\") for x in tmp.iloc[0]]\\n # Drop row zero which held the header row\\n tmp = tmp.drop(tmp.index[0])\\n # Forward fill the dates for defensive split later \\n tmp['Date'].fillna(method='ffill', inplace = True)\\n # Add in the team \\n tmp['Team'] = curr_team\\n # Create an offense/defense variable\\n tmp['OffenseDefense'] = tmp['Opponent']\\n # If it's not a defensive total then it's offense - set that in the offensedefense variable\\n tmp['OffenseDefense'] = tmp['OffenseDefense'].apply(lambda x: \\\"Defense\\\" if x == \\\"Defensive Totals\\\" else \\\"Offense\\\")\\n # Set the defensive totals in the opponent varaible to nullls\\n tmp['Opponent'] = tmp['Opponent'].apply(lambda x: None if x == \\\"Defensive Totals\\\" else x)\\n # Forward fill the opponents in for analysis later\\n tmp['Opponent'].fillna(method='ffill', inplace = True)\\n # Forward fill the results in for analysis later \\n tmp['Result'].fillna(method='ffill', inplace = True)\\n return tmp\",\n \"def calculate(self):\\n\\n s_sum = 0\\n class_num = len(self.scores)\\n \\n for i in range(class_num):\\n s_sum += self.scores[i]\\n\\n av = float(s_sum)/class_num\\n if av >= 90:\\n return 'O'\\n elif av >= 80:\\n return 'E'\\n elif av >= 70:\\n return 'A'\\n elif av >= 55:\\n return 'P'\\n elif av >= 40:\\n return 'D'\\n else:\\n return 'T'\",\n \"def test_get_team_strength(self):\\n pass\",\n \"def update_mean_and_count(self, strat_profile, game_outcome):\\n self.total_interactions += 1\\n for k in range(self.G.n_players):\\n self.mu[k][strat_profile] *= self.count[k][strat_profile]\\n self.mu[k][strat_profile] += game_outcome[k]\\n self.count[k][strat_profile] += 1\\n self.mu[k][strat_profile] /= self.count[k][strat_profile]\\n\\n for s in self.V:\\n self.count_history[s].append(self.count[0][s] /\\n float(self.total_interactions))\",\n \"def stats(detections, faces):\\n vp, fp, fn, vn = 0, 0, 0, 0\\n max_label = np.max(faces[:, 0])\\n for i in range(max_label + 1):\\n detections_i = get_label_with_index(detections, i)\\n faces_i = get_label_with_index(faces, i)\\n local_vp = 0\\n for face in faces_i:\\n found = False\\n for detection in detections_i:\\n if intersection_ratio(face, detection) >= 0.5:\\n found = True\\n break\\n if found:\\n vp += 1\\n local_vp += 1\\n else:\\n fn += 1\\n fp += len(detections_i) - local_vp\\n\\n precision = vp / (vp + fp)\\n rappel = vp / (vp + fn)\\n f_score = 2 * ((precision * rappel) / (precision + rappel))\\n\\n return precision, rappel, f_score\",\n \"def find_pcts_multi(P, start_b = [], iter = 10000):\\n assert len(P) >= 2\\n wins_per_player = [0] * len(P)\\n all_hole = reduce(lambda x,y: x+y, P)\\n for i in range(iter):\\n deck = Deck()\\n need = 5 - len(start_b)\\n b2 = draw_sure(deck, need, all_hole+start_b)\\n s = [evaluator.evaluate(start_b+b2, h) for h in P]\\n for i, e in enumerate(s):\\n if e == min(s):\\n wins_per_player[i] += 1\\n return [float(x) / sum(wins_per_player) for x in wins_per_player]\",\n \"def cal_hit_gbratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \\n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\\n\\n #print(np.mean(score_ratio))\\n #print(score_1)\\n #score = score_1 + score_2\\n return np.mean(score_ratio)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def per100_top_stat_players(game_type, stat, player_pk, excluded_pks, season_id=None):\\n season = None\\n if season_id:\\n season = bmodels.Season.objects.get(id=season_id)\\n\\n if player_pk:\\n players = bmodels.Player.objects.filter(pk=player_pk)\\n else:\\n players = bmodels.Player.objects.all().exclude(\\n Q(first_name__contains=\\\"Team\\\") | Q(pk__in=excluded_pks))\\n player_list = []\\n for player in players:\\n if season:\\n result = player.statline_set.filter(game__game_type=game_type, game__date__range=(\\n season.start_date, season.end_date)).aggregate(Sum(stat), Sum('off_pos'))\\n else:\\n result = player.statline_set.filter(\\n game__game_type=game_type).aggregate(Sum(stat), Sum('off_pos'))\\n if result['off_pos__sum'] and result['off_pos__sum'] is not 0:\\n percentage = (result[stat + '__sum'] /\\n result['off_pos__sum']) * 100\\n else:\\n percentage = 0.0\\n player_list.append((player.first_name, percentage))\\n return sorted(player_list, key=lambda x: x[1], reverse=True)\",\n \"def percentage_40(set_):\\n db = TinyDB(CARD_DATA_FILE)\\n card_data = db.table('card_data')\\n total = card_data.count(where('set') == set_)\\n q = Query()\\n num_forties = card_data.count((q.set == set_) & (q.commons == 4) & (q.rares == 1))\\n\\n print(num_forties/total)\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n #Between 1-8\\n return own_moves / opp_moves\",\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def update_stats(home_player: Player, away_player: Player,\\n home_score: int, away_score: int) -> None:\\n home_player.goals_for += home_score\\n home_player.goals_against += away_score\\n away_player.goals_for += away_score\\n away_player.goals_against += home_score\\n\\n # home won\\n if (home_score > away_score):\\n home_player.wins += 1\\n away_player.losses += 1\\n # away won\\n elif (home_score < away_score):\\n home_player.losses += 1\\n away_player.wins += 1\\n # draw\\n else:\\n home_player.draws += 1\\n away_player.draws += 1\",\n \"def calculate_uptake_rate(team_members, issues):\\n team_uptake_rate = {name: len([issue for issue in issues.values() if issue['assigned_to'] == name])/\\n float(len([issue for issue in issues.values() if issue['assigned_to']]))\\n for name in team_members}\\n return team_uptake_rate\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def add_player_derived_stats(pl_stats, team_stats, opp_stats):\\n pl_stats['FGP'] = gen_derived_var(pl_stats['FG'], pl_stats['FGA'])\\n pl_stats['FTP'] = gen_derived_var(pl_stats['FT'], pl_stats['FTA'])\\n pl_stats['THRP'] = gen_derived_var(pl_stats['THR'], pl_stats['THRA'])\\n pl_stats['EFGP'] = gen_derived_var(pl_stats['FG'] + 0.5 *\\n pl_stats['THR'], pl_stats['FGA'])\\n pl_stats['TSA'] = pl_stats['FGA'] + 0.44 * pl_stats['FTA']\\n pl_stats['TSP'] = gen_derived_var(pl_stats['PTS'], 2 * pl_stats['TSA'])\\n pl_stats['THRAr'] = gen_derived_var(pl_stats['THRA'], pl_stats['FGA'])\\n pl_stats['FTAr'] = gen_derived_var(pl_stats['FTA'], pl_stats['FGA'])\\n pl_stats['TWOAr'] = gen_derived_var(pl_stats['TWOA'], pl_stats['FGA'])\\n pl_stats['TWOP'] = gen_derived_var(pl_stats['TWO'], pl_stats['TWOA'])\\n pl_stats['ORBr'] = gen_derived_var(pl_stats['ORB'], pl_stats['TRB'])\\n pl_stats['DRBr'] = gen_derived_var(pl_stats['DRB'], pl_stats['TRB'])\\n pl_stats['AST_to_TOV'] = gen_derived_var(pl_stats['AST'], pl_stats['TOV'])\\n pl_stats['STL_to_TOV'] = gen_derived_var(pl_stats['STL'], pl_stats['TOV'])\\n pl_stats['FIC'] = (pl_stats['PTS'] + pl_stats['ORB'] + 0.75 * pl_stats['DRB'] +\\n pl_stats['AST'] + pl_stats['STL'] + pl_stats['BLK'] - 0.75 *\\n pl_stats['FGA'] - 0.375 * pl_stats['FTA'] -\\n pl_stats['TOV'] - 0.5 * pl_stats['PF'])\\n pl_stats['FT_to_FGA'] = gen_derived_var(pl_stats['FT'], pl_stats['FGA'])\\n\\n team_stats['OPOS'] = gen_possessions(pl_stats, opp_stats)\\n team_stats['DPOS'] = gen_possessions(opp_stats, pl_stats)\\n team_stats['PACE'] = 48 * ((team_stats['OPOS'] + team_stats['DPOS']) / (2 * (float(team_stats['MP']) / 5)))\\n\\n # test for None\\n pl_stats['ORBP'] = 100.0 * (pl_stats['ORB'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (team_stats['ORB'] + opp_stats['DRB']))\\n pl_stats['DRBP'] = 100.0 * (pl_stats['DRB'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (team_stats['DRB'] + opp_stats['ORB']))\\n pl_stats['TRBP'] = 100.0 * (pl_stats['TRB'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (team_stats['TRB'] + opp_stats['TRB']))\\n pl_stats['ASTP'] = 100.0 * pl_stats['AST'] / (((float(pl_stats['MP']) / (team_stats['MP'] / 5)) * team_stats['FG']) - pl_stats['FG'])\\n pl_stats['STLP'] = 100.0 * (pl_stats['STL'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * team_stats['DPOS'])\\n pl_stats['BLKP'] = 100.0 * (pl_stats['BLK'] * (team_stats['MP'] / 5)) / (float(pl_stats['MP']) * (opp_stats['FGA'] - opp_stats['THRA']))\\n try:\\n pl_stats['TOVP'] = 100.0 * pl_stats['TOV'] / (pl_stats['FGA'] + 0.44 * pl_stats['FTA'] + pl_stats['TOV'])\\n except ZeroDivisionError:\\n pl_stats['TOVP'] = None\\n pl_stats['HOB'] = gen_derived_var(pl_stats['FG'] + pl_stats['AST'], team_stats['FG'])\\n # pl_stats['+/-'] = pl_stats['+/-'] / pl_stats['N']\",\n \"def __countPlayers(self, players):\\n\\n numLow = sum(map(lambda p: p.lowFps, players))\\n numHigh = sum(map(lambda p: p.highFps, players))\\n numMed = len(players) - numLow - numHigh\\n\\n return '%s, %s, %s' % (numLow, numMed, numHigh)\",\n \"def get_score_percent(self, value):\\n qs_related = RoundData.objects.prefetch_related(\\n 'shotdata').select_related('shotdata')\\n\\n round_holes = int(self.round_type)\\n\\n if value == 'par':\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'birdie_better':\\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'tbogey_worse':\\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\\n if isinstance(value, int):\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)\",\n \"def walkout_percentage_average(df,start_year, end_year,bat_met, player_name):\\n base_fields = ['PA']\\n emp_list = check_base_fields(df,base_fields)\\n\\n if not emp_list:\\n bb_val = round((pd.to_numeric(df['BB.'].str.split('%').str[0])/100)*df['PA'],0).sum()\\n pa_total = df['PA'].fillna(0).sum()\\n return \\\"{:.2%}\\\".format(bb_val / pa_total)\\n else:\\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\\n return walkout_percentage_average(df,start_year, end_year,bat_met, player_name)\",\n \"def get_fool_ratio(self, test_acc, attack_accs):\\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]\",\n \"def calc_stats(hits, misses):\\n try:\\n result = (float(misses) / float(hits)) * 100.0\\n except ZeroDivisionError:\\n if misses == 0:\\n result = 0.0\\n else:\\n result = 100.0\\n return result\",\n \"def calculate_score(player_cards):\\n score = sum(player_cards)\\n return score\",\n \"def scoreTeams(curTeams, oppTeam, pokedex, league, minDistWanted):\\n battleData, htmlData = loadBattleData(league)\\n similarities = loadSims() \\n \\n #If not given an opponent team then simply randomly choose losers from the dataset to compare to.\\n if len(oppTeam) == 0:\\n picks = set([])\\n while (len(picks) < NUMLOSINGTEAMS and (not len(picks) == len(battleData))):\\n picks.add(random.randint(0,len(battleData)-1))\\n\\n losers = []\\n loserDict = {}\\n for i in picks:\\n entry = battleData[i]\\n winner,loser = determineWinner(entry)\\n loserDict[str(loser)] = [winner]\\n losers.append( (loser,0) )\\n\\n #Given opponent team then find similar teams\\n else:\\n oppTeam = [getSimPokemon(opp,similarities) for opp in oppTeam]\\n\\n #create dictionary from losers team to the team that beat them.\\n loserDict = {}\\n sims = []\\n for d in battleData:\\n winner, loser = determineWinner(d)\\n\\n wTeam = teamToArray(winner,pokedex)\\n lTeam = np.array(teamToArray(loser, pokedex))\\n\\n score = 0\\n for oppNp in oppTeam:\\n score+= np.amax(lTeam*oppNp) \\n\\n if str(loser) in loserDict:\\n loserDict[str(loser)].append(winner)\\n else:\\n #new to dictonary\\n loserDict[str(loser)] = [winner]\\n\\n sims.append((loser, score))\\n\\n\\n sims = sorted(sims, key = lambda x : x[1], reverse = True)\\n\\n cutoff = min(len(sims),NUMLOSINGTEAMS)\\n losers = sims[:cutoff]\\n\\n #Gather winners to losing teams\\n winnersComp = []\\n for loser,_ in losers:\\n for winner in loserDict[str(loser)]:\\n winnersComp.append(teamToArray(winner,pokedex))\\n \\n topScore = len(winnersComp)*6 #pkmn team size\\n\\n results = []\\n inverted_idx = {}\\n\\n existsSet = []\\n\\n #Creates inverted index for teams, while simoultaneously weeding out any teams that are exactly similar.\\n for i in range(len(curTeams)):\\n team = curTeams[i]\\n results.append((team,0))\\n sTeam = set(team)\\n if not (sTeam in existsSet):\\n existsSet.append(sTeam)\\n for pkm in team:\\n if pkm != EMPTY:\\n if pkm in inverted_idx:\\n inverted_idx[pkm].append(i)\\n else:\\n inverted_idx[pkm] = [i]\\n \\n #Giving the similiarity scores to the winners based off of the inverted index.\\n for pkm in inverted_idx:\\n for winner in winnersComp:\\n wArr = np.array(winner)\\n #tArr = getSimPokemon(pkm,similarities)\\n tArr = similarities[pkm]\\n \\n vals = wArr * tArr\\n\\n score = np.amax(vals)\\n\\n for i in inverted_idx[pkm]:\\n results[i] = (results[i][0],results[i][1]+(score/topScore))\\n\\n results = sorted(results, key = lambda x : x[1], reverse = True)\\n\\n if len(results) < NUMTEAMSRETURN:\\n if len(results) == 0:\\n returnTeams = [[] for x in range(NUMTEAMSRETURN)]\\n teamScores = [0 for x in range(NUMTEAMSRETURN)]\\n\\n else:\\n returnTeams = [result[0] for result in results]\\n teamScores = [result[1] for result in results]\\n else:\\n firstResult, firstScore = results[0]\\n returnTeams = [firstResult]\\n teamScores = [round(firstScore*100,1)]\\n returnSets = [set(firstResult)]\\n \\n i = 1\\n\\n #Loops through results and adds teams with the proper edit distance away.\\n while(len(returnTeams) < NUMTEAMSRETURN and minDistWanted > 0):\\n teamToConsider,teamToConsiderScore = results[i]\\n \\n considerSet = set(teamToConsider)\\n add = True\\n ##checks the edit distance of teams is above wanted\\n for team in returnSets:\\n if len(team.union(considerSet)) < len(team)+minDistWanted:\\n add = False\\n\\n ##If indeed above wanted levels then add\\n if add:\\n returnTeams.append(teamToConsider)\\n returnSets.append(considerSet)\\n teamScores.append(round(teamToConsiderScore*100,1))\\n \\n i+=1\\n\\n if i >= len(results):\\n i = 1\\n minDistWanted -= 1 \\n \\n winHtmls = []\\n if htmlData != None:\\n for team,_ in losers:\\n for winner in loserDict[str(team)]:\\n winHtmls.extend(htmlData[str(sorted(winner))])\\n \\n\\n return returnTeams, teamScores, winHtmls\",\n \"def updateSuit(self, playersView: Player, ofPlayer: Player, suit: Suit):\\n deck = [Card(suit, val) for val in range(2, 14 + 1)]\\n\\n playersProb = self[playersView, ofPlayer, :]\\n\\n for otherPlayer in Player:\\n if otherPlayer != playersView and otherPlayer != ofPlayer:\\n for card in deck:\\n self[playersView, otherPlayer, card] += (playersProb[card.__hash__()] / 2)\\n\\n for card in deck:\\n self[playersView, ofPlayer, card] = 0\",\n \"def marcels_players(goalie, date, df):\\n # 0 = that year, 1 is year b4 ....\\n marcel_weights = [.36, .29, .21, .14]\\n reg_const = 2000\\n reg_avg = 0 # Where to regress to\\n\\n # Use past 3 season to weight games played -> Just take weighted average\\n gp_weights = [8, 4, 2, 0]\\n\\n season = int(helpers.get_season(date))\\n\\n weighted_goals_sum, weighted_fen_sum, weighted_xg_sum, weights_marcel_sum = 0, 0, 0, 0\\n weighted_gp_sum, weights_gp_sum = 0, 0\\n\\n # Past 4 Seasons\\n for i in range(0, 4):\\n if season - i > 2006:\\n # Subset from stats df\\n df_goalie = df[(df['player'] == goalie) & (df['season'] == (season - i))]\\n\\n # Sanity Check\\n if df_goalie.shape[0] > 1:\\n print(\\\"Too many rows!!!!!!!\\\")\\n exit()\\n\\n # If he played that year\\n if not df_goalie.empty:\\n weighted_goals_sum += df_goalie.iloc[0]['goals_a'] * marcel_weights[i]\\n weighted_fen_sum += df_goalie.iloc[0]['fenwick_a'] * marcel_weights[i]\\n weighted_xg_sum += df_goalie.iloc[0]['xg_a'] * marcel_weights[i]\\n weighted_gp_sum += df_goalie.iloc[0]['games'] * gp_weights[i]\\n\\n # -> To divide by at end...normalize everything\\n weights_marcel_sum += marcel_weights[i]\\n weights_gp_sum += gp_weights[i]\\n\\n # Normalize weighted sums\\n weighted_xg_sum = weighted_xg_sum / weights_marcel_sum if weights_marcel_sum != 0 else 0\\n weighted_goals_sum = weighted_goals_sum / weights_marcel_sum if weights_marcel_sum != 0 else 0\\n weighted_fen_sum = weighted_fen_sum / weights_marcel_sum if weights_marcel_sum != 0 else 0\\n\\n # Get Regressed fsv%\\n if weighted_fen_sum != 0:\\n weighted_adj_fsv = ((1 - weighted_goals_sum / weighted_fen_sum) - (1 - weighted_xg_sum / weighted_fen_sum)) * 100\\n else:\\n weighted_adj_fsv = 0\\n reg_adj_fsv = weighted_adj_fsv - ((weighted_adj_fsv - reg_avg) * (reg_const / (reg_const + weighted_fen_sum)))\\n\\n # Get weighted gp\\n weighted_gp_sum = weighted_gp_sum / weights_gp_sum if weights_gp_sum != 0 else 0\\n\\n return {'fsv': reg_adj_fsv, 'gp': weighted_gp_sum}\",\n \"def set_steals_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n poss = self.get_team_possessions()\\n result = 0.00\\n if bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"steals\\\"] * (team[\\\"minutes\\\"]/Decimal('5'))) / Decimal(float(bx[\\\"minutes\\\"]) * poss)) * 100\\n self.steals_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def set_tichu_percentage(threshold):\\n tichu_threshold = threshold\\n tichu_cnt = 0\\n deck = Deck()\\n players = [Player(id=0), Player(id=1), Player(id=2), Player(id=3)]\\n for i in range(100):\\n myhands = deck.shuffle_and_deal()\\n for idx in range(4):\\n players[idx].assign_hand(myhands[idx])\\n score = players[idx].hand_rating\\n if score > tichu_threshold:\\n tichu_cnt += 1\\n players[idx].hand.show()\\n print('Player calls Tichu with a hand rating of {:.1f}.'.format(score))\\n print('\\\\n')\\n print('Tichu percentage: {:.2f}'.format(tichu_cnt/100))\",\n \"def get_effective_team_stats(team_stats: dict) -> int:\\n\\n # TODO: Problem effective stats <-> value\\n # value = int((reaction * 0.5 + technical_skill * 1.5 + tactical_skill * 1.5 + game_knowledge) * xp)\\n\\n stats_sum = 0\\n\\n for value in team_stats.values():\\n stats_sum += value * random.uniform(0.5, 1.5)\\n\\n return stats_sum\",\n \"def get_scores(self, tournament: Tournament):\\n self.model.eval()\\n # collate_fn = lambda x: collate_teams(x, tournament.max_members)\\n dl_rank = DataLoader(tournament.ranking, num_workers=self.jobs, batch_size=self.bs, shuffle=False)\\n iterator = tqdm(dl_rank, position=0, desc=f'{tournament.tournament_id} ranking', disable=True)\\n scores = []\\n for i, team in enumerate(iterator):\\n score = self.model.get_team_score(team.to(self.device))\\n scores.append(score.cpu().numpy())\\n\\n scores = np.concatenate(scores)\\n return scores.flatten()\",\n \"def get_team_scores(self, team, include_home=True, include_away=True):\\n if include_away:\\n away_games = list(filter(lambda g: team == g.AwayTeam, self.games))\\n else:\\n away_games = []\\n\\n if include_home:\\n home_games = list(filter(lambda g: team == g.HomeTeam, self.games))\\n else:\\n home_games = []\\n\\n scored_h = [g.FTHG for g in home_games]\\n scored_a = [g.FTAG for g in away_games]\\n\\n conceded_h = [g.FTAG for g in home_games]\\n conceded_a = [g.FTHG for g in away_games]\\n\\n try:\\n mean_gd = mean(scored_h + scored_a) - mean(conceded_h + conceded_a)\\n home_gd = mean(scored_h) - mean(conceded_h)\\n home_adv = home_gd - mean_gd\\n except Exception:\\n home_adv = 0\\n\\n return {\\n \\\"scored_xg\\\": scored_h + scored_a,\\n \\\"conceded_xg\\\": conceded_h + conceded_a,\\n \\\"home_adv\\\": home_adv,\\n \\\"expected_points\\\": self.get_table(metric='points')[team] /\\n len(home_games + away_games)\\n }\",\n \"def set_assists_per_turnover(self):\\n bx = self.get_standard_stats()\\n ratio = bx[\\\"assists\\\"]\\n if bx[\\\"turnovers\\\"] > 0:\\n ratio = bx[\\\"assists\\\"] / bx[\\\"turnovers\\\"]\\n self.assists_per_turnover = \\\"%.2f\\\" % round(ratio, 2)\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def get_new_ratings(players, teams):\\n nb_players_team0 = len(teams[0])\\n nb_players_team1 = len(teams[1])\\n winner = players[teams[0][0]]\\n loser = players[teams[1][0]]\\n if nb_players_team0 == 1 and nb_players_team1 == 1:\\n new_r1, new_r3 = rate_1vs1(winner,loser)\\n elif nb_players_team0 == 1 and nb_players_team1 > 1:\\n team_loser = [loser, players[teams[1][1]]]\\n (new_r1), (new_r3, new_r4) = rate([winner, team_loser], ranks=[0, 1]) \\n elif nb_players_team0 > 1 and nb_players_team1 == 1:\\n team_winner = [winner, players[teams[0][1]]]\\n (new_r1, new_r2), (new_r3) = rate([team_winner, loser], ranks=[0, 1]) \\n else:\\n team_loser = [loser, players[teams[1][1]]]\\n team_winner = [winner, players[teams[0][1]]]\\n (new_r1, new_r2), (new_r3, new_r4) = rate([team_winner, team_loser], ranks=[0, 1]) \\n player1 = {'name': teams[0][0], 'mu': new_r1.mu, 'sigma': new_r1.sigma}\\n player3 = {'name': teams[1][0], 'mu': new_r3.mu, 'sigma': new_r3.sigma}\\n if nb_players_team0 > 1:\\n player2 = {'name': teams[0][1], 'mu': new_r2.mu, 'sigma': new_r2.sigma}\\n if nb_players_team1 > 1:\\n player4 = {'name': teams[1][1], 'mu': new_r4.mu, 'sigma': new_r4.sigma}\\n if nb_players_team0 > 1:\\n return [player1, player2, player3, player4]\\n return [player1, player2, player4]\\n return [player1, player3]\",\n \"def U_Function(currentPlayer, oppositePlayer, N, maxEntity):\\n EndPointPlayer1 = Posisi.Posisi(N - 1, N - 1)\\n EndPointPlayer2 = Posisi.Posisi(0, 0)\\n \\n sumPionPlayer1 = 0\\n sumPionPlayer2 = 0\\n\\n if (currentPlayer.noPlayer == 1):\\n for Pion in currentPlayer.arrayPion:\\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\\n for Pion in oppositePlayer.arrayPion:\\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\\n \\n if (currentPlayer.noPlayer == 2):\\n for Pion in currentPlayer.arrayPion:\\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\\n for Pion in oppositePlayer.arrayPion:\\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\\n\\n if (maxEntity == 1):\\n return -sumPionPlayer1 + sumPionPlayer2\\n else:\\n return -sumPionPlayer2 + sumPionPlayer1\",\n \"def add_team_derived_stats(stats, opp_stats):\\n stats['FGP'] = gen_derived_var(stats['FG'], stats['FGA'])\\n stats['FTP'] = gen_derived_var(stats['FT'], stats['FTA'])\\n stats['THRP'] = gen_derived_var(stats['THR'], stats['THRA'])\\n stats['EFGP'] = gen_derived_var(stats['FG'] + 0.5 *\\n stats['THR'], stats['FGA'])\\n stats['TSA'] = stats['FGA'] + 0.44 * stats['FTA']\\n stats['TSP'] = gen_derived_var(stats['PTS'], 2 * stats['TSA'])\\n stats['THRAr'] = gen_derived_var(stats['THRA'], stats['FGA'])\\n stats['FTAr'] = gen_derived_var(stats['FTA'], stats['FGA'])\\n stats['TWOAr'] = gen_derived_var(stats['TWOA'], stats['FGA'])\\n stats['TWOP'] = gen_derived_var(stats['TWO'], stats['TWOA'])\\n stats['ORBr'] = gen_derived_var(stats['ORB'], stats['TRB'])\\n stats['DRBr'] = gen_derived_var(stats['DRB'], stats['TRB'])\\n stats['AST_to_TOV'] = gen_derived_var(stats['AST'], stats['TOV'])\\n stats['STL_to_TOV'] = gen_derived_var(stats['STL'], stats['TOV'])\\n stats['FIC'] = (stats['PTS'] + stats['ORB'] + 0.75 * stats['DRB'] +\\n stats['AST'] + stats['STL'] + stats['BLK'] - 0.75 *\\n stats['FGA'] - 0.375 * stats['FTA'] -\\n stats['TOV'] - 0.5 * stats['PF'])\\n stats['FT_to_FGA'] = gen_derived_var(stats['FT'], stats['FGA'])\\n\\n stats['OPOS'] = gen_possessions(stats, opp_stats)\\n stats['DPOS'] = gen_possessions(opp_stats, stats)\\n stats['PACE'] = 48 * ((stats['OPOS'] + stats['DPOS']) / (2 * (float(stats['MP']) / 5)))\\n\\n stats['ORBP'] = stats['ORB'] / (stats['ORB'] + opp_stats['DRB'])\\n stats['DRBP'] = stats['DRB'] / (stats['DRB'] + opp_stats['ORB'])\\n stats['TRBP'] = stats['TRB'] / (stats['TRB'] + opp_stats['TRB'])\\n stats['ASTP'] = stats['AST'] / stats['FG']\\n stats['STLP'] = stats['STL'] / stats['DPOS']\\n stats['BLKP'] = stats['BLK'] / opp_stats['TWOA']\\n stats['TOVP'] = stats['TOV'] / stats['OPOS']\\n # stats['+/-'] = stats['+/-'] / stats['N']\",\n \"def score(self,player, board):\\r\\n numPlayer = 0\\r\\n numOpp = 0\\r\\n for i in self.squares():\\r\\n if board[i] == player:\\r\\n numPlayer+= SQUARE_WEIGHTS[i]\\r\\n else:\\r\\n numOpp+=SQUARE_WEIGHTS[i]\\r\\n return numPlayer-numOpp\",\n \"def calc_adv_U(self):\\n num_U = 0\\n adv_U = numpy.zeros((3,3), float)\\n\\n for atm in self:\\n ## use the atom's U matrix if it exists, otherwise use the\\n ## temperature factor\\n\\n if atm.U is not None:\\n adv_U += atm.U\\n num_U += 1\\n\\n return adv_U / num_U\",\n \"def recalculate_popularity(self):\\n self.voters = 0\\n for x in self.votes:\\n self.voters += 1\\n if x.good:\\n self.popularity += 1\\n else:\\n self.popularity -= 1\",\n \"def find_pcts(p1, p2, start_b = [], iter = 10000):\\n win_record = []\\n for i in range(iter):\\n deck = Deck()\\n need = 5 - len(start_b)\\n b2 = draw_sure(deck, need, p1+p2+start_b)\\n win_record.append(_who_wins(start_b + b2, p1, p2, printout = False))\\n return [win_record.count(1) / float(len(win_record)), \\n win_record.count(2) / float(len(win_record))\\n ]\",\n \"def _compute_global_stats():\\n global_stats = []\\n \\n wmt16_group = Group.objects.filter(name='WMT16')\\n wmt16_users = _get_active_users_for_group(wmt16_group)\\n \\n # Check how many HITs have been completed. We now consider a HIT to be\\n # completed once it has been annotated by one or more annotators.\\n #\\n # Before we required `hit.users.count() >= 3` for greater overlap.\\n hits_completed = HIT.objects.filter(mturk_only=False, completed=True).count()\\n \\n # Check any remaining active HITs which are not yet marked complete.\\n for hit in HIT.objects.filter(active=True, mturk_only=False, completed=False):\\n if hit.users.count() >= 1:\\n hits_completed = hits_completed + 1\\n hit.completed = True\\n hit.save()\\n \\n # Compute remaining HITs for all language pairs.\\n hits_remaining = HIT.compute_remaining_hits()\\n \\n # Compute number of results contributed so far.\\n ranking_results = RankingResult.objects.filter(\\n item__hit__completed=True, item__hit__mturk_only=False)\\n \\n from math import factorial\\n system_comparisons = 0\\n for result in ranking_results:\\n result.reload_dynamic_fields()\\n # TODO: this implicitly counts A=B comparisons for multi systems.\\n # Basically, inflating the number of pairwise comparisons... Fix!\\n combinations = factorial(result.systems)/(factorial(result.systems-2) * 2) if result.systems > 2 else 0\\n system_comparisons = system_comparisons + combinations\\n \\n # Aggregate information about participating groups.\\n groups = set()\\n for user in wmt16_users:\\n for group in _identify_groups_for_user(user):\\n groups.add(group)\\n \\n # Compute average/total duration over all results.\\n durations = RankingResult.objects.all().values_list('duration', flat=True)\\n total_time = sum([datetime_to_seconds(x) for x in durations])\\n avg_time = total_time / float(hits_completed or 1)\\n avg_user_time = total_time / float(3 * hits_completed or 1)\\n \\n global_stats.append(('Users', len(wmt16_users)))\\n global_stats.append(('Groups', len(groups)))\\n global_stats.append(('HITs completed', '{0:,}'.format(hits_completed)))\\n global_stats.append(('HITs remaining', '{0:,}'.format(hits_remaining)))\\n global_stats.append(('Ranking results', '{0:,}'.format(ranking_results.count())))\\n global_stats.append(('System comparisons', '{0:,}'.format(system_comparisons)))\\n global_stats.append(('Average duration (per HIT)', seconds_to_timedelta(avg_time)))\\n global_stats.append(('Average duration (per task)', seconds_to_timedelta(avg_user_time)))\\n global_stats.append(('Total duration', seconds_to_timedelta(total_time)))\\n \\n # Create new status data snapshot\\n TimedKeyValueData.update_status_if_changed('users', str(len(wmt16_users)))\\n TimedKeyValueData.update_status_if_changed('groups', str(len(groups)))\\n TimedKeyValueData.update_status_if_changed('hits_completed', str(hits_completed))\\n TimedKeyValueData.update_status_if_changed('hits_remaining', str(hits_remaining))\\n TimedKeyValueData.update_status_if_changed('ranking_results', str(ranking_results.count()))\\n TimedKeyValueData.update_status_if_changed('system_comparisons', str(system_comparisons))\\n TimedKeyValueData.update_status_if_changed('duration_per_hit', str(seconds_to_timedelta(avg_time)))\\n TimedKeyValueData.update_status_if_changed('duration_per_task', str(seconds_to_timedelta(avg_user_time)))\\n TimedKeyValueData.update_status_if_changed('duration_total', str(seconds_to_timedelta(total_time)))\\n \\n return global_stats\",\n \"def get_team_stats() -> List[BaseStat]:\\n return [PossessionStat(),\\n TeamTendencies(),\\n RelativeTendencies(),\\n PerPossessionStat(),\\n RumbleItemStat(),\\n PreRumbleGoals(),\\n DropshotStats()\\n ]\",\n \"def evaluate_power(soldier_list: List[Soldier]):\\n inf_count = 0\\n inf_avg_weapon = 0.0\\n inf_avg_armor = 0.0\\n arc_count = 0\\n arc_avg_weapon = 0.0\\n arc_avg_armor = 0.0\\n cvl_count = 0\\n cvl_avg_weapon = 0.0\\n cvl_avg_armor = 0.0\\n \\n for soldier in soldier_list:\\n ################################# YOUR CODE HERE #################################\\n if soldier.typecode == \\\"ARC\\\":\\n arc_count += 1\\n arc_avg_armor += soldier.armor\\n arc_avg_weapon += soldier.weapon\\n elif soldier.typecode == \\\"INF\\\":\\n inf_count += 1\\n inf_avg_armor += soldier.armor\\n inf_avg_weapon += soldier.weapon\\n elif soldier.typecode == \\\"CVL\\\":\\n cvl_count += 1\\n cvl_avg_armor += soldier.armor\\n cvl_avg_weapon += soldier.weapon\\n if arc_count != 0:\\n arc_avg_armor /= arc_count\\n arc_avg_weapon /= arc_count\\n\\n if cvl_count != 0:\\n cvl_avg_armor /= cvl_count\\n cvl_avg_weapon /= cvl_count\\n\\n if inf_count != 0:\\n inf_avg_armor /= inf_count\\n inf_avg_weapon /= inf_count\\n ##################################################################################\\n return (inf_count, inf_avg_weapon, inf_avg_armor), (arc_count, arc_avg_weapon, arc_avg_armor), (cvl_count, cvl_avg_weapon, cvl_avg_armor)\",\n \"def __calculateNormalizedScores(self):\\n year_scores = {0 : []}\\n for venue in self.venue_scores:\\n v_scores = []\\n for year in self.venue_scores[venue]:\\n v_scores.append(self.venue_scores[venue][year])\\n if year not in year_scores:\\n year_scores[year] = []\\n year_scores[year].append(self.venue_scores[venue][year])\\n x_year = np.average(np.array(v_scores))\\n self.venue_scores[venue][0] = x_year\\n year_scores[0].append(x_year)\\n \\n ##for standardization\\n #year_metrics = {x : (np.average(np.array(year_scores[x])), np.std(np.array(year_scores[x]))) for x in year_scores}\\n ##for normalization\\n year_metrics = {x: (max(year_scores[x]), min(year_scores[x])) for x in year_scores}\\n \\n #print year_metrics\\n \\n for venue in self.venue_scores:\\n self.normalized_scores[venue] = dict()\\n for year in self.venue_scores[venue]:\\n #self.standard_scores[venue][year] = round((self.venue_scores[venue][year] - year_metrics[year][0]) / year_metrics[year][1],5)\\n #self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1]) / (year_metrics[year][0] - year_metrics[year][1]) + eps\\n self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1] + self.epsilon) / (year_metrics[year][0] - year_metrics[year][1] + self.epsilon)\",\n \"def get_total_health(self,obs):\\n total_health = 0\\n for unit in obs.observation.raw_units:\\n if(unit.alliance == PlayerRelative.SELF):\\n total_health += unit[FeatureUnit.health]\\n return total_health\",\n \"def percentage(self):\\n temp = self.cpu_freq_time_spent.copy()\\n for i in self.cpu_freq_time_spent:\\n total = 0\\n for j in self.cpu_freq_time_spent[i]:\\n total += self.cpu_freq_time_spent[i][j]\\n for j in self.cpu_freq_time_spent[i]:\\n if total != 0:\\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\\n else:\\n temp[i][j] = 0\\n return temp\",\n \"def calculate_profit(self):\",\n \"def get_list_team_scores(self):\\n scores = defaultdict(lambda: {\\n \\\"scored_xg\\\": [],\\n \\\"conceded_xg\\\": [],\\n \\\"home_adv\\\": 0,\\n \\\"expected_points\\\": 0\\n })\\n\\n for g in self.games:\\n scores[g.HomeTeam][\\\"scored_xg\\\"].append(g.FTHG)\\n scores[g.HomeTeam][\\\"conceded_xg\\\"].append(g.FTAG)\\n scores[g.AwayTeam][\\\"scored_xg\\\"].append(g.FTAG)\\n scores[g.AwayTeam][\\\"conceded_xg\\\"].append(g.FTHG)\\n\\n for team in scores.keys():\\n scores[team][\\\"expected_points\\\"] = (self.get_table(metric='points')[team] /\\n len(scores[team][\\\"scored_xg\\\"]))\\n\\n return scores\",\n \"def get_percentage_sf_votes(self):\\n\\n votes_f = self.get_num_f_votes()\\n votes_sf = self.get_num_sf_votes()\\n\\n # avoid dividing by zero\\n if votes_f + votes_sf == 0:\\n return 0\\n else:\\n ratio = float(votes_sf)/(votes_f + votes_sf)\\n return round(ratio * 100, 1)\",\n \"def set_offensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0 and (bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]) > 0:\\n fgm = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n fga = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n team_fgm = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n team_fga = team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]\\n team_points = team[\\\"t2p_conv\\\"]*2 + team[\\\"t3p_conv\\\"]*3 + team[\\\"tl_conv\\\"]\\n points = bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"]\\n\\n try:\\n qAST = (Decimal(bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * (Decimal('1.14') * Decimal((team[\\\"assists\\\"] - bx[\\\"assists\\\"]) / team_fgm))) + \\\\\\n Decimal((((team[\\\"assists\\\"] / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - bx[\\\"assists\\\"]) / ((team_fgm / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - fgm)) * (1 - (bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5))))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n qAST = 1\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n qAST = 1\\n\\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2*(team_fga - fga))) * bx[\\\"assists\\\"]\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n ast_part = 0\\n\\n if bx[\\\"tl_int\\\"] > 0:\\n ft_part = Decimal(1 - (1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_part = 0\\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"]))**2) * team[\\\"tl_int\\\"] * Decimal('0.4'))\\n try:\\n team_orb_percentage = Decimal(team[\\\"reb_of\\\"] / (team[\\\"reb_of\\\"] + ((opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]) - opp_team[\\\"reb_of\\\"])))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n\\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\\\"tl_int\\\"] * Decimal('0.4') + team[\\\"turnovers\\\"]))\\n try:\\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_weight = 0\\n\\n orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage\\n\\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\\n if bx[\\\"tl_conv\\\"] > 0:\\n ft_x_poss = Decimal((1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_x_poss = Decimal(1 - (bx[\\\"tl_conv\\\"] / 1)**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n try:\\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n sc_poss =0\\n\\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\\\"turnovers\\\"]\\n\\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\\\"t3p_conv\\\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\\\"t3p_conv\\\"] - bx[\\\"t3p_conv\\\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2 * (team_fga - fga))) * bx[\\\"assists\\\"]\\n except:\\n pprod_ast_part = 0\\n\\n pprod_orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"])**2) * Decimal('0.4') * team[\\\"tl_int\\\"]))\\n try:\\n pprod = (pprod_fg_part + pprod_ast_part + bx[\\\"tl_conv\\\"]) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n pprod = 0\\n\\n try:\\n result = 100 * (pprod / tot_poss)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n result = 0\\n\\n # print(\\\"fgm: \\\" + str(fgm))\\n # print(\\\"fga: \\\" + str(fga))\\n # print(\\\"team_fgm: \\\" + str(team_fgm))\\n # print(\\\"team_fga: \\\" + str(team_fga))\\n # print(\\\"team_points: \\\" + str(team_points))\\n # print(\\\"points: \\\" + str(points))\\n # print(\\\"qAST: \\\" + str(qAST))\\n # print(\\\"fg_part: \\\" + str(fg_part))\\n # print(\\\"ast_part: \\\" + str(ast_part))\\n # print(\\\"ft_part: \\\" + str(ft_part))\\n # print(\\\"team_scoring_poss: \\\" + str(team_scoring_poss))\\n # print(\\\"team_orb_percentage: \\\" + str(team_orb_percentage))\\n # print(\\\"team_play_percentage: \\\" + str(team_play_percentage))\\n # print(\\\"team_orb_weight: \\\" + str(team_orb_weight))\\n # print(\\\"orb_part: \\\" + str(orb_part))\\n # print(\\\"fg_x_poss: \\\" + str(fg_x_poss))\\n # print(\\\"ft_x_poss: \\\" + str(ft_x_poss))\\n # print(\\\"sc_poss: \\\" + str(sc_poss))\\n # print(\\\"tot_poss: \\\" + str(tot_poss))\\n # print(\\\"pprod_fg_part: \\\" + str(pprod_fg_part))\\n # print(\\\"pprod_ast_part: \\\" + str(pprod_ast_part))\\n # print(\\\"pprod_orb_part: \\\" + str(pprod_orb_part))\\n # print(\\\"pprod: \\\" + str(pprod))\\n # print(\\\"result: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n\\n self.ortg = \\\"%.2f\\\" % round(result, 2)\\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\\n \\\"\\\"\\\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \\n using team's formula\\\"\\\"\\\"\\n print(BCOLORS.OKBLUE + \\\"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\\\" + BCOLORS.ENDC)\\n bx = self.get_standard_stats()\\n result = round((bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])/self.get_team_possessions(), 2)\\n self.ortg = \\\"%.2f\\\" % result\",\n \"def cumulative_stats_for_teams_each_year(self):\\n self.cumulative_stats_for_team_each_year = (\\n self.combine_both_winning_losing_games_stats\\n .sort_values(['WTeamID','Season'])\\n .groupby(['WTeamID'])\\n .cumsum()\\n .pipe(lambda x:x.assign(Season = self.combine_both_winning_losing_games_stats.Season.values))\\n .pipe(lambda x:x.assign(TeamID = self.combine_both_winning_losing_games_stats.WTeamID.values))\\n .drop(['LTeamID','win_rate'],1)\\n .pipe(lambda x:x.assign(win_rate = x.winning_num_counts/(x.winning_num_counts + x.losing_num_counts)))\\n .pipe(lambda x:x.assign(WFGP = x.WFGM/x.WFGA))\\n .pipe(lambda x:x.assign(WFG3P = x.WFGM3/x.WFGA3))\\n .pipe(lambda x:x.assign(WFTP = x.WFTM/x.WFTA))\\n .pipe(lambda x:x.assign(LFGP = x.LFGM/x.LFGA))\\n .pipe(lambda x:x.assign(LFG3P = x.LFGM3/x.LFGA3))\\n .pipe(lambda x:x.assign(LFTP = x.LFTM/x.LFTA))\\n .pipe(lambda x:x.assign(fgp = x.total_fgm/x.total_fga))\\n .pipe(lambda x:x.assign(fg3p = x.total_fg3m/x.total_fg3a))\\n .pipe(lambda x:x.assign(ftp = x.total_ftm/x.total_fta))\\n # rebounds cumsum stats\\n .pipe(lambda x:x.assign(total_def_rebounds_percent = x.total_def_rebounds/x.total_rebounds))\\n .pipe(lambda x:x.assign(total_off_rebounds_percent = x.total_off_rebounds/x.total_rebounds))\\n .pipe(lambda x:x.assign(total_rebound_possession_percent = x.total_off_rebounds/x.total_team_missed_attempts))\\n .pipe(lambda x:x.assign(total_rebound_possessiongain_percent = x.total_def_rebounds/x.total_opp_team_missed_attempts))\\n # assists, turnovers, steals, blocks and personal fouls\\n .pipe(lambda x:x.assign(total_block_opp_FGA_percent = x.total_blocks/x.total_opp_fga))\\n .pipe(lambda x:x.assign(total_assist_per_fgm = x.total_assists/x.total_fgm))\\n .pipe(lambda x:x.assign(total_assist_turnover_ratio = x.total_assists/x.total_turnover))\\n # win or lose by how many points\\n .pipe(lambda x:x.assign(lose_rate = 1-x.win_rate))\\n .pipe(lambda x:x.assign(win_score_by = x.WScore - x.losing_opponent_score))\\n .pipe(lambda x:x.assign(lose_score_by = x.LScore - x.winning_opponent_score))\\n .pipe(lambda x:x.assign(expectation_per_game = x.win_rate * x.win_score_by/x.winning_num_counts + x.lose_rate * x.lose_score_by/x.losing_num_counts))\\n .pipe(lambda x:x.assign(avg_win_score_by = x.win_score_by/x.winning_num_counts))\\n .pipe(lambda x:x.assign(avg_lose_score_by = x.lose_score_by/x.losing_num_counts))\\n )\",\n \"def __call__(self, outcome):\\n if not hasattr(self, 'total'):\\n self.total = sum(self.values())\\n return self[outcome] / self.total\",\n \"def _compute_user_stats():\\n user_stats = []\\n \\n wmt16_group = Group.objects.filter(name='WMT16')\\n wmt16_users = _get_active_users_for_group(wmt16_group)\\n \\n for user in wmt16_users:\\n _user_stats = HIT.compute_status_for_user(user)\\n _name = user.username\\n _avg_time = seconds_to_timedelta(_user_stats[1])\\n _total_time = seconds_to_timedelta(_user_stats[2])\\n _data = (_name, _user_stats[0], _avg_time, _total_time)\\n \\n if _data[0] > 0:\\n user_stats.append(_data)\\n \\n # Sort by total number of completed HITs.\\n user_stats.sort(key=lambda x: x[1])\\n user_stats.reverse()\\n \\n return user_stats\",\n \"def mutual_info_score(self):\\n _, _, I_CK = self._entropies()\\n return I_CK / self.grand_total\",\n \"def score( self ):\\r\\n result = 0.0\\r\\n for rr in self.ee.getRsrcs( ):\\r\\n value = self.scoreRsrc( rr )\\r\\n result += value\\r\\n print( \\\"INFO: Value for the schedule is %s \\\" % ( rr, result ) )\\r\\n return( result )\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n list_scores = []\\n die_sides = [die for die in range(1, num_die_sides + 1)]\\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\\n for item in possible_seq:\\n list_scores.append(score(held_dice + item))\\n \\n return float(sum(list_scores)) / len(list_scores)\",\n \"def getTeamStat(self, year = 2014):\\r\\n \\r\\n year_next = (year % 100) + 1\\r\\n season = str(year) + '-' + str(year_next)\\r\\n \\r\\n stat_url = 'http://stats.nba.com/stats/leaguedashteamstats?Conference=&'\\\\\\r\\n 'DateFrom=&DateTo=&Division=&GameScope=&GameSegment=&'\\\\\\r\\n 'LastNGames=0&LeagueID=00&Location=&MeasureType=Base&'\\\\\\r\\n 'Month=0&OpponentTeamID=0&Outcome=&PORound=0&PaceAdjust=N&'\\\\\\r\\n 'PerMode=PerGame&Period=0&PlayerExperience=&PlayerPosition=&'\\\\\\r\\n 'PlusMinus=N&Rank=N&Season=' + season + '&SeasonSegment=&'\\\\\\r\\n 'SeasonType=Regular+Season&ShotClockRange=&StarterBench=&'\\\\\\r\\n 'TeamID=0&VsConference=&VsDivision='\\r\\n \\r\\n response = requests.get(stat_url)\\r\\n data = json.loads(response.text)\\r\\n \\r\\n headers = data['resultSets'][0]['headers']\\r\\n stat_data = data['resultSets'][0]['rowSet']\\r\\n df = pd.DataFrame(stat_data,columns=headers) \\r\\n \\r\\n team_df = df[[\\\"TEAM_ID\\\",\\\"TEAM_NAME\\\",\\\"GP\\\",\\\"W\\\",\\\"L\\\",\\\"W_PCT\\\",\\\"MIN\\\",\\\"FGM\\\",\\r\\n \\\"FGA\\\",\\\"FG_PCT\\\",\\\"FG3M\\\",\\\"FG3A\\\",\\\"FG3_PCT\\\",\\\"FTM\\\",\\\"FTA\\\",\\\"FT_PCT\\\",\\r\\n \\\"OREB\\\",\\\"DREB\\\",\\\"REB\\\",\\\"AST\\\",\\\"TOV\\\",\\\"STL\\\",\\\"BLK\\\",\\\"BLKA\\\",\\\"PF\\\",\\r\\n \\\"PFD\\\",\\\"PTS\\\",\\\"PLUS_MINUS\\\"]]\\r\\n \\r\\n return team_df\",\n \"def as_counts_and_pcts(self):\\n if self.e_pct is None:\\n self.calculate_percentages()\\n\\n score_str = 'E: ' + str(self.e_score) + '(' + str(self.e_pct) + '%)/'\\n score_str += 'I: ' + str(self.i_score) + '(' + str(self.i_pct) + '%) - '\\n score_str += 'N: ' + str(self.n_score) + '(' + str(self.n_pct) + '%)/'\\n score_str += 'S: ' + str(self.s_score) + '(' + str(self.s_pct) + '%) - '\\n score_str += 'F: ' + str(self.f_score) + '(' + str(self.f_pct) + '%)/'\\n score_str += 'T: ' + str(self.t_score) + '(' + str(self.t_pct) + '%) - '\\n score_str += 'J: ' + str(self.j_score) + '(' + str(self.j_pct) + '%)/'\\n score_str += 'P: ' + str(self.p_score) + '(' + str(self.p_pct) + '%)'\\n return score_str\",\n \"def collect_stats(games: List[BaseGame], date_min = None, date_max = None):\\n if not games: games = self.games\\n\\n under2_5 = len(list(filter(lambda g: g.is_total_under(), games)))\\n under3_5 = len(list(filter(lambda g: g.is_total_under(3.5), games)))\\n under1_5 = len(list(filter(lambda g: g.is_total_under(1.5), games)))\\n\\n home_score = sum([g.FTHG for g in games])\\n away_score = sum([g.FTAG for g in games])\\n\\n home_wins = sum(1 for _ in filter(lambda g: g.is_home_win(), games))\\n away_wins = sum(1 for _ in filter(lambda g: g.is_away_win(), games))\\n draws = sum(1 for _ in filter(lambda g: g.is_draw(), games))\\n\\n return {\\n 'under2.5': float(under2_5) / len(games),\\n 'under3.5': float(under3_5) / len(games),\\n 'under1.5': float(under1_5) / len(games),\\n 'avgScoredHome': float(home_score) / len(games),\\n 'avgScoredAway': float(away_score) / len(games),\\n \\\"home_wins\\\": float(home_wins) / len(games),\\n \\\"away_wins\\\": float(away_wins) / len(games),\\n \\\"draws\\\": float(draws) / len(games),\\n }\",\n \"def _calculate_result(found, total):\\n return (found * 100) / total\",\n \"def play_game(game,standings_):\\n rand_nmr = random.random()\\n\\n standings_.loc[standings_.TEAMS==game['Home'],'MP'] += 1\\n standings_.loc[standings_.TEAMS==game['Away'],'MP'] += 1\\n\\n if rand_nmr < game['Prob Home']:\\n n_goals = goals() # a random number of goals is added to the goal tally, all games and in 1-0,2-0,3-0 or 4-0. This can be improved\\n standings_.loc[standings_.TEAMS==game['Home'],'W'] += 1\\n standings_.loc[standings_.TEAMS==game['Home'],'F'] += n_goals\\n standings_.loc[standings_.TEAMS==game['Away'],'L'] += 1\\n standings_.loc[standings_.TEAMS==game['Away'],'A'] += n_goals\\n standings_.loc[standings_.TEAMS==game['Home']][\\\"h2h\\\"].apply(lambda x:x.append(game['Away']))\\n\\n return 0\\n\\n elif rand_nmr < game['Prob Home'] + game['Prob Draw']:\\n # all draws end in 0-0 this can be improved\\n standings_.loc[standings_.TEAMS==game['Home'],'D'] += 1\\n standings_.loc[standings_.TEAMS==game['Away'],'D'] += 1\\n\\n return 1\\n\\n else:\\n n_goals = goals() # a random number of goals is added to the goal tally, all games and in 1-0,2-0,3-0 or 4-0. This can be improved\\n standings_.loc[standings_.TEAMS==game['Away'],'W'] += 1\\n standings_.loc[standings_.TEAMS==game['Away'],'F'] += n_goals\\n standings_.loc[standings_.TEAMS==game['Home'],'A'] += 1\\n standings_.loc[standings_.TEAMS==game['Home'],'L'] += n_goals\\n standings_.loc[standings_.TEAMS==game['Away']][\\\"h2h\\\"].apply(lambda x:x.append(game['Home']))\\n\\n return 2\",\n \"def display_stats(self):\\n print(\\\"Simulation took: {:.2f} seconds to execute\\\".format(time.time() - self.start_time))\\n for i, win in enumerate(self.wins):\\n average = 0\\n if win:\\n average = float(self.tries[i]) / win\\n print(\\\"Player {} wins: {} with (average number of rounds: {:.2f})\\\".format(i+1, win, average))\",\n \"def _compute_winrates(synergy, counter, heroes_released):\\n for i in range(heroes_released):\\n for j in range(heroes_released):\\n if i != j and i != 23 and j != 23:\\n if synergy['games'][i, j] != 0:\\n synergy['winrate'][i, j] = synergy['wins'][i, j] / \\\\\\n float(synergy['games'][i, j])\\n\\n if counter['games'][i, j] != 0:\\n counter['winrate'][i, j] = counter['wins'][i, j] / \\\\\\n float(counter['games'][i, j])\",\n \"def grade_inst(inst, population):\\n \\n # Initialize to keep track of score \\n inst_score = 0\\n \\n # Battle against each instance in population\\n for i in range(len(population)):\\n battle_result = inst.battle(population[i])\\n inst_score += battle_result[0]\\n \\n # Also record the score in the instance\\n inst.set_score(inst_score)\\n\\n return inst_score\",\n \"def calculate_scores():\\n all_people = models.Leaderboard.query.order_by(\\n models.Leaderboard.score.desc()).all()\\n print(all_people)\\n users = []\\n scores = []\\n for person in all_people:\\n users.append(person.username)\\n scores.append(person.score)\\n return users, scores\",\n \"def winrate(matches):\\n if not matches:\\n print('no matches')\\n return None\\n\\n win_loss = [match['result'] for match in matches]\\n return sum(win_loss)/len(win_loss)\",\n \"def set_total_reb_of_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n result = 0.00\\n try:\\n if bx[\\\"reb_of\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"reb_of\\\"] * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team[\\\"reb_of\\\"] + opp_team[\\\"reb_def\\\"])))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n self.total_reb_of_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def update_scores(self):\\r\\n totals = [0, 0, 0, 0]\\r\\n for player in range(0, 4):\\r\\n for round_num in range(0, 17):\\r\\n try:\\r\\n bid = int(self.spin_bids[player][round_num].get())\\r\\n tricks = int(self.spin_tricks[player][round_num].get())\\r\\n except ValueError:\\r\\n bid = -1\\r\\n tricks = -1\\r\\n score = calc_score(min(round_num+1, 13), bid, tricks)\\r\\n self.lbl_scores[player][round_num].configure(text=str(score))\\r\\n totals[player] += score\\r\\n for player in range(0, 4):\\r\\n self.lbl_totals[player].configure(text=str(totals[player]))\\r\\n return totals[0] + totals[1] + totals[2] + totals[3]\",\n \"def TeamScores(level,team_N):\\r\\n \\r\\n groupresults = Combined_Non_Compound_Results(level).groupby('Club') \\r\\n # groups clubs together in a big list just for NMR\\r\\n # will need to generalise for all categories\\r\\n\\r\\n LoR = [ frame for LoRs, frame in groupresults ]\\r\\n \\r\\n TeamTable = pd.DataFrame({},columns=['Club','Total Score', # initial empty\\r\\n 'Total Golds', 'Total Hits']) # dataframe\\r\\n \\r\\n# Uni = pd.DataFrame({},columns=['Name','Club','Score','Golds', 'Hits'])\\r\\n TeamComposition = [[],[],[],[]]\\r\\n for j in range(4): # only four clubs in the dataframe\\r\\n\\r\\n Uni = LoR[j][0:team_N] # jth club in index, gets top team_N archers\\r\\n Uni = Uni.reset_index(drop=True) # resets the index for UCL sublist\\r\\n UniName = Uni.loc[0,'Club']\\r\\n\\r\\n Scores=0\\r\\n Golds=0\\r\\n Hits=0\\r\\n \\r\\n TeamComposition[j].append(UniName)\\r\\n\\r\\n for i in range(team_N): # sums the score,golds and hits for uni club j\\r\\n Scores += Uni.loc[i,'Score']\\r\\n Golds += Uni.loc[i,'Golds']\\r\\n Hits += Uni.loc[i,'Hits']\\r\\n\\r\\n TeamComposition[j].append(Uni.loc[i,'Name'])\\r\\n \\r\\n TeamTable2 = pd.DataFrame({'Club': [UniName], \\r\\n 'Total Score': [Scores],\\r\\n 'Total Golds': [Golds], \\r\\n 'Total Hits': [Hits]},\\r\\n columns=['Club','Total Score', \\r\\n 'Total Golds', 'Total Hits'])\\r\\n \\r\\n TeamTable = TeamTable.append(TeamTable2) # appends each club data\\r\\n\\r\\n TeamTable = TeamTable.sort_values(['Total Score','Total Golds',\\r\\n 'Total Hits'],ascending=[False,False,\\r\\n False],na_position='last')\\r\\n TeamTable = TeamTable.reset_index(drop=True)\\r\\n print()\\r\\n print(TeamTable)\\r\\n print()\\r\\n \\r\\n \\r\\n FinalList = [[],[],[],[]]\\r\\n \\r\\n for h in range(4):\\r\\n for g in range(4):\\r\\n if TeamTable.iloc[h,0] == TeamComposition[g][0]:\\r\\n FinalList[h] = TeamComposition[g]\\r\\n\\r\\n \\r\\n for k in range(4):\\r\\n print(FinalList[k])\\r\\n print()\\r\\n\\r\\n if level == NovCategories:\\r\\n \\r\\n return print(\\\"----- End of Novice Team Scores -----\\\")\\r\\n \\r\\n if level == AllCategories:\\r\\n \\r\\n return print(\\\"----- End of Experienced Team Scores -----\\\")\",\n \"def percenter(rank, max_rank):\\n\\treturn 100 * (rank/(max_rank or 1))\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n result = 0\\n outcomes = range(1, num_die_sides + 1)\\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\\n for hand in possible:\\n result += score(held_dice + hand)\\n return float(result)/len(possible)\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def calc_stat_values(self):\",\n \"def rate(self, neighbors, labels):\\n num = 0\\n den = 0\\n for neighbor in neighbors:\\n lable = self.labels[neighbor[1]]\\n dest_to_neighbor = neighbor[0]\\n num += lable / dest_to_neighbor\\n den += 1 / dest_to_neighbor\\n return num/den\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67434204","0.6500815","0.6359718","0.63065845","0.63019216","0.6301762","0.6299715","0.6148283","0.6126874","0.6103746","0.59502584","0.59436804","0.59398586","0.5932481","0.58808863","0.58741057","0.58336693","0.58299714","0.57860583","0.5785277","0.57851714","0.5772505","0.5765083","0.5754176","0.57456493","0.5744941","0.57435244","0.57411337","0.5740637","0.57328707","0.57090527","0.5703763","0.5695928","0.5695037","0.56833076","0.5667735","0.56660813","0.5661647","0.5658868","0.564245","0.564245","0.5640655","0.563955","0.56324834","0.56269974","0.56265515","0.56263846","0.56194395","0.56164384","0.56158626","0.56150824","0.5611808","0.5603649","0.5599148","0.5596763","0.55725795","0.5567675","0.5562651","0.55621547","0.5558683","0.55546826","0.55500245","0.5549437","0.5549317","0.55458724","0.5544281","0.554114","0.5537532","0.55233663","0.55194324","0.5516322","0.5514533","0.5513997","0.5510753","0.55095863","0.5501924","0.5501501","0.5501018","0.55000347","0.5497445","0.549627","0.5494147","0.54901165","0.54873544","0.5487157","0.5484148","0.5483676","0.5482826","0.54821","0.54820836","0.54816294","0.54772824","0.54760695","0.54697263","0.54645133","0.5460016","0.5458558","0.54511875","0.54451436","0.54448134"],"string":"[\n \"0.67434204\",\n \"0.6500815\",\n \"0.6359718\",\n \"0.63065845\",\n \"0.63019216\",\n \"0.6301762\",\n \"0.6299715\",\n \"0.6148283\",\n \"0.6126874\",\n \"0.6103746\",\n \"0.59502584\",\n \"0.59436804\",\n \"0.59398586\",\n \"0.5932481\",\n \"0.58808863\",\n \"0.58741057\",\n \"0.58336693\",\n \"0.58299714\",\n \"0.57860583\",\n \"0.5785277\",\n \"0.57851714\",\n \"0.5772505\",\n \"0.5765083\",\n \"0.5754176\",\n \"0.57456493\",\n \"0.5744941\",\n \"0.57435244\",\n \"0.57411337\",\n \"0.5740637\",\n \"0.57328707\",\n \"0.57090527\",\n \"0.5703763\",\n \"0.5695928\",\n \"0.5695037\",\n \"0.56833076\",\n \"0.5667735\",\n \"0.56660813\",\n \"0.5661647\",\n \"0.5658868\",\n \"0.564245\",\n \"0.564245\",\n \"0.5640655\",\n \"0.563955\",\n \"0.56324834\",\n \"0.56269974\",\n \"0.56265515\",\n \"0.56263846\",\n \"0.56194395\",\n \"0.56164384\",\n \"0.56158626\",\n \"0.56150824\",\n \"0.5611808\",\n \"0.5603649\",\n \"0.5599148\",\n \"0.5596763\",\n \"0.55725795\",\n \"0.5567675\",\n \"0.5562651\",\n \"0.55621547\",\n \"0.5558683\",\n \"0.55546826\",\n \"0.55500245\",\n \"0.5549437\",\n \"0.5549317\",\n \"0.55458724\",\n \"0.5544281\",\n \"0.554114\",\n \"0.5537532\",\n \"0.55233663\",\n \"0.55194324\",\n \"0.5516322\",\n \"0.5514533\",\n \"0.5513997\",\n \"0.5510753\",\n \"0.55095863\",\n \"0.5501924\",\n \"0.5501501\",\n \"0.5501018\",\n \"0.55000347\",\n \"0.5497445\",\n \"0.549627\",\n \"0.5494147\",\n \"0.54901165\",\n \"0.54873544\",\n \"0.5487157\",\n \"0.5484148\",\n \"0.5483676\",\n \"0.5482826\",\n \"0.54821\",\n \"0.54820836\",\n \"0.54816294\",\n \"0.54772824\",\n \"0.54760695\",\n \"0.54697263\",\n \"0.54645133\",\n \"0.5460016\",\n \"0.5458558\",\n \"0.54511875\",\n \"0.54451436\",\n \"0.54448134\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6911841"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3091,"cells":{"query":{"kind":"string","value":"Method which calculate Total Rebound Percentage"},"document":{"kind":"string","value":"def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def set_total_reb_of_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"reb_of\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_of\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_of\"] + opp_team[\"reb_def\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n self.total_reb_of_percentage = \"%.2f\" % round(result, 2)","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def set_total_reb_def_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_def\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_def\"] + opp_team[\"reb_of\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_def_percentage = \"%.2f\" % round(result, 2)","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def represent_total_percent(self, length):\n numpkgs = self.totals['numpkgs']\n dlpkgs = self.totals['dlpkgs']\n return self.represent_percent(dlpkgs, numpkgs, length)","def pct(self):\n\t\treturn self.bottle.pct()","def percentage(count, total):\n return count / total * 100","def pct_bust(data):\n return round((data[\"new_total\"] > 21).sum() / len(data), 3)","def calculate_percent(self, total_number, some_number):\n\t\treturn (some_number * 100) / total_number","def pct_helper(self,k,d,total):\n if k in d:\n return 100.0*d[k]/total\n else:\n return -100.0","def percent_raised(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.total_raised() * 100 / total_cost, 2)\n else:\n return 0","def _calculate_result(found, total):\n return (found * 100) / total","def __call__(self, relsSortedByScores, qrelDict):\n result = 0.\n postQty = len(qrelDict)\n\n pos = 0\n for i, rel in enumerate(relsSortedByScores):\n if rel > RELEVANCE_THRESHOLD:\n pos += 1.\n result += pos / (i + 1.)\n\n return result / postQty","def rF(count, total):\n\treturn float(count)/float(total)","def getPercent(*args):","def getPercent(*args):","def update_percent(self):","def compute_total_customs_duty(self):\n for rec in self:\n total = 0.0\n extra_duty = 0.0\n price_total = rec.quantity * rec.unit_price\n# total = (price_total * duty_percentage)/100\n rec.price_total = price_total\n# for hts in rec.hts_ids:\n# if hts.extra_duty_applicable:\n# extra_duty += ((rec.quantity/hts.quantity) * hts.extra_duty)\n# rec.total = total + extra_duty\n\n return True","def patrimony_total(self):\n pass","def percent_usage(value, total):\n if total:\n return float(value) * 100.0 / (float(total) + float(value))\n else:\n return 100.0","def _prorata_rate(self, days_used, days_in_month):\n return (100 * days_used // days_in_month) / 100.0","def grand_total(self):\n return sum(self.grid[pos][1] for pos in assignable_positions if self.grid[pos][0]) + self.grid[\"nb\"][1]","def percentage_update(self):\n\n self.event_update()\n return self.percentage","def CalculateBoundProbability(self, psi):\n\n\t\t_, _, _, boundTotal = self.CalculateBoundDistribution(psi)\n\n\t\treturn boundTotal","def get_free_set_percentage(self, params):\n raise NotImplementedError()","def percentage(self):\n temp = self.cpu_freq_time_spent.copy()\n for i in self.cpu_freq_time_spent:\n total = 0\n for j in self.cpu_freq_time_spent[i]:\n total += self.cpu_freq_time_spent[i][j]\n for j in self.cpu_freq_time_spent[i]:\n if total != 0:\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\n else:\n temp[i][j] = 0\n return temp","def fractionPassing(self):\n return self.cut.entries / self.entries","def robbins(counts):\n return float(singles(counts))/counts.sum()","def norm_percent(raw):\n if sum(raw) != 0:\n return [float(i)/sum(raw)*100 for i in raw]\n else:\n return [0 for i in raw]","def rate(self, neighbors, labels):\n num = 0\n den = 0\n for neighbor in neighbors:\n lable = self.labels[neighbor[1]]\n dest_to_neighbor = neighbor[0]\n num += lable / dest_to_neighbor\n den += 1 / dest_to_neighbor\n return num/den","def calculate_profit(self):","def calculate_finalscore(self):\n\n if self.count!=0:\n print(self.count)\n print(self.badGuess)\n self.finalScore=(self.total/self.count)- ((self.total/self.count)*(10*self.badGuess)/100)\n\n\n else:\n self.finalScore=self.total","def get_percentage(self):\n return self.PotTax_percentage","def compute_bound(self, sstats, totals):\n w = self.vocab_len\n t = self.num_time_slices\n\n term_1 = 0\n term_2 = 0\n term_3 = 0\n\n val = 0\n ent = 0\n\n chain_variance = self.chain_variance\n # computing mean, fwd_mean\n self.mean, self.fwd_mean = \\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\n self.zeta = self.update_zeta()\n\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\n\n logger.info(\"Computing bound, all times\")\n\n for t in range(1, t + 1):\n term_1 = 0.0\n term_2 = 0.0\n ent = 0.0\n for w in range(w):\n\n m = self.mean[w][t]\n prev_m = self.mean[w][t - 1]\n\n v = self.variance[w][t]\n\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\n # w_phi_l = sslm.w_phi_l[w][t - 1]\n # exp_i = np.exp(-prev_m)\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\n # (v / chain_variance) - np.log(chain_variance)\n\n term_1 += \\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\n term_2 += sstats[w][t - 1] * m\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\n\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\n val += term_2 + term_3 + ent - term_1\n\n return val","def percent_updated(self):\n return self.percent_complete - self.previous_percent_complete","def calculScore(self):\n for cell in self.notComputeRouter:\n if(cell.isCovered==True):\n self.score += 1000\n self.score += self.budget","def percent(value, total):\n if total:\n return float(value) * 100.0 / float(total)\n else:\n return 100.0","def life_insurance_to_recive_total(self):\n pass","def mask_percentage(self):\n return 100 - self.tissue_percentage","def proper_annulus_centres(self) -> Quantity:\n return self._proper_ann_centres","def usage_percent(used, total, _round=None):\r\n try:\r\n ret = (used / total) * 100\r\n except ZeroDivisionError:\r\n ret = 0\r\n if _round is not None:\r\n return round(ret, _round)\r\n else:\r\n return ret","def stretch_pct(cube,out,pct):\n\n try:\n isis.percent(from_=cube, to=out, percentage=pct)\n val = isis.getkey(from_=out, grpname=\"Results\", keyword=\"Value\").decode().replace('\\n', '')\n except ProcessError as e:\n val = None\n if val:\n return float(val)\n else:\n return None","def get_percentage(self):\n return self.percentage","def get_percentage(self):\n return self.percentage","def total_rewards(self) -> float:\n return self.__total_rewards","def _percent(self, lines_total, lines_covered):\n\n if lines_total == 0:\n return '0.0'\n return str(float(float(lines_covered) / float(lines_total)))","def calc_stat_values(self):","def get_gst_subtotals(self):\n self.__subtotal_gst = 0\n for current_item in self.__items_list:\n self.__subtotal_gst += current_item.calculate_gst()\n return self.__subtotal_gst","def ComputeNrb(self):\r\n pass","def __calculate_statistics(self, candidates):\n pdf = {}\n for candidate in candidates:\n neighbors = list(self.G.neighbors(candidate))\n capacity = sum([self.G.get_edge_data(candidate, n)[\"satoshis\"] for n in neighbors])\n average = capacity / len(neighbors)\n pdf[candidate] = average\n cumsum = sum(pdf.values())\n pdf = {k:v/cumsum for k,v in pdf.items()}\n w = 0.7\n print(\"percentage smoothed percentage capacity numchannels alias\")\n print(\"----------------------------------------------------------------------\")\n res_pdf = {}\n for k,v in pdf.items():\n neighbors = list(self.G.neighbors(k))\n capacity = sum([self.G.get_edge_data(k, n)[\"satoshis\"] for n in neighbors])\n name = k\n if \"alias\" in self.G.node[k]:\n name = self.G.node[k][\"alias\"]\n print(\"{:12.2f} \".format(100*v), \"{:12.2f} \".format(100*(w * v + (1-w)/len(candidates))) ,\"{:10} {:10} \".format( capacity, len(neighbors)), name)\n res_pdf[k] = (w * v + (1-w)/len(candidates))\n return res_pdf","def percent_b(self) -> float:\n return self._percent_b","def percentage(part, whole):\n return round((100 * float(part)/float(whole)),2)","def calc_pct_to_save_as_doublets(self):\n x, y = load_expected_doublet_rates( # pylint: disable=invalid-name\n \"/Users/austinhartman/Desktop/doublet-caller/src/expected_doublet_rates.csv\"\n )\n r = calculate_expected_doublet_rate(x, y) # pylint: disable=invalid-name\n return self.num_cells * r[\"coefficient\"] + r[\"intercept\"]","def total(self) -> float:\n\n remained_to_be_taxed = self.income\n # taxed = list()\n self.tax_amounts = []\n start_tax_range = 0\n end_tax_range = self.bracket\n\n for i, b in enumerate(self.bracket):\n\n amount_to_tax = b.end - start_tax_range\n t = Taxed(min(amount_to_tax, remained_to_be_taxed), b.rate,\n min(amount_to_tax, remained_to_be_taxed) * b.rate)\n self.tax_amounts.append(t)\n # print(i, start_t ax_range, b.end, amount_to_tax, b.rate)\n\n remained_to_be_taxed -= amount_to_tax\n # print(remained_to_be_taxed)\n\n if b.end > self.income:\n break\n\n start_tax_range = b.end\n\n # print(taxed)\n return sum([t.tax for t in self.tax_amounts])","def calc_percentage(count, total_count, percent_factor=100):\n percentage = Decimal(float(count) * float(percent_factor) / total_count)\n percentage = round(percentage, 2)\n return percentage","def evaluate_percentage_of_class_for_each_flight(df_flights_info):\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\n for row, col in df_new.iterrows():\n for item in list(df_new):\n number_booking = df_new.loc[row, item]\n total_booking = df_new.loc[row]['Total']\n percentage = float(number_booking / total_booking)\n df_new.at[row, item] = percentage\n df_new = df_new.drop(columns=['Total'])\n df_new = df_new.stack()\n df_new = df_new.reset_index(level=[0, 1])\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\n return df_flights_info","def percentage(self):\n return sum(self.chunk_percentage) / self.total_steps","def private_pension_total(self):\n pass","def relative_change(nr1, nr2):\n\n return float(((nr2 - nr1) / nr1) * 100)","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def calculatePercentChange(self, oldValue, newValue):\n return (((newValue - oldValue)/oldValue)*100)","def get_load_factor(self):\n # Your code here\n return self.total_items / self.capacity","def getClassBalance(pshapes, bounds, proj):\n\n xmin, ymin, xmax, ymax = bounds\n bpoly = Polygon([(xmin, ymax),\n (xmax, ymax),\n (xmax, ymin),\n (xmin, ymin)])\n project = partial(\n pyproj.transform,\n pyproj.Proj(proj='latlong', datum='WGS84'),\n proj)\n bpolyproj = transform(project, bpoly)\n totalarea = bpolyproj.area\n polyarea = 0\n for pshape in pshapes:\n polyarea += pshape.area\n\n return polyarea/totalarea","def coverage(self):\n try:\n return self.found * 100 / self.needed\n except ZeroDivisionError:\n return 100.0","def cal_expected_map(self, ranking_list, total_rel=0):\r\n s = 0.0\r\n pr = 0\r\n pn = 0\r\n for ele in reversed(ranking_list):\r\n rel_doc_cnt = ele[0]\r\n this_doc_cnt = ele[1]\r\n nonrel_doc_cnt = this_doc_cnt - rel_doc_cnt\r\n s += self.A(pr, pn, rel_doc_cnt, nonrel_doc_cnt)\r\n pr += rel_doc_cnt\r\n pn += nonrel_doc_cnt\r\n total_rel += rel_doc_cnt\r\n #print s/total_rel\r\n if total_rel == 0:\r\n return 0\r\n return s/total_rel","def percentageChange(self):\n try:\n curPrice = self.dailyData[-1].currentPrice\n closePrice = self.historicData[-1].closePrice\n except IndexError: # Just return zero when no historic or dailyData is available yet\n return 0.0\n return (curPrice - closePrice)/closePrice * 100","def __call__(self, outcome):\n if not hasattr(self, 'total'):\n self.total = sum(self.values())\n return self[outcome] / self.total","def getTotalBusinessPercentForSalePercents(sc_sp:float, lc_sp:float):\n sc_tbp,lc_tbp,actualRainPercent = 0.0,0.0,0.0\n for i in range(int(Problem2.TOTAL_WEEKS)):\n isRainy = Problem2.eventOccurred(Problem2.RAIN_PERCENT)\n if isRainy:\n actualRainPercent += 1\n sc_hasSale = Problem2.eventOccurred(sc_sp)\n lc_hasSale = Problem2.eventOccurred(lc_sp)\n sc_ns_bp, lc_ns_bp, ss_bp = Problem2.setBusinessPercents(isRainy)\n sc_bp, lc_bp = Problem2.getBusinessPercentBySales(sc_hasSale, lc_hasSale, sc_ns_bp, lc_ns_bp, ss_bp)\n sc_tbp += sc_bp\n lc_tbp += lc_bp\n\n sc_tbp /= Problem2.TOTAL_WEEKS\n lc_tbp /= Problem2.TOTAL_WEEKS\n actualRainPercent /= Problem2.TOTAL_WEEKS\n return sc_tbp, lc_tbp, actualRainPercent","def percentage(a, b):\n return (a * 100.0) / b","def calculate_gpa(self):\n cur_node = self.head\n gpa = 0\n total_credits = 0\n while cur_node is not None:\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\n total_credits += cur_node.data.credit_hr()\n cur_node = cur_node.next\n if total_credits == 0:\n return 0\n return gpa / total_credits","def return_on_total_assets():\r\n x = float(input(\"Please Enter Net Income Value: \"))\r\n y = float(input(\"Please Enter Interest Expense Value: \"))\r\n z = float(input(\"Please Enter Beginning Total Assets Value: \"))\r\n w = float(input(\"Please Enter Ending Total Assets Value: \"))\r\n d = ((float(x)+float(y)) / ((float(z)+float(w)) / float(2))) * float(100)\r\n print \">> Your Rate of Return on Total Assets is\",round(d,1),\"%\"","def overall_reduction(self):\n return 84","def get_price_subtotals(self):\n self.__subtotal_price = 0\n for current_item in self.__items_list:\n self.__subtotal_price += current_item.get_item_base_price()\n return self.__subtotal_price","def as_percent(self):\n if self.dynamic:\n self._update_db_obj()\n return f\"{(self._db_obj.progress / self._db_obj.total) * 100}%\"","def get_percent(self):\n return self.percent","def calculate_amount_payable_rule_old(self, total):\n return self.amount_raised * Decimal(0.95)","def percentages(self) -> pandas.Series:\n if self._percentages is None:\n scalar = 1 if self.use_fraction else 100\n self._percentages = scalar * self.counts/self.total\n return self._percentages","def percent_processed(self):\n try:\n return (self.pos / self.data_encap.size) * 100.0\n except ZeroDivisionError:\n return 100.0","def calculate(self) -> float:","def _set_percentage(self):\n\n step = float(self.step)\n end = float(self.end)\n self.percentage = format((100 * step / end), '.1f')","def normalize(self):\n total = self.total()\n for x in self.d:\n self.d[x] /= total\n return total","def percent_left(self):\n return 100 - self.percent_complete","def percent(self):\r\n return self._percent","def calculate_total(self):\n if self.total_price == 0:\n for discount in self.discounts:\n for item in self.items:\n item.add_discount(discount)\n\n for item in self.items:\n self.total_price += item.final_price()\n\n return self.total_price","def set_effective_field_goal_percentage(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tcConv = float(bx[\"t2p_conv\"] + bx[\"t3p_conv\"])\n result = 0.00\n if tcInt > 0:\n result = ((tcConv + (0.5 * float(bx[\"t3p_conv\"]))) / tcInt) * 100\n self.effective_field_goal_percentage = \"%.2f\" % round(result, 2)","def recall(self) -> float:\n if self.ref_ignored:\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\n self.num_ignored += num_ref_ignored\n # True Positive = the number of unignored reference mappings that are Positive\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\n # False Negative = the number of unignored reference mappings that are Negative\n fn = len(self.ref_set) - tp - num_ref_ignored\n return tp / (tp + fn)","def get_duty_percentage(self):\n container_line_ids = self\n hbl_customs_obj = self.env['hbl.customs.duty']\n for line in container_line_ids:\n p_line = line.purchase_line\n #Get the supplier from product by using po supplier id.\n product_supplier_id = p_line.product_id.seller_ids.filtered(lambda rec:rec.name.id == p_line.partner_id.id and rec.hts_codes_ids)\n #Get HTS code of the supplier\n hts_codes_ids = product_supplier_id and product_supplier_id[0].hts_codes_ids or False\n if hts_codes_ids:\n percentage = sum(hts_codes_ids.mapped('percentage'))\n line_customs_id = hbl_customs_obj.create({'hbl_line_id' : line.id,\n 'hts_ids': [(6,_, hts_codes_ids.ids)],\n 'duty_percentage': percentage,\n 'quantity' : line.qty_to_load,\n 'unit_price' : p_line.price_unit\n })\n line.write({'line_customs_id' : line_customs_id.id})","def calculate_vote_fractions():\n return _calculate_vote_fractions(models.get_candidate_to_vote_count())","def get_average_percision_(qres, ibs=None, gt_aids=None):\n recall_range_, p_interp_curve = get_interpolated_precision_vs_recall_(qres, ibs=ibs, gt_aids=gt_aids)\n\n if recall_range_ is None:\n ave_p = np.nan\n else:\n ave_p = p_interp_curve.sum() / p_interp_curve.size\n\n return ave_p","def compute_stats(self):\n if self.stats is not None:\n return\n self.stats = np.zeros(STEPS_MAX + 1)\n for m in self.missions:\n m.compute_stats()\n self.stats += 100 * m.stats\n self.stats /= len(self.missions)","def profit_per_item_percentage(self, pk=None):\n total_profit_percentage = 0\n total_cost = self.item_cost + self.shipping_cost + self.listing_fee + self.final_value_fee\n total_paid = self.shipping_paid + self.item_paid\n total_profit_percentage = round(100*((total_paid - total_cost) / total_cost), 2)\n return total_profit_percentage","def get_total(self):\n\n total = super().get_total()\n if self.qty < 10:\n total += 3.00\n return total","def percent_of(part, whole):\n return part * 100 / whole","def total_to_proportion(total_pronoun_dict):\n if total_pronoun_dict['total'] is 0:\n return total_pronoun_dict\n else:\n return{\n 'first_person_singular': total_pronoun_dict['first_person_singular']/total_pronoun_dict['total'],\n 'first_person_plural': total_pronoun_dict['first_person_plural']/total_pronoun_dict['total'],\n 'second_person': total_pronoun_dict['second_person']/total_pronoun_dict['total'],\n 'third_person_singular': total_pronoun_dict['third_person_singular']/total_pronoun_dict['total'],\n 'third_person_plural': total_pronoun_dict['third_person_plural']/total_pronoun_dict['total'],\n 'total': total_pronoun_dict['total']\n }","def getPercent(self):\n if isinstance(self.score,numbers.Number) and self.getMaximum():\n return (1.0*self.score/self.getMaximum())\n return None","def ram_percent(self):\n self.monitoring_object['ram_percent'] = \\\n psutil.virtual_memory().used","def calculateCurrentPercentageChange(self, Prices):\n threeDayMovingAverage = self.calculateLatestThreeDayMA(Prices)\n fifteenDayMovingAverage = self.calculateLatestFifteenDayMA(Prices)\n percentageChange = self.calculatePercentChange(\n fifteenDayMovingAverage, threeDayMovingAverage)\n return percentageChange","def percentCheck(currentTimeLabel, totalTimeLabel):\n # Updated 11/19/16\n try:\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\n except (ValueError , ZeroDivisionError):\n progPercent = 0\n \n return progPercent","def fitness(individual, divider, target_sum, target_multiply):\n\n sum_val = reduce(operator.add, individual[:divider], 0)\n multiply_val = reduce(operator.mul, individual[divider:], 1)\n \n sum_error = abs(target_sum - sum_val)\n sum_error = sum_error / target_sum\n\n multiply_error = abs(target_multiply - multiply_val)\n multiply_error = multiply_error / target_multiply\n\n #print(multiply_error, sum_error)\n #print(sum_error, multiply_error)\n return (multiply_error + sum_error)/2 * 100","def cagr(B, A, n):\n if B < 0: B = 0\n return (math.pow(B / A, 1 / n) - 1) * 100"],"string":"[\n \"def set_total_reb_of_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n result = 0.00\\n try:\\n if bx[\\\"reb_of\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"reb_of\\\"] * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team[\\\"reb_of\\\"] + opp_team[\\\"reb_def\\\"])))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n self.total_reb_of_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def set_total_reb_def_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"reb_def\\\"] * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"])))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_def_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def represent_total_percent(self, length):\\n numpkgs = self.totals['numpkgs']\\n dlpkgs = self.totals['dlpkgs']\\n return self.represent_percent(dlpkgs, numpkgs, length)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def pct_bust(data):\\n return round((data[\\\"new_total\\\"] > 21).sum() / len(data), 3)\",\n \"def calculate_percent(self, total_number, some_number):\\n\\t\\treturn (some_number * 100) / total_number\",\n \"def pct_helper(self,k,d,total):\\n if k in d:\\n return 100.0*d[k]/total\\n else:\\n return -100.0\",\n \"def percent_raised(self):\\n total_cost = self.total_cost()\\n if total_cost:\\n return round(self.total_raised() * 100 / total_cost, 2)\\n else:\\n return 0\",\n \"def _calculate_result(found, total):\\n return (found * 100) / total\",\n \"def __call__(self, relsSortedByScores, qrelDict):\\n result = 0.\\n postQty = len(qrelDict)\\n\\n pos = 0\\n for i, rel in enumerate(relsSortedByScores):\\n if rel > RELEVANCE_THRESHOLD:\\n pos += 1.\\n result += pos / (i + 1.)\\n\\n return result / postQty\",\n \"def rF(count, total):\\n\\treturn float(count)/float(total)\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def update_percent(self):\",\n \"def compute_total_customs_duty(self):\\n for rec in self:\\n total = 0.0\\n extra_duty = 0.0\\n price_total = rec.quantity * rec.unit_price\\n# total = (price_total * duty_percentage)/100\\n rec.price_total = price_total\\n# for hts in rec.hts_ids:\\n# if hts.extra_duty_applicable:\\n# extra_duty += ((rec.quantity/hts.quantity) * hts.extra_duty)\\n# rec.total = total + extra_duty\\n\\n return True\",\n \"def patrimony_total(self):\\n pass\",\n \"def percent_usage(value, total):\\n if total:\\n return float(value) * 100.0 / (float(total) + float(value))\\n else:\\n return 100.0\",\n \"def _prorata_rate(self, days_used, days_in_month):\\n return (100 * days_used // days_in_month) / 100.0\",\n \"def grand_total(self):\\n return sum(self.grid[pos][1] for pos in assignable_positions if self.grid[pos][0]) + self.grid[\\\"nb\\\"][1]\",\n \"def percentage_update(self):\\n\\n self.event_update()\\n return self.percentage\",\n \"def CalculateBoundProbability(self, psi):\\n\\n\\t\\t_, _, _, boundTotal = self.CalculateBoundDistribution(psi)\\n\\n\\t\\treturn boundTotal\",\n \"def get_free_set_percentage(self, params):\\n raise NotImplementedError()\",\n \"def percentage(self):\\n temp = self.cpu_freq_time_spent.copy()\\n for i in self.cpu_freq_time_spent:\\n total = 0\\n for j in self.cpu_freq_time_spent[i]:\\n total += self.cpu_freq_time_spent[i][j]\\n for j in self.cpu_freq_time_spent[i]:\\n if total != 0:\\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\\n else:\\n temp[i][j] = 0\\n return temp\",\n \"def fractionPassing(self):\\n return self.cut.entries / self.entries\",\n \"def robbins(counts):\\n return float(singles(counts))/counts.sum()\",\n \"def norm_percent(raw):\\n if sum(raw) != 0:\\n return [float(i)/sum(raw)*100 for i in raw]\\n else:\\n return [0 for i in raw]\",\n \"def rate(self, neighbors, labels):\\n num = 0\\n den = 0\\n for neighbor in neighbors:\\n lable = self.labels[neighbor[1]]\\n dest_to_neighbor = neighbor[0]\\n num += lable / dest_to_neighbor\\n den += 1 / dest_to_neighbor\\n return num/den\",\n \"def calculate_profit(self):\",\n \"def calculate_finalscore(self):\\n\\n if self.count!=0:\\n print(self.count)\\n print(self.badGuess)\\n self.finalScore=(self.total/self.count)- ((self.total/self.count)*(10*self.badGuess)/100)\\n\\n\\n else:\\n self.finalScore=self.total\",\n \"def get_percentage(self):\\n return self.PotTax_percentage\",\n \"def compute_bound(self, sstats, totals):\\n w = self.vocab_len\\n t = self.num_time_slices\\n\\n term_1 = 0\\n term_2 = 0\\n term_3 = 0\\n\\n val = 0\\n ent = 0\\n\\n chain_variance = self.chain_variance\\n # computing mean, fwd_mean\\n self.mean, self.fwd_mean = \\\\\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\\n self.zeta = self.update_zeta()\\n\\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\\n\\n logger.info(\\\"Computing bound, all times\\\")\\n\\n for t in range(1, t + 1):\\n term_1 = 0.0\\n term_2 = 0.0\\n ent = 0.0\\n for w in range(w):\\n\\n m = self.mean[w][t]\\n prev_m = self.mean[w][t - 1]\\n\\n v = self.variance[w][t]\\n\\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\\n # w_phi_l = sslm.w_phi_l[w][t - 1]\\n # exp_i = np.exp(-prev_m)\\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\\n # (v / chain_variance) - np.log(chain_variance)\\n\\n term_1 += \\\\\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\\n term_2 += sstats[w][t - 1] * m\\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\\n\\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\\n val += term_2 + term_3 + ent - term_1\\n\\n return val\",\n \"def percent_updated(self):\\n return self.percent_complete - self.previous_percent_complete\",\n \"def calculScore(self):\\n for cell in self.notComputeRouter:\\n if(cell.isCovered==True):\\n self.score += 1000\\n self.score += self.budget\",\n \"def percent(value, total):\\n if total:\\n return float(value) * 100.0 / float(total)\\n else:\\n return 100.0\",\n \"def life_insurance_to_recive_total(self):\\n pass\",\n \"def mask_percentage(self):\\n return 100 - self.tissue_percentage\",\n \"def proper_annulus_centres(self) -> Quantity:\\n return self._proper_ann_centres\",\n \"def usage_percent(used, total, _round=None):\\r\\n try:\\r\\n ret = (used / total) * 100\\r\\n except ZeroDivisionError:\\r\\n ret = 0\\r\\n if _round is not None:\\r\\n return round(ret, _round)\\r\\n else:\\r\\n return ret\",\n \"def stretch_pct(cube,out,pct):\\n\\n try:\\n isis.percent(from_=cube, to=out, percentage=pct)\\n val = isis.getkey(from_=out, grpname=\\\"Results\\\", keyword=\\\"Value\\\").decode().replace('\\\\n', '')\\n except ProcessError as e:\\n val = None\\n if val:\\n return float(val)\\n else:\\n return None\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def total_rewards(self) -> float:\\n return self.__total_rewards\",\n \"def _percent(self, lines_total, lines_covered):\\n\\n if lines_total == 0:\\n return '0.0'\\n return str(float(float(lines_covered) / float(lines_total)))\",\n \"def calc_stat_values(self):\",\n \"def get_gst_subtotals(self):\\n self.__subtotal_gst = 0\\n for current_item in self.__items_list:\\n self.__subtotal_gst += current_item.calculate_gst()\\n return self.__subtotal_gst\",\n \"def ComputeNrb(self):\\r\\n pass\",\n \"def __calculate_statistics(self, candidates):\\n pdf = {}\\n for candidate in candidates:\\n neighbors = list(self.G.neighbors(candidate))\\n capacity = sum([self.G.get_edge_data(candidate, n)[\\\"satoshis\\\"] for n in neighbors])\\n average = capacity / len(neighbors)\\n pdf[candidate] = average\\n cumsum = sum(pdf.values())\\n pdf = {k:v/cumsum for k,v in pdf.items()}\\n w = 0.7\\n print(\\\"percentage smoothed percentage capacity numchannels alias\\\")\\n print(\\\"----------------------------------------------------------------------\\\")\\n res_pdf = {}\\n for k,v in pdf.items():\\n neighbors = list(self.G.neighbors(k))\\n capacity = sum([self.G.get_edge_data(k, n)[\\\"satoshis\\\"] for n in neighbors])\\n name = k\\n if \\\"alias\\\" in self.G.node[k]:\\n name = self.G.node[k][\\\"alias\\\"]\\n print(\\\"{:12.2f} \\\".format(100*v), \\\"{:12.2f} \\\".format(100*(w * v + (1-w)/len(candidates))) ,\\\"{:10} {:10} \\\".format( capacity, len(neighbors)), name)\\n res_pdf[k] = (w * v + (1-w)/len(candidates))\\n return res_pdf\",\n \"def percent_b(self) -> float:\\n return self._percent_b\",\n \"def percentage(part, whole):\\n return round((100 * float(part)/float(whole)),2)\",\n \"def calc_pct_to_save_as_doublets(self):\\n x, y = load_expected_doublet_rates( # pylint: disable=invalid-name\\n \\\"/Users/austinhartman/Desktop/doublet-caller/src/expected_doublet_rates.csv\\\"\\n )\\n r = calculate_expected_doublet_rate(x, y) # pylint: disable=invalid-name\\n return self.num_cells * r[\\\"coefficient\\\"] + r[\\\"intercept\\\"]\",\n \"def total(self) -> float:\\n\\n remained_to_be_taxed = self.income\\n # taxed = list()\\n self.tax_amounts = []\\n start_tax_range = 0\\n end_tax_range = self.bracket\\n\\n for i, b in enumerate(self.bracket):\\n\\n amount_to_tax = b.end - start_tax_range\\n t = Taxed(min(amount_to_tax, remained_to_be_taxed), b.rate,\\n min(amount_to_tax, remained_to_be_taxed) * b.rate)\\n self.tax_amounts.append(t)\\n # print(i, start_t ax_range, b.end, amount_to_tax, b.rate)\\n\\n remained_to_be_taxed -= amount_to_tax\\n # print(remained_to_be_taxed)\\n\\n if b.end > self.income:\\n break\\n\\n start_tax_range = b.end\\n\\n # print(taxed)\\n return sum([t.tax for t in self.tax_amounts])\",\n \"def calc_percentage(count, total_count, percent_factor=100):\\n percentage = Decimal(float(count) * float(percent_factor) / total_count)\\n percentage = round(percentage, 2)\\n return percentage\",\n \"def evaluate_percentage_of_class_for_each_flight(df_flights_info):\\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\\n for row, col in df_new.iterrows():\\n for item in list(df_new):\\n number_booking = df_new.loc[row, item]\\n total_booking = df_new.loc[row]['Total']\\n percentage = float(number_booking / total_booking)\\n df_new.at[row, item] = percentage\\n df_new = df_new.drop(columns=['Total'])\\n df_new = df_new.stack()\\n df_new = df_new.reset_index(level=[0, 1])\\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\\n return df_flights_info\",\n \"def percentage(self):\\n return sum(self.chunk_percentage) / self.total_steps\",\n \"def private_pension_total(self):\\n pass\",\n \"def relative_change(nr1, nr2):\\n\\n return float(((nr2 - nr1) / nr1) * 100)\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def calculatePercentChange(self, oldValue, newValue):\\n return (((newValue - oldValue)/oldValue)*100)\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.total_items / self.capacity\",\n \"def getClassBalance(pshapes, bounds, proj):\\n\\n xmin, ymin, xmax, ymax = bounds\\n bpoly = Polygon([(xmin, ymax),\\n (xmax, ymax),\\n (xmax, ymin),\\n (xmin, ymin)])\\n project = partial(\\n pyproj.transform,\\n pyproj.Proj(proj='latlong', datum='WGS84'),\\n proj)\\n bpolyproj = transform(project, bpoly)\\n totalarea = bpolyproj.area\\n polyarea = 0\\n for pshape in pshapes:\\n polyarea += pshape.area\\n\\n return polyarea/totalarea\",\n \"def coverage(self):\\n try:\\n return self.found * 100 / self.needed\\n except ZeroDivisionError:\\n return 100.0\",\n \"def cal_expected_map(self, ranking_list, total_rel=0):\\r\\n s = 0.0\\r\\n pr = 0\\r\\n pn = 0\\r\\n for ele in reversed(ranking_list):\\r\\n rel_doc_cnt = ele[0]\\r\\n this_doc_cnt = ele[1]\\r\\n nonrel_doc_cnt = this_doc_cnt - rel_doc_cnt\\r\\n s += self.A(pr, pn, rel_doc_cnt, nonrel_doc_cnt)\\r\\n pr += rel_doc_cnt\\r\\n pn += nonrel_doc_cnt\\r\\n total_rel += rel_doc_cnt\\r\\n #print s/total_rel\\r\\n if total_rel == 0:\\r\\n return 0\\r\\n return s/total_rel\",\n \"def percentageChange(self):\\n try:\\n curPrice = self.dailyData[-1].currentPrice\\n closePrice = self.historicData[-1].closePrice\\n except IndexError: # Just return zero when no historic or dailyData is available yet\\n return 0.0\\n return (curPrice - closePrice)/closePrice * 100\",\n \"def __call__(self, outcome):\\n if not hasattr(self, 'total'):\\n self.total = sum(self.values())\\n return self[outcome] / self.total\",\n \"def getTotalBusinessPercentForSalePercents(sc_sp:float, lc_sp:float):\\n sc_tbp,lc_tbp,actualRainPercent = 0.0,0.0,0.0\\n for i in range(int(Problem2.TOTAL_WEEKS)):\\n isRainy = Problem2.eventOccurred(Problem2.RAIN_PERCENT)\\n if isRainy:\\n actualRainPercent += 1\\n sc_hasSale = Problem2.eventOccurred(sc_sp)\\n lc_hasSale = Problem2.eventOccurred(lc_sp)\\n sc_ns_bp, lc_ns_bp, ss_bp = Problem2.setBusinessPercents(isRainy)\\n sc_bp, lc_bp = Problem2.getBusinessPercentBySales(sc_hasSale, lc_hasSale, sc_ns_bp, lc_ns_bp, ss_bp)\\n sc_tbp += sc_bp\\n lc_tbp += lc_bp\\n\\n sc_tbp /= Problem2.TOTAL_WEEKS\\n lc_tbp /= Problem2.TOTAL_WEEKS\\n actualRainPercent /= Problem2.TOTAL_WEEKS\\n return sc_tbp, lc_tbp, actualRainPercent\",\n \"def percentage(a, b):\\n return (a * 100.0) / b\",\n \"def calculate_gpa(self):\\n cur_node = self.head\\n gpa = 0\\n total_credits = 0\\n while cur_node is not None:\\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\\n total_credits += cur_node.data.credit_hr()\\n cur_node = cur_node.next\\n if total_credits == 0:\\n return 0\\n return gpa / total_credits\",\n \"def return_on_total_assets():\\r\\n x = float(input(\\\"Please Enter Net Income Value: \\\"))\\r\\n y = float(input(\\\"Please Enter Interest Expense Value: \\\"))\\r\\n z = float(input(\\\"Please Enter Beginning Total Assets Value: \\\"))\\r\\n w = float(input(\\\"Please Enter Ending Total Assets Value: \\\"))\\r\\n d = ((float(x)+float(y)) / ((float(z)+float(w)) / float(2))) * float(100)\\r\\n print \\\">> Your Rate of Return on Total Assets is\\\",round(d,1),\\\"%\\\"\",\n \"def overall_reduction(self):\\n return 84\",\n \"def get_price_subtotals(self):\\n self.__subtotal_price = 0\\n for current_item in self.__items_list:\\n self.__subtotal_price += current_item.get_item_base_price()\\n return self.__subtotal_price\",\n \"def as_percent(self):\\n if self.dynamic:\\n self._update_db_obj()\\n return f\\\"{(self._db_obj.progress / self._db_obj.total) * 100}%\\\"\",\n \"def get_percent(self):\\n return self.percent\",\n \"def calculate_amount_payable_rule_old(self, total):\\n return self.amount_raised * Decimal(0.95)\",\n \"def percentages(self) -> pandas.Series:\\n if self._percentages is None:\\n scalar = 1 if self.use_fraction else 100\\n self._percentages = scalar * self.counts/self.total\\n return self._percentages\",\n \"def percent_processed(self):\\n try:\\n return (self.pos / self.data_encap.size) * 100.0\\n except ZeroDivisionError:\\n return 100.0\",\n \"def calculate(self) -> float:\",\n \"def _set_percentage(self):\\n\\n step = float(self.step)\\n end = float(self.end)\\n self.percentage = format((100 * step / end), '.1f')\",\n \"def normalize(self):\\n total = self.total()\\n for x in self.d:\\n self.d[x] /= total\\n return total\",\n \"def percent_left(self):\\n return 100 - self.percent_complete\",\n \"def percent(self):\\r\\n return self._percent\",\n \"def calculate_total(self):\\n if self.total_price == 0:\\n for discount in self.discounts:\\n for item in self.items:\\n item.add_discount(discount)\\n\\n for item in self.items:\\n self.total_price += item.final_price()\\n\\n return self.total_price\",\n \"def set_effective_field_goal_percentage(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tcConv = float(bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"])\\n result = 0.00\\n if tcInt > 0:\\n result = ((tcConv + (0.5 * float(bx[\\\"t3p_conv\\\"]))) / tcInt) * 100\\n self.effective_field_goal_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def recall(self) -> float:\\n if self.ref_ignored:\\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\\n self.num_ignored += num_ref_ignored\\n # True Positive = the number of unignored reference mappings that are Positive\\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\\n # False Negative = the number of unignored reference mappings that are Negative\\n fn = len(self.ref_set) - tp - num_ref_ignored\\n return tp / (tp + fn)\",\n \"def get_duty_percentage(self):\\n container_line_ids = self\\n hbl_customs_obj = self.env['hbl.customs.duty']\\n for line in container_line_ids:\\n p_line = line.purchase_line\\n #Get the supplier from product by using po supplier id.\\n product_supplier_id = p_line.product_id.seller_ids.filtered(lambda rec:rec.name.id == p_line.partner_id.id and rec.hts_codes_ids)\\n #Get HTS code of the supplier\\n hts_codes_ids = product_supplier_id and product_supplier_id[0].hts_codes_ids or False\\n if hts_codes_ids:\\n percentage = sum(hts_codes_ids.mapped('percentage'))\\n line_customs_id = hbl_customs_obj.create({'hbl_line_id' : line.id,\\n 'hts_ids': [(6,_, hts_codes_ids.ids)],\\n 'duty_percentage': percentage,\\n 'quantity' : line.qty_to_load,\\n 'unit_price' : p_line.price_unit\\n })\\n line.write({'line_customs_id' : line_customs_id.id})\",\n \"def calculate_vote_fractions():\\n return _calculate_vote_fractions(models.get_candidate_to_vote_count())\",\n \"def get_average_percision_(qres, ibs=None, gt_aids=None):\\n recall_range_, p_interp_curve = get_interpolated_precision_vs_recall_(qres, ibs=ibs, gt_aids=gt_aids)\\n\\n if recall_range_ is None:\\n ave_p = np.nan\\n else:\\n ave_p = p_interp_curve.sum() / p_interp_curve.size\\n\\n return ave_p\",\n \"def compute_stats(self):\\n if self.stats is not None:\\n return\\n self.stats = np.zeros(STEPS_MAX + 1)\\n for m in self.missions:\\n m.compute_stats()\\n self.stats += 100 * m.stats\\n self.stats /= len(self.missions)\",\n \"def profit_per_item_percentage(self, pk=None):\\n total_profit_percentage = 0\\n total_cost = self.item_cost + self.shipping_cost + self.listing_fee + self.final_value_fee\\n total_paid = self.shipping_paid + self.item_paid\\n total_profit_percentage = round(100*((total_paid - total_cost) / total_cost), 2)\\n return total_profit_percentage\",\n \"def get_total(self):\\n\\n total = super().get_total()\\n if self.qty < 10:\\n total += 3.00\\n return total\",\n \"def percent_of(part, whole):\\n return part * 100 / whole\",\n \"def total_to_proportion(total_pronoun_dict):\\n if total_pronoun_dict['total'] is 0:\\n return total_pronoun_dict\\n else:\\n return{\\n 'first_person_singular': total_pronoun_dict['first_person_singular']/total_pronoun_dict['total'],\\n 'first_person_plural': total_pronoun_dict['first_person_plural']/total_pronoun_dict['total'],\\n 'second_person': total_pronoun_dict['second_person']/total_pronoun_dict['total'],\\n 'third_person_singular': total_pronoun_dict['third_person_singular']/total_pronoun_dict['total'],\\n 'third_person_plural': total_pronoun_dict['third_person_plural']/total_pronoun_dict['total'],\\n 'total': total_pronoun_dict['total']\\n }\",\n \"def getPercent(self):\\n if isinstance(self.score,numbers.Number) and self.getMaximum():\\n return (1.0*self.score/self.getMaximum())\\n return None\",\n \"def ram_percent(self):\\n self.monitoring_object['ram_percent'] = \\\\\\n psutil.virtual_memory().used\",\n \"def calculateCurrentPercentageChange(self, Prices):\\n threeDayMovingAverage = self.calculateLatestThreeDayMA(Prices)\\n fifteenDayMovingAverage = self.calculateLatestFifteenDayMA(Prices)\\n percentageChange = self.calculatePercentChange(\\n fifteenDayMovingAverage, threeDayMovingAverage)\\n return percentageChange\",\n \"def percentCheck(currentTimeLabel, totalTimeLabel):\\n # Updated 11/19/16\\n try:\\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\\n except (ValueError , ZeroDivisionError):\\n progPercent = 0\\n \\n return progPercent\",\n \"def fitness(individual, divider, target_sum, target_multiply):\\n\\n sum_val = reduce(operator.add, individual[:divider], 0)\\n multiply_val = reduce(operator.mul, individual[divider:], 1)\\n \\n sum_error = abs(target_sum - sum_val)\\n sum_error = sum_error / target_sum\\n\\n multiply_error = abs(target_multiply - multiply_val)\\n multiply_error = multiply_error / target_multiply\\n\\n #print(multiply_error, sum_error)\\n #print(sum_error, multiply_error)\\n return (multiply_error + sum_error)/2 * 100\",\n \"def cagr(B, A, n):\\n if B < 0: B = 0\\n return (math.pow(B / A, 1 / n) - 1) * 100\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6523484","0.6491968","0.63697445","0.6303792","0.6300233","0.62549525","0.6121597","0.6087575","0.60844654","0.6044818","0.6027688","0.6009361","0.5989413","0.5969596","0.59609574","0.59609574","0.59606254","0.5904455","0.5899307","0.58770585","0.584258","0.58401334","0.58382976","0.5824316","0.5794439","0.5781197","0.5766814","0.5712529","0.57073605","0.57034516","0.56790906","0.56403285","0.56107545","0.56088257","0.55992335","0.5596763","0.5595719","0.557121","0.55671036","0.55598134","0.55472976","0.5547236","0.55348074","0.55348074","0.5533357","0.5528287","0.5525748","0.5525052","0.55243754","0.55156636","0.5514154","0.5513591","0.5511515","0.551105","0.5507345","0.5504536","0.55025876","0.5499663","0.54978704","0.54940504","0.54933256","0.5486853","0.5482061","0.5481559","0.547937","0.5473942","0.54581296","0.5455525","0.54546916","0.5450097","0.54447657","0.5431445","0.54272735","0.5421677","0.5416862","0.5413267","0.54113734","0.5397872","0.5394833","0.53911483","0.5379467","0.53628045","0.5361172","0.53595567","0.535791","0.5354153","0.5351761","0.53517336","0.53496337","0.53494453","0.5348908","0.53352207","0.53317803","0.5331302","0.5330255","0.53278524","0.53260463","0.5315842","0.5304827","0.5303798"],"string":"[\n \"0.6523484\",\n \"0.6491968\",\n \"0.63697445\",\n \"0.6303792\",\n \"0.6300233\",\n \"0.62549525\",\n \"0.6121597\",\n \"0.6087575\",\n \"0.60844654\",\n \"0.6044818\",\n \"0.6027688\",\n \"0.6009361\",\n \"0.5989413\",\n \"0.5969596\",\n \"0.59609574\",\n \"0.59609574\",\n \"0.59606254\",\n \"0.5904455\",\n \"0.5899307\",\n \"0.58770585\",\n \"0.584258\",\n \"0.58401334\",\n \"0.58382976\",\n \"0.5824316\",\n \"0.5794439\",\n \"0.5781197\",\n \"0.5766814\",\n \"0.5712529\",\n \"0.57073605\",\n \"0.57034516\",\n \"0.56790906\",\n \"0.56403285\",\n \"0.56107545\",\n \"0.56088257\",\n \"0.55992335\",\n \"0.5596763\",\n \"0.5595719\",\n \"0.557121\",\n \"0.55671036\",\n \"0.55598134\",\n \"0.55472976\",\n \"0.5547236\",\n \"0.55348074\",\n \"0.55348074\",\n \"0.5533357\",\n \"0.5528287\",\n \"0.5525748\",\n \"0.5525052\",\n \"0.55243754\",\n \"0.55156636\",\n \"0.5514154\",\n \"0.5513591\",\n \"0.5511515\",\n \"0.551105\",\n \"0.5507345\",\n \"0.5504536\",\n \"0.55025876\",\n \"0.5499663\",\n \"0.54978704\",\n \"0.54940504\",\n \"0.54933256\",\n \"0.5486853\",\n \"0.5482061\",\n \"0.5481559\",\n \"0.547937\",\n \"0.5473942\",\n \"0.54581296\",\n \"0.5455525\",\n \"0.54546916\",\n \"0.5450097\",\n \"0.54447657\",\n \"0.5431445\",\n \"0.54272735\",\n \"0.5421677\",\n \"0.5416862\",\n \"0.5413267\",\n \"0.54113734\",\n \"0.5397872\",\n \"0.5394833\",\n \"0.53911483\",\n \"0.5379467\",\n \"0.53628045\",\n \"0.5361172\",\n \"0.53595567\",\n \"0.535791\",\n \"0.5354153\",\n \"0.5351761\",\n \"0.53517336\",\n \"0.53496337\",\n \"0.53494453\",\n \"0.5348908\",\n \"0.53352207\",\n \"0.53317803\",\n \"0.5331302\",\n \"0.5330255\",\n \"0.53278524\",\n \"0.53260463\",\n \"0.5315842\",\n \"0.5304827\",\n \"0.5303798\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6903449"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3092,"cells":{"query":{"kind":"string","value":"Method which calculate Total Rebound Defensive Percentage"},"document":{"kind":"string","value":"def set_total_reb_def_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_def\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_def\"] + opp_team[\"reb_of\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_def_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)","def pct_bust(data):\n return round((data[\"new_total\"] > 21).sum() / len(data), 3)","def pct(self):\n\t\treturn self.bottle.pct()","def set_total_reb_of_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"reb_of\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_of\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_of\"] + opp_team[\"reb_def\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n self.total_reb_of_percentage = \"%.2f\" % round(result, 2)","def get_free_set_percentage(self, params):\n raise NotImplementedError()","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def percent_raised(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.total_raised() * 100 / total_cost, 2)\n else:\n return 0","def __call__(self, relsSortedByScores, qrelDict):\n result = 0.\n postQty = len(qrelDict)\n\n pos = 0\n for i, rel in enumerate(relsSortedByScores):\n if rel > RELEVANCE_THRESHOLD:\n pos += 1.\n result += pos / (i + 1.)\n\n return result / postQty","def compute_total_customs_duty(self):\n for rec in self:\n total = 0.0\n extra_duty = 0.0\n price_total = rec.quantity * rec.unit_price\n# total = (price_total * duty_percentage)/100\n rec.price_total = price_total\n# for hts in rec.hts_ids:\n# if hts.extra_duty_applicable:\n# extra_duty += ((rec.quantity/hts.quantity) * hts.extra_duty)\n# rec.total = total + extra_duty\n\n return True","def calculScore(self):\n for cell in self.notComputeRouter:\n if(cell.isCovered==True):\n self.score += 1000\n self.score += self.budget","def overall_reduction(self):\n return 84","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def calculate_profit(self):","def set_effective_field_goal_percentage(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tcConv = float(bx[\"t2p_conv\"] + bx[\"t3p_conv\"])\n result = 0.00\n if tcInt > 0:\n result = ((tcConv + (0.5 * float(bx[\"t3p_conv\"]))) / tcInt) * 100\n self.effective_field_goal_percentage = \"%.2f\" % round(result, 2)","def _prorata_rate(self, days_used, days_in_month):\n return (100 * days_used // days_in_month) / 100.0","def coverage(self):\n try:\n return self.found * 100 / self.needed\n except ZeroDivisionError:\n return 100.0","def max_occupancy_percent_for_deferred_work(self):\n return self._max_occupancy_percent_for_deferred_work","def _calc_freeze_probability(self, num_iterations, final_fraction):\n return 1.0 - (final_fraction ** (1.0 / num_iterations))","def mask_percentage(self):\n return 100 - self.tissue_percentage","def penalty(self):\n return 0","def percentage(self):\n temp = self.cpu_freq_time_spent.copy()\n for i in self.cpu_freq_time_spent:\n total = 0\n for j in self.cpu_freq_time_spent[i]:\n total += self.cpu_freq_time_spent[i][j]\n for j in self.cpu_freq_time_spent[i]:\n if total != 0:\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\n else:\n temp[i][j] = 0\n return temp","def percent_usage(value, total):\n if total:\n return float(value) * 100.0 / (float(total) + float(value))\n else:\n return 100.0","def get_load_factor(self):\n # Your code here\n return self.total_items / self.capacity","def total_sdram_requirements(self):","def recall(self) -> float:\n if self.ref_ignored:\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\n self.num_ignored += num_ref_ignored\n # True Positive = the number of unignored reference mappings that are Positive\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\n # False Negative = the number of unignored reference mappings that are Negative\n fn = len(self.ref_set) - tp - num_ref_ignored\n return tp / (tp + fn)","def pct_helper(self,k,d,total):\n if k in d:\n return 100.0*d[k]/total\n else:\n return -100.0","def rF(count, total):\n\treturn float(count)/float(total)","def calculate_percent(self, total_number, some_number):\n\t\treturn (some_number * 100) / total_number","def update_percent(self):","def compute_sufficient_stats(self):\n self.counts = (np.sum(self.resp, axis=0) + 10e-30)\n # print(self.counts)\n for k in range(self.k):\n self.means[k] = np.sum(self.resp[n, k] * self.x[n] for n in range(self.n)) / self.counts[k]\n self.covars[k] = np.sum(self.resp[n, k] * (self.x[n] - self.means[k]) @ (self.x[n] - self.means[k]).T\n for n in range(self.n)) / self.counts[k]\n self.covars[k] = np.nan_to_num(self.covars[k])\n self.means[k] = np.nan_to_num(self.means[k])","def life_insurance_to_recive_total(self):\n pass","def revenue_landfill(self) -> float:\n return self.income_statement.revenue.operating_revenue * (\n 1 - self.inputs.allocation_to_collection_unit\n )","def cost(self) -> float:","def get_expected_cost(self):","def getPercent(*args):","def getPercent(*args):","def _calculate_result(found, total):\n return (found * 100) / total","def set_defensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0:\n opp_fga = opp_team[\"t2p_int\"] + opp_team[\"t3p_int\"]\n opp_fgm = opp_team[\"t2p_conv\"] + opp_team[\"t3p_conv\"]\n try:\n dor = Decimal(opp_team[\"reb_of\"] / (opp_team[\"reb_of\"] + team[\"reb_def\"]))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n dor = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n dor = 0\n\n try:\n dfg = Decimal(opp_fgm / opp_fga)\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n dfg = 0\n try:\n fmwt = Decimal((dfg * (1 - dor)) / (dfg * (1 - dor) + (1 - dfg) * dor))\n except:\n fmwt = 0\n stops1 = bx[\"steals\"] + bx[\"block_shots\"] * fmwt * (1 - Decimal('1.07') * dor) + bx[\"reb_def\"] * (1 - fmwt)\n\n try:\n stops2 = (Decimal((opp_fga - opp_fgm - team[\"block_shots\"]) / team[\"minutes\"]) * fmwt * (1 - Decimal('1.07') * dor) + Decimal((opp_team[\"turnovers\"] - team[\"steals\"]) / team[\"minutes\"])) * bx[\"minutes\"] + Decimal(bx[\"fouls_cm\"] / team[\"fouls_cm\"]) * Decimal('0.4') * opp_team[\"tl_int\"] * (1 - Decimal(opp_team[\"tl_conv\"] / opp_team[\"tl_int\"]))**2\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n stops2 = 0\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n stops2 = 0\n\n stops = stops1 + stops2\n poss = self.get_team_possessions()\n if bx[\"minutes\"] > 0:\n stop_percentage = (float(stops) * float(opp_team[\"minutes\"])) / (float(poss) * float(bx[\"minutes\"]))\n else:\n stop_percentage = 0.00\n opp_points = opp_team[\"t2p_conv\"] * 2 + opp_team[\"t3p_conv\"] * 3 + opp_team[\"tl_conv\"]\n team_defensive_rating = 100 * (float(opp_points) / poss)\n try:\n d_pts_per_scposs = float(opp_points) / (float(opp_fgm) + (1 - (1 - (float(opp_team[\"tl_conv\"]) / float(opp_team[\"tl_int\"])))**2) * float(opp_team[\"tl_int\"])*0.4)\n result = Decimal(team_defensive_rating) + Decimal('0.2') * (100 * Decimal(d_pts_per_scposs) * (1 - Decimal(stop_percentage)) - Decimal(team_defensive_rating))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n d_pts_per_scposs = 0\n result = 0.00\n\n\n\n # print(\"dor: \" + str(dor))\n # print(\"dfg: \" + str(dfg))\n # print(\"fmwt: \" + str(fmwt))\n # print(\"stops1: \" + str(stops1))\n # print(\"stops2: \" + str(stops2))\n # print(\"stops: \" + str(stops))\n # print(\"poss: \" + str(poss))\n # print(\"stop_percentage: \" + str(stop_percentage))\n # print(\"opp_points: \" + str(opp_points))\n # print(\"team_defensive_rating: \" + str(team_defensive_rating))\n # print(\"d_pts_per_scposs: \" + str(d_pts_per_scposs))\n # print(\"drtg: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n self.drtg = \"%.2f\" % round(result, 2)","def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\r\n return self.f1score","def fractionPassing(self):\n return self.cut.entries / self.entries","def percentage(count, total):\n return count / total * 100","def usage_percent(used, total, _round=None):\r\n try:\r\n ret = (used / total) * 100\r\n except ZeroDivisionError:\r\n ret = 0\r\n if _round is not None:\r\n return round(ret, _round)\r\n else:\r\n return ret","def dilutionneeded(self) -> float:\n return self.stock*1.0/self.final","def percentage_update(self):\n\n self.event_update()\n return self.percentage","def fitness(individual, divider, target_sum, target_multiply):\n\n sum_val = reduce(operator.add, individual[:divider], 0)\n multiply_val = reduce(operator.mul, individual[divider:], 1)\n \n sum_error = abs(target_sum - sum_val)\n sum_error = sum_error / target_sum\n\n multiply_error = abs(target_multiply - multiply_val)\n multiply_error = multiply_error / target_multiply\n\n #print(multiply_error, sum_error)\n #print(sum_error, multiply_error)\n return (multiply_error + sum_error)/2 * 100","def get_percentage(self):\n return self.PotTax_percentage","def calc_annual_electric_savings (self):\n price = self.diesel_prices\n #TODO add rural v non rural\n self.base_generation_cost = self.electric_diesel_reduction * price\n\n\n self.proposed_generation_cost = self.maintenance_cost\n\n self.annual_electric_savings = self.base_generation_cost - \\\n self.proposed_generation_cost\n #~ print 'self.annual_electric_savings',self.annual_electric_savings","def percent_busy(self):\n return self._percent_busy","def patrimony_total(self):\n pass","def __calculate_statistics(self, candidates):\n pdf = {}\n for candidate in candidates:\n neighbors = list(self.G.neighbors(candidate))\n capacity = sum([self.G.get_edge_data(candidate, n)[\"satoshis\"] for n in neighbors])\n average = capacity / len(neighbors)\n pdf[candidate] = average\n cumsum = sum(pdf.values())\n pdf = {k:v/cumsum for k,v in pdf.items()}\n w = 0.7\n print(\"percentage smoothed percentage capacity numchannels alias\")\n print(\"----------------------------------------------------------------------\")\n res_pdf = {}\n for k,v in pdf.items():\n neighbors = list(self.G.neighbors(k))\n capacity = sum([self.G.get_edge_data(k, n)[\"satoshis\"] for n in neighbors])\n name = k\n if \"alias\" in self.G.node[k]:\n name = self.G.node[k][\"alias\"]\n print(\"{:12.2f} \".format(100*v), \"{:12.2f} \".format(100*(w * v + (1-w)/len(candidates))) ,\"{:10} {:10} \".format( capacity, len(neighbors)), name)\n res_pdf[k] = (w * v + (1-w)/len(candidates))\n return res_pdf","def rate(self, neighbors, labels):\n num = 0\n den = 0\n for neighbor in neighbors:\n lable = self.labels[neighbor[1]]\n dest_to_neighbor = neighbor[0]\n num += lable / dest_to_neighbor\n den += 1 / dest_to_neighbor\n return num/den","def percentage_complete(self) -> float:\n return self.__percentage_complete","def represent_total_percent(self, length):\n numpkgs = self.totals['numpkgs']\n dlpkgs = self.totals['dlpkgs']\n return self.represent_percent(dlpkgs, numpkgs, length)","def remaining_percent(self):\n return (self.remaining_words / self.total_words) * 100","def overhead(readings):\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))","def get_estimated_percentage(self):\n now_id = now_as_id()\n message_id = self.last_message_id\n if message_id >= now_id:\n return 100.0\n \n channel_id = self.source_channel.id\n if channel_id >= message_id:\n return 0.0\n \n if self.is_polling_done():\n return 100.0\n \n return (1.0 - (now_id - message_id) / (now_id - channel_id)) * 100.0","def calc_pct_to_save_as_doublets(self):\n x, y = load_expected_doublet_rates( # pylint: disable=invalid-name\n \"/Users/austinhartman/Desktop/doublet-caller/src/expected_doublet_rates.csv\"\n )\n r = calculate_expected_doublet_rate(x, y) # pylint: disable=invalid-name\n return self.num_cells * r[\"coefficient\"] + r[\"intercept\"]","def penalty_calc(self):\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\n\n # fiber attenuation,\n self.p_atten = self.alpha*self.length # column B\n\n # calculate bandwidth for RIN test (exclude transmitter)\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\n rin_bw = 1.0 / rin_inverse_bw\n\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\n k_rin = 0.7\n\n # v_rin,\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\n math.pow(10.0,0.1*self.rin)) # column AK\n\n # Prin,\n print('v_rin: ', self.v_rin)\n print('Q: ',self.Q)\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\n print(\"P_rin : \", self.p_rin)\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\n print(\"isi_center : \", self.isi_center)\n\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\n\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\n\n\n # calculate the \"cross\" penalty contribution, column S\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\n self.p_cross_center = ( # column S\n arg3\n - self.p_blw # cell T13\n - self.p_isi_center # column J\n - self.p_isi_dj_center # column L\n - self.p_mpn # column Q\n - self.p_reflection # column N\n - self.p_rin # column R\n - self.pmn*self.l_1) # cell G13\n print('p_isi_center: ', self.p_isi_center)\n\n # calculate the total power budget evaluated at the center of the eye\n self.p_total_center = ( # column T\n self.p_isi_center # column J\n + self.p_isi_dj_center # column L\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1) # cell G13\n # calculate the total power budget evaluated at the corner of the eye\n self.p_total_corners = (\n self.p_isi_center # column J\n + self.p_isi_corners # column K\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1 # cell G13\n + self.p_isi_dj_corners)# column M\n\n # receiver stressed sensitivity\n self.margin = ( self.p_budget\n - self.p_total_center) # column W\n\n self.rx_stressed_sensitivity = (\n self.tx_oma_min*self.l_1\n - self.chil\n - self.p_mpn\n - self.p_reflection\n - self.p_rin\n - 0.5*self.p_cross_center\n - self.pmn*self.l_1\n - self.margin[self.lnum//2]*self.l_1)\n\n\n # end of GbE10.penalty_calc\n #======================================================================+","def calculate_finalscore(self):\n\n if self.count!=0:\n print(self.count)\n print(self.badGuess)\n self.finalScore=(self.total/self.count)- ((self.total/self.count)*(10*self.badGuess)/100)\n\n\n else:\n self.finalScore=self.total","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def efficiency_cal(self):\n Temp = 0\n for i in self.supplyseries:\n for j in self.demandseries:\n if(self.shortestpathij(i, j) == None):\n continue\n Temp += 1/self.shortestpathij(i, j)\n \n self.efficiency = 1/(self.supplynum*self.demandnum)*Temp","def percentageChange(self):\n try:\n curPrice = self.dailyData[-1].currentPrice\n closePrice = self.historicData[-1].closePrice\n except IndexError: # Just return zero when no historic or dailyData is available yet\n return 0.0\n return (curPrice - closePrice)/closePrice * 100","def calculate_gpa(self):\n cur_node = self.head\n gpa = 0\n total_credits = 0\n while cur_node is not None:\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\n total_credits += cur_node.data.credit_hr()\n cur_node = cur_node.next\n if total_credits == 0:\n return 0\n return gpa / total_credits","def max_total_unready_percentage(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"max_total_unready_percentage\")","def ComputeNrb(self):\r\n pass","def evaluate_percentage_of_class_for_each_flight(df_flights_info):\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\n for row, col in df_new.iterrows():\n for item in list(df_new):\n number_booking = df_new.loc[row, item]\n total_booking = df_new.loc[row]['Total']\n percentage = float(number_booking / total_booking)\n df_new.at[row, item] = percentage\n df_new = df_new.drop(columns=['Total'])\n df_new = df_new.stack()\n df_new = df_new.reset_index(level=[0, 1])\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\n return df_flights_info","def cf_mean(self):\n return self['capacity_factor'] / 100","def cf_mean(self):\n return self['capacity_factor'] / 100","def calculateDataRate(self):\n pass","def _percent(self, lines_total, lines_covered):\n\n if lines_total == 0:\n return '0.0'\n return str(float(float(lines_covered) / float(lines_total)))","def getPercent(self):\n if isinstance(self.score,numbers.Number) and self.getMaximum():\n return (1.0*self.score/self.getMaximum())\n return None","def rate(self) -> float:\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0","def percent_updated(self):\n return self.percent_complete - self.previous_percent_complete","def cost_fun(self, specs_dict: Dict[str, float]) -> float:\n cost = 0\n for spec in self.spec_range.keys():\n penalty = self.compute_penalty(specs_dict[spec], spec)[0]\n cost += penalty\n\n return cost","def _compute_register_bounds(cls, num_values, probability):\n bits = np.arange(1, num_values + 1)\n probs = scipy.stats.geom.cdf(bits, probability)\n return probs / probs[-1]","def get_percentage(self):\n return self.percentage","def get_percentage(self):\n return self.percentage","def get_free_set_percentage(self, params):\n return params.scaling_options.free_set_percentage","def ComputeRegenerativeBraking(self):\r\n pass","def total_rewards(self) -> float:\n return self.__total_rewards","def calculate(self) -> float:","def grand_total(self):\n return sum(self.grid[pos][1] for pos in assignable_positions if self.grid[pos][0]) + self.grid[\"nb\"][1]","def shield_percentage(self) -> Union[int, float]:\n if not self.proto.shield_max:\n return 0\n return self.proto.shield / self.proto.shield_max","def shield_percentage(self) -> Union[int, float]:\n if not self.proto.shield_max:\n return 0\n return self.proto.shield / self.proto.shield_max","def percent_passing(self) -> float:\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\n num_pass = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: m.passed)\n .count(lambda p: bool(p) is True)\n )\n return float(100 * num_pass / num_meas)","def percent_b(self) -> float:\n return self._percent_b","def compute_stats(self):\n if self.stats is not None:\n return\n self.stats = np.zeros(STEPS_MAX + 1)\n for m in self.missions:\n m.compute_stats()\n self.stats += 100 * m.stats\n self.stats /= len(self.missions)","def _cost_caught_by_police(self):\n if self.fine_frequency != 0:\n if self.number_of_courses % self.fine_frequency == 0 and self.number_of_courses != 0:\n if self.number_of_courses % self.fine_frequency_paid_by_driver == 0 and self.number_of_courses != 0:\n self.fine_paid_number_of_courses += 1\n fine_value = np.random.choice([100, 200, 500], p=[0.25, 0.4, 0.35])\n self.total_penalty_points += self._add_penalty_points() # adding penalty points\n return fine_value\n else:\n return 0\n else:\n return 0\n else:\n return 0","def get_duty_percentage(self):\n container_line_ids = self\n hbl_customs_obj = self.env['hbl.customs.duty']\n for line in container_line_ids:\n p_line = line.purchase_line\n #Get the supplier from product by using po supplier id.\n product_supplier_id = p_line.product_id.seller_ids.filtered(lambda rec:rec.name.id == p_line.partner_id.id and rec.hts_codes_ids)\n #Get HTS code of the supplier\n hts_codes_ids = product_supplier_id and product_supplier_id[0].hts_codes_ids or False\n if hts_codes_ids:\n percentage = sum(hts_codes_ids.mapped('percentage'))\n line_customs_id = hbl_customs_obj.create({'hbl_line_id' : line.id,\n 'hts_ids': [(6,_, hts_codes_ids.ids)],\n 'duty_percentage': percentage,\n 'quantity' : line.qty_to_load,\n 'unit_price' : p_line.price_unit\n })\n line.write({'line_customs_id' : line_customs_id.id})","def percent_processed(self):\n try:\n return (self.pos / self.data_encap.size) * 100.0\n except ZeroDivisionError:\n return 100.0","def private_pension_total(self):\n pass","def calc_stats(hits, misses):\n try:\n result = (float(misses) / float(hits)) * 100.0\n except ZeroDivisionError:\n if misses == 0:\n result = 0.0\n else:\n result = 100.0\n return result","def exceeded_ratio(self) -> float:\n return self.amount_spent / self.total_amount","def calc_annual_electric_savings (self):\n costs = self.comp_specs['diesel generator o&m']\n\n for kW in costs.keys():\n try:\n if self.average_load < int(kW):\n maintenance = self.comp_specs['diesel generator o&m'][kW]\n break\n except ValueError:\n maintenance = self.comp_specs['diesel generator o&m'][kW]\n\n self.baseline_generation_cost = maintenance + \\\n (self.pre_intertie_generation_fuel_used * self.diesel_prices)\n\n maintenance = self.capital_costs * \\\n (self.comp_specs['percent o&m'] / 100.0)\n self.proposed_generation_cost = maintenance + \\\n self.intertie_offset_generation_fuel_used * \\\n self.intertie_diesel_prices\n self.annual_electric_savings = self.baseline_generation_cost -\\\n self.proposed_generation_cost\n #~ print len(self.annual_electric_savings)\n #~ print 'self.annual_electric_savings',self.annual_electric_savings","def _compute_penalty(self):\n raise ValueError('Implement in a child class')","def PercentMaxRate(self):\n\t\treturn self._get_attribute('percentMaxRate')","def calc_excess_energy (self):\n #~ print sorted(self.cd.keys())\n self.excess_energy = \\\n (self.generation_wind_proposed - self.transmission_losses) * \\\n (self.cd['percent excess energy'] / 100.0)\n #~ print 'self.excess_energy',self.excess_energy","def _calcTotalMax(self, item, masterIntf, slaveIntf):\n if self.classmax:\n total = int((self.params[masterIntf]['intf_max']*self.params[masterIntf][slaveIntf]))\n total = int(total/self.params[masterIntf]['total_allocated'])+item['reserved']\n totalAll = item['reqRate'] + item['reserved']\n return max(total, totalAll)\n return item['reqRate'] + item['reserved']","def compute_utilization(self) -> float:\r\n return self._compute_utilization"],"string":"[\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def set_total_reb_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n player_rebounds = bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"]\\n team_rebounds = team[\\\"reb_def\\\"] + team[\\\"reb_of\\\"]\\n opp_team_rebounds = opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((player_rebounds * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team_rebounds + opp_team_rebounds)))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def pct_bust(data):\\n return round((data[\\\"new_total\\\"] > 21).sum() / len(data), 3)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def set_total_reb_of_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n result = 0.00\\n try:\\n if bx[\\\"reb_of\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"reb_of\\\"] * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team[\\\"reb_of\\\"] + opp_team[\\\"reb_def\\\"])))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n self.total_reb_of_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_free_set_percentage(self, params):\\n raise NotImplementedError()\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def percent_raised(self):\\n total_cost = self.total_cost()\\n if total_cost:\\n return round(self.total_raised() * 100 / total_cost, 2)\\n else:\\n return 0\",\n \"def __call__(self, relsSortedByScores, qrelDict):\\n result = 0.\\n postQty = len(qrelDict)\\n\\n pos = 0\\n for i, rel in enumerate(relsSortedByScores):\\n if rel > RELEVANCE_THRESHOLD:\\n pos += 1.\\n result += pos / (i + 1.)\\n\\n return result / postQty\",\n \"def compute_total_customs_duty(self):\\n for rec in self:\\n total = 0.0\\n extra_duty = 0.0\\n price_total = rec.quantity * rec.unit_price\\n# total = (price_total * duty_percentage)/100\\n rec.price_total = price_total\\n# for hts in rec.hts_ids:\\n# if hts.extra_duty_applicable:\\n# extra_duty += ((rec.quantity/hts.quantity) * hts.extra_duty)\\n# rec.total = total + extra_duty\\n\\n return True\",\n \"def calculScore(self):\\n for cell in self.notComputeRouter:\\n if(cell.isCovered==True):\\n self.score += 1000\\n self.score += self.budget\",\n \"def overall_reduction(self):\\n return 84\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def calculate_profit(self):\",\n \"def set_effective_field_goal_percentage(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tcConv = float(bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"])\\n result = 0.00\\n if tcInt > 0:\\n result = ((tcConv + (0.5 * float(bx[\\\"t3p_conv\\\"]))) / tcInt) * 100\\n self.effective_field_goal_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def _prorata_rate(self, days_used, days_in_month):\\n return (100 * days_used // days_in_month) / 100.0\",\n \"def coverage(self):\\n try:\\n return self.found * 100 / self.needed\\n except ZeroDivisionError:\\n return 100.0\",\n \"def max_occupancy_percent_for_deferred_work(self):\\n return self._max_occupancy_percent_for_deferred_work\",\n \"def _calc_freeze_probability(self, num_iterations, final_fraction):\\n return 1.0 - (final_fraction ** (1.0 / num_iterations))\",\n \"def mask_percentage(self):\\n return 100 - self.tissue_percentage\",\n \"def penalty(self):\\n return 0\",\n \"def percentage(self):\\n temp = self.cpu_freq_time_spent.copy()\\n for i in self.cpu_freq_time_spent:\\n total = 0\\n for j in self.cpu_freq_time_spent[i]:\\n total += self.cpu_freq_time_spent[i][j]\\n for j in self.cpu_freq_time_spent[i]:\\n if total != 0:\\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\\n else:\\n temp[i][j] = 0\\n return temp\",\n \"def percent_usage(value, total):\\n if total:\\n return float(value) * 100.0 / (float(total) + float(value))\\n else:\\n return 100.0\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.total_items / self.capacity\",\n \"def total_sdram_requirements(self):\",\n \"def recall(self) -> float:\\n if self.ref_ignored:\\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\\n self.num_ignored += num_ref_ignored\\n # True Positive = the number of unignored reference mappings that are Positive\\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\\n # False Negative = the number of unignored reference mappings that are Negative\\n fn = len(self.ref_set) - tp - num_ref_ignored\\n return tp / (tp + fn)\",\n \"def pct_helper(self,k,d,total):\\n if k in d:\\n return 100.0*d[k]/total\\n else:\\n return -100.0\",\n \"def rF(count, total):\\n\\treturn float(count)/float(total)\",\n \"def calculate_percent(self, total_number, some_number):\\n\\t\\treturn (some_number * 100) / total_number\",\n \"def update_percent(self):\",\n \"def compute_sufficient_stats(self):\\n self.counts = (np.sum(self.resp, axis=0) + 10e-30)\\n # print(self.counts)\\n for k in range(self.k):\\n self.means[k] = np.sum(self.resp[n, k] * self.x[n] for n in range(self.n)) / self.counts[k]\\n self.covars[k] = np.sum(self.resp[n, k] * (self.x[n] - self.means[k]) @ (self.x[n] - self.means[k]).T\\n for n in range(self.n)) / self.counts[k]\\n self.covars[k] = np.nan_to_num(self.covars[k])\\n self.means[k] = np.nan_to_num(self.means[k])\",\n \"def life_insurance_to_recive_total(self):\\n pass\",\n \"def revenue_landfill(self) -> float:\\n return self.income_statement.revenue.operating_revenue * (\\n 1 - self.inputs.allocation_to_collection_unit\\n )\",\n \"def cost(self) -> float:\",\n \"def get_expected_cost(self):\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def _calculate_result(found, total):\\n return (found * 100) / total\",\n \"def set_defensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0:\\n opp_fga = opp_team[\\\"t2p_int\\\"] + opp_team[\\\"t3p_int\\\"]\\n opp_fgm = opp_team[\\\"t2p_conv\\\"] + opp_team[\\\"t3p_conv\\\"]\\n try:\\n dor = Decimal(opp_team[\\\"reb_of\\\"] / (opp_team[\\\"reb_of\\\"] + team[\\\"reb_def\\\"]))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n dor = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n dor = 0\\n\\n try:\\n dfg = Decimal(opp_fgm / opp_fga)\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n dfg = 0\\n try:\\n fmwt = Decimal((dfg * (1 - dor)) / (dfg * (1 - dor) + (1 - dfg) * dor))\\n except:\\n fmwt = 0\\n stops1 = bx[\\\"steals\\\"] + bx[\\\"block_shots\\\"] * fmwt * (1 - Decimal('1.07') * dor) + bx[\\\"reb_def\\\"] * (1 - fmwt)\\n\\n try:\\n stops2 = (Decimal((opp_fga - opp_fgm - team[\\\"block_shots\\\"]) / team[\\\"minutes\\\"]) * fmwt * (1 - Decimal('1.07') * dor) + Decimal((opp_team[\\\"turnovers\\\"] - team[\\\"steals\\\"]) / team[\\\"minutes\\\"])) * bx[\\\"minutes\\\"] + Decimal(bx[\\\"fouls_cm\\\"] / team[\\\"fouls_cm\\\"]) * Decimal('0.4') * opp_team[\\\"tl_int\\\"] * (1 - Decimal(opp_team[\\\"tl_conv\\\"] / opp_team[\\\"tl_int\\\"]))**2\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n stops2 = 0\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n stops2 = 0\\n\\n stops = stops1 + stops2\\n poss = self.get_team_possessions()\\n if bx[\\\"minutes\\\"] > 0:\\n stop_percentage = (float(stops) * float(opp_team[\\\"minutes\\\"])) / (float(poss) * float(bx[\\\"minutes\\\"]))\\n else:\\n stop_percentage = 0.00\\n opp_points = opp_team[\\\"t2p_conv\\\"] * 2 + opp_team[\\\"t3p_conv\\\"] * 3 + opp_team[\\\"tl_conv\\\"]\\n team_defensive_rating = 100 * (float(opp_points) / poss)\\n try:\\n d_pts_per_scposs = float(opp_points) / (float(opp_fgm) + (1 - (1 - (float(opp_team[\\\"tl_conv\\\"]) / float(opp_team[\\\"tl_int\\\"])))**2) * float(opp_team[\\\"tl_int\\\"])*0.4)\\n result = Decimal(team_defensive_rating) + Decimal('0.2') * (100 * Decimal(d_pts_per_scposs) * (1 - Decimal(stop_percentage)) - Decimal(team_defensive_rating))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n d_pts_per_scposs = 0\\n result = 0.00\\n\\n\\n\\n # print(\\\"dor: \\\" + str(dor))\\n # print(\\\"dfg: \\\" + str(dfg))\\n # print(\\\"fmwt: \\\" + str(fmwt))\\n # print(\\\"stops1: \\\" + str(stops1))\\n # print(\\\"stops2: \\\" + str(stops2))\\n # print(\\\"stops: \\\" + str(stops))\\n # print(\\\"poss: \\\" + str(poss))\\n # print(\\\"stop_percentage: \\\" + str(stop_percentage))\\n # print(\\\"opp_points: \\\" + str(opp_points))\\n # print(\\\"team_defensive_rating: \\\" + str(team_defensive_rating))\\n # print(\\\"d_pts_per_scposs: \\\" + str(d_pts_per_scposs))\\n # print(\\\"drtg: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n self.drtg = \\\"%.2f\\\" % round(result, 2)\",\n \"def computeFScores(self, targetLabels, actualLabels):\\r\\n if self.prMeasures is None:\\r\\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\\r\\n if self.prMeasures[0] == 0:\\r\\n return 0\\r\\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\\r\\n return self.f1score\",\n \"def fractionPassing(self):\\n return self.cut.entries / self.entries\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def usage_percent(used, total, _round=None):\\r\\n try:\\r\\n ret = (used / total) * 100\\r\\n except ZeroDivisionError:\\r\\n ret = 0\\r\\n if _round is not None:\\r\\n return round(ret, _round)\\r\\n else:\\r\\n return ret\",\n \"def dilutionneeded(self) -> float:\\n return self.stock*1.0/self.final\",\n \"def percentage_update(self):\\n\\n self.event_update()\\n return self.percentage\",\n \"def fitness(individual, divider, target_sum, target_multiply):\\n\\n sum_val = reduce(operator.add, individual[:divider], 0)\\n multiply_val = reduce(operator.mul, individual[divider:], 1)\\n \\n sum_error = abs(target_sum - sum_val)\\n sum_error = sum_error / target_sum\\n\\n multiply_error = abs(target_multiply - multiply_val)\\n multiply_error = multiply_error / target_multiply\\n\\n #print(multiply_error, sum_error)\\n #print(sum_error, multiply_error)\\n return (multiply_error + sum_error)/2 * 100\",\n \"def get_percentage(self):\\n return self.PotTax_percentage\",\n \"def calc_annual_electric_savings (self):\\n price = self.diesel_prices\\n #TODO add rural v non rural\\n self.base_generation_cost = self.electric_diesel_reduction * price\\n\\n\\n self.proposed_generation_cost = self.maintenance_cost\\n\\n self.annual_electric_savings = self.base_generation_cost - \\\\\\n self.proposed_generation_cost\\n #~ print 'self.annual_electric_savings',self.annual_electric_savings\",\n \"def percent_busy(self):\\n return self._percent_busy\",\n \"def patrimony_total(self):\\n pass\",\n \"def __calculate_statistics(self, candidates):\\n pdf = {}\\n for candidate in candidates:\\n neighbors = list(self.G.neighbors(candidate))\\n capacity = sum([self.G.get_edge_data(candidate, n)[\\\"satoshis\\\"] for n in neighbors])\\n average = capacity / len(neighbors)\\n pdf[candidate] = average\\n cumsum = sum(pdf.values())\\n pdf = {k:v/cumsum for k,v in pdf.items()}\\n w = 0.7\\n print(\\\"percentage smoothed percentage capacity numchannels alias\\\")\\n print(\\\"----------------------------------------------------------------------\\\")\\n res_pdf = {}\\n for k,v in pdf.items():\\n neighbors = list(self.G.neighbors(k))\\n capacity = sum([self.G.get_edge_data(k, n)[\\\"satoshis\\\"] for n in neighbors])\\n name = k\\n if \\\"alias\\\" in self.G.node[k]:\\n name = self.G.node[k][\\\"alias\\\"]\\n print(\\\"{:12.2f} \\\".format(100*v), \\\"{:12.2f} \\\".format(100*(w * v + (1-w)/len(candidates))) ,\\\"{:10} {:10} \\\".format( capacity, len(neighbors)), name)\\n res_pdf[k] = (w * v + (1-w)/len(candidates))\\n return res_pdf\",\n \"def rate(self, neighbors, labels):\\n num = 0\\n den = 0\\n for neighbor in neighbors:\\n lable = self.labels[neighbor[1]]\\n dest_to_neighbor = neighbor[0]\\n num += lable / dest_to_neighbor\\n den += 1 / dest_to_neighbor\\n return num/den\",\n \"def percentage_complete(self) -> float:\\n return self.__percentage_complete\",\n \"def represent_total_percent(self, length):\\n numpkgs = self.totals['numpkgs']\\n dlpkgs = self.totals['dlpkgs']\\n return self.represent_percent(dlpkgs, numpkgs, length)\",\n \"def remaining_percent(self):\\n return (self.remaining_words / self.total_words) * 100\",\n \"def overhead(readings):\\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))\",\n \"def get_estimated_percentage(self):\\n now_id = now_as_id()\\n message_id = self.last_message_id\\n if message_id >= now_id:\\n return 100.0\\n \\n channel_id = self.source_channel.id\\n if channel_id >= message_id:\\n return 0.0\\n \\n if self.is_polling_done():\\n return 100.0\\n \\n return (1.0 - (now_id - message_id) / (now_id - channel_id)) * 100.0\",\n \"def calc_pct_to_save_as_doublets(self):\\n x, y = load_expected_doublet_rates( # pylint: disable=invalid-name\\n \\\"/Users/austinhartman/Desktop/doublet-caller/src/expected_doublet_rates.csv\\\"\\n )\\n r = calculate_expected_doublet_rate(x, y) # pylint: disable=invalid-name\\n return self.num_cells * r[\\\"coefficient\\\"] + r[\\\"intercept\\\"]\",\n \"def penalty_calc(self):\\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\\n\\n # fiber attenuation,\\n self.p_atten = self.alpha*self.length # column B\\n\\n # calculate bandwidth for RIN test (exclude transmitter)\\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\\n rin_bw = 1.0 / rin_inverse_bw\\n\\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\\n k_rin = 0.7\\n\\n # v_rin,\\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\\n math.pow(10.0,0.1*self.rin)) # column AK\\n\\n # Prin,\\n print('v_rin: ', self.v_rin)\\n print('Q: ',self.Q)\\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\\n print(\\\"P_rin : \\\", self.p_rin)\\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\\n print(\\\"isi_center : \\\", self.isi_center)\\n\\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\\n\\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\\n\\n\\n # calculate the \\\"cross\\\" penalty contribution, column S\\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\\n self.p_cross_center = ( # column S\\n arg3\\n - self.p_blw # cell T13\\n - self.p_isi_center # column J\\n - self.p_isi_dj_center # column L\\n - self.p_mpn # column Q\\n - self.p_reflection # column N\\n - self.p_rin # column R\\n - self.pmn*self.l_1) # cell G13\\n print('p_isi_center: ', self.p_isi_center)\\n\\n # calculate the total power budget evaluated at the center of the eye\\n self.p_total_center = ( # column T\\n self.p_isi_center # column J\\n + self.p_isi_dj_center # column L\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1) # cell G13\\n # calculate the total power budget evaluated at the corner of the eye\\n self.p_total_corners = (\\n self.p_isi_center # column J\\n + self.p_isi_corners # column K\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1 # cell G13\\n + self.p_isi_dj_corners)# column M\\n\\n # receiver stressed sensitivity\\n self.margin = ( self.p_budget\\n - self.p_total_center) # column W\\n\\n self.rx_stressed_sensitivity = (\\n self.tx_oma_min*self.l_1\\n - self.chil\\n - self.p_mpn\\n - self.p_reflection\\n - self.p_rin\\n - 0.5*self.p_cross_center\\n - self.pmn*self.l_1\\n - self.margin[self.lnum//2]*self.l_1)\\n\\n\\n # end of GbE10.penalty_calc\\n #======================================================================+\",\n \"def calculate_finalscore(self):\\n\\n if self.count!=0:\\n print(self.count)\\n print(self.badGuess)\\n self.finalScore=(self.total/self.count)- ((self.total/self.count)*(10*self.badGuess)/100)\\n\\n\\n else:\\n self.finalScore=self.total\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def efficiency_cal(self):\\n Temp = 0\\n for i in self.supplyseries:\\n for j in self.demandseries:\\n if(self.shortestpathij(i, j) == None):\\n continue\\n Temp += 1/self.shortestpathij(i, j)\\n \\n self.efficiency = 1/(self.supplynum*self.demandnum)*Temp\",\n \"def percentageChange(self):\\n try:\\n curPrice = self.dailyData[-1].currentPrice\\n closePrice = self.historicData[-1].closePrice\\n except IndexError: # Just return zero when no historic or dailyData is available yet\\n return 0.0\\n return (curPrice - closePrice)/closePrice * 100\",\n \"def calculate_gpa(self):\\n cur_node = self.head\\n gpa = 0\\n total_credits = 0\\n while cur_node is not None:\\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\\n total_credits += cur_node.data.credit_hr()\\n cur_node = cur_node.next\\n if total_credits == 0:\\n return 0\\n return gpa / total_credits\",\n \"def max_total_unready_percentage(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"max_total_unready_percentage\\\")\",\n \"def ComputeNrb(self):\\r\\n pass\",\n \"def evaluate_percentage_of_class_for_each_flight(df_flights_info):\\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\\n for row, col in df_new.iterrows():\\n for item in list(df_new):\\n number_booking = df_new.loc[row, item]\\n total_booking = df_new.loc[row]['Total']\\n percentage = float(number_booking / total_booking)\\n df_new.at[row, item] = percentage\\n df_new = df_new.drop(columns=['Total'])\\n df_new = df_new.stack()\\n df_new = df_new.reset_index(level=[0, 1])\\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\\n return df_flights_info\",\n \"def cf_mean(self):\\n return self['capacity_factor'] / 100\",\n \"def cf_mean(self):\\n return self['capacity_factor'] / 100\",\n \"def calculateDataRate(self):\\n pass\",\n \"def _percent(self, lines_total, lines_covered):\\n\\n if lines_total == 0:\\n return '0.0'\\n return str(float(float(lines_covered) / float(lines_total)))\",\n \"def getPercent(self):\\n if isinstance(self.score,numbers.Number) and self.getMaximum():\\n return (1.0*self.score/self.getMaximum())\\n return None\",\n \"def rate(self) -> float:\\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0\",\n \"def percent_updated(self):\\n return self.percent_complete - self.previous_percent_complete\",\n \"def cost_fun(self, specs_dict: Dict[str, float]) -> float:\\n cost = 0\\n for spec in self.spec_range.keys():\\n penalty = self.compute_penalty(specs_dict[spec], spec)[0]\\n cost += penalty\\n\\n return cost\",\n \"def _compute_register_bounds(cls, num_values, probability):\\n bits = np.arange(1, num_values + 1)\\n probs = scipy.stats.geom.cdf(bits, probability)\\n return probs / probs[-1]\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_free_set_percentage(self, params):\\n return params.scaling_options.free_set_percentage\",\n \"def ComputeRegenerativeBraking(self):\\r\\n pass\",\n \"def total_rewards(self) -> float:\\n return self.__total_rewards\",\n \"def calculate(self) -> float:\",\n \"def grand_total(self):\\n return sum(self.grid[pos][1] for pos in assignable_positions if self.grid[pos][0]) + self.grid[\\\"nb\\\"][1]\",\n \"def shield_percentage(self) -> Union[int, float]:\\n if not self.proto.shield_max:\\n return 0\\n return self.proto.shield / self.proto.shield_max\",\n \"def shield_percentage(self) -> Union[int, float]:\\n if not self.proto.shield_max:\\n return 0\\n return self.proto.shield / self.proto.shield_max\",\n \"def percent_passing(self) -> float:\\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\\n num_pass = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: m.passed)\\n .count(lambda p: bool(p) is True)\\n )\\n return float(100 * num_pass / num_meas)\",\n \"def percent_b(self) -> float:\\n return self._percent_b\",\n \"def compute_stats(self):\\n if self.stats is not None:\\n return\\n self.stats = np.zeros(STEPS_MAX + 1)\\n for m in self.missions:\\n m.compute_stats()\\n self.stats += 100 * m.stats\\n self.stats /= len(self.missions)\",\n \"def _cost_caught_by_police(self):\\n if self.fine_frequency != 0:\\n if self.number_of_courses % self.fine_frequency == 0 and self.number_of_courses != 0:\\n if self.number_of_courses % self.fine_frequency_paid_by_driver == 0 and self.number_of_courses != 0:\\n self.fine_paid_number_of_courses += 1\\n fine_value = np.random.choice([100, 200, 500], p=[0.25, 0.4, 0.35])\\n self.total_penalty_points += self._add_penalty_points() # adding penalty points\\n return fine_value\\n else:\\n return 0\\n else:\\n return 0\\n else:\\n return 0\",\n \"def get_duty_percentage(self):\\n container_line_ids = self\\n hbl_customs_obj = self.env['hbl.customs.duty']\\n for line in container_line_ids:\\n p_line = line.purchase_line\\n #Get the supplier from product by using po supplier id.\\n product_supplier_id = p_line.product_id.seller_ids.filtered(lambda rec:rec.name.id == p_line.partner_id.id and rec.hts_codes_ids)\\n #Get HTS code of the supplier\\n hts_codes_ids = product_supplier_id and product_supplier_id[0].hts_codes_ids or False\\n if hts_codes_ids:\\n percentage = sum(hts_codes_ids.mapped('percentage'))\\n line_customs_id = hbl_customs_obj.create({'hbl_line_id' : line.id,\\n 'hts_ids': [(6,_, hts_codes_ids.ids)],\\n 'duty_percentage': percentage,\\n 'quantity' : line.qty_to_load,\\n 'unit_price' : p_line.price_unit\\n })\\n line.write({'line_customs_id' : line_customs_id.id})\",\n \"def percent_processed(self):\\n try:\\n return (self.pos / self.data_encap.size) * 100.0\\n except ZeroDivisionError:\\n return 100.0\",\n \"def private_pension_total(self):\\n pass\",\n \"def calc_stats(hits, misses):\\n try:\\n result = (float(misses) / float(hits)) * 100.0\\n except ZeroDivisionError:\\n if misses == 0:\\n result = 0.0\\n else:\\n result = 100.0\\n return result\",\n \"def exceeded_ratio(self) -> float:\\n return self.amount_spent / self.total_amount\",\n \"def calc_annual_electric_savings (self):\\n costs = self.comp_specs['diesel generator o&m']\\n\\n for kW in costs.keys():\\n try:\\n if self.average_load < int(kW):\\n maintenance = self.comp_specs['diesel generator o&m'][kW]\\n break\\n except ValueError:\\n maintenance = self.comp_specs['diesel generator o&m'][kW]\\n\\n self.baseline_generation_cost = maintenance + \\\\\\n (self.pre_intertie_generation_fuel_used * self.diesel_prices)\\n\\n maintenance = self.capital_costs * \\\\\\n (self.comp_specs['percent o&m'] / 100.0)\\n self.proposed_generation_cost = maintenance + \\\\\\n self.intertie_offset_generation_fuel_used * \\\\\\n self.intertie_diesel_prices\\n self.annual_electric_savings = self.baseline_generation_cost -\\\\\\n self.proposed_generation_cost\\n #~ print len(self.annual_electric_savings)\\n #~ print 'self.annual_electric_savings',self.annual_electric_savings\",\n \"def _compute_penalty(self):\\n raise ValueError('Implement in a child class')\",\n \"def PercentMaxRate(self):\\n\\t\\treturn self._get_attribute('percentMaxRate')\",\n \"def calc_excess_energy (self):\\n #~ print sorted(self.cd.keys())\\n self.excess_energy = \\\\\\n (self.generation_wind_proposed - self.transmission_losses) * \\\\\\n (self.cd['percent excess energy'] / 100.0)\\n #~ print 'self.excess_energy',self.excess_energy\",\n \"def _calcTotalMax(self, item, masterIntf, slaveIntf):\\n if self.classmax:\\n total = int((self.params[masterIntf]['intf_max']*self.params[masterIntf][slaveIntf]))\\n total = int(total/self.params[masterIntf]['total_allocated'])+item['reserved']\\n totalAll = item['reqRate'] + item['reserved']\\n return max(total, totalAll)\\n return item['reqRate'] + item['reserved']\",\n \"def compute_utilization(self) -> float:\\r\\n return self._compute_utilization\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6720814","0.65615296","0.64223516","0.63799196","0.63289535","0.63207704","0.63154423","0.62732965","0.6261528","0.6167289","0.6124796","0.61081874","0.6068133","0.60473025","0.5999613","0.5988745","0.59840715","0.5983306","0.5973883","0.59696484","0.59576386","0.59197676","0.59165156","0.587996","0.5865504","0.5859559","0.585895","0.5858603","0.5855112","0.5829298","0.58145696","0.57965887","0.5792907","0.57922316","0.57863903","0.5776798","0.5776798","0.5770127","0.5761446","0.57581216","0.5758022","0.57552683","0.5754498","0.5751767","0.57515454","0.57418174","0.5736591","0.5729933","0.5724472","0.5712921","0.56928974","0.5692151","0.56806296","0.5677196","0.56634945","0.56594735","0.5657584","0.5648082","0.5647366","0.5637153","0.5632266","0.5629826","0.5628365","0.56143117","0.5604036","0.56016886","0.55992","0.5595613","0.5595613","0.5594552","0.55928564","0.55927795","0.5592624","0.55915564","0.5590641","0.55886316","0.55875444","0.55875444","0.5581265","0.5565706","0.55654895","0.5562704","0.5560306","0.55576754","0.55576754","0.55507755","0.5550245","0.55489564","0.55254537","0.55235225","0.55218625","0.55194646","0.55153394","0.55142355","0.55073756","0.55067825","0.5504176","0.5494338","0.54923844","0.54922533"],"string":"[\n \"0.6720814\",\n \"0.65615296\",\n \"0.64223516\",\n \"0.63799196\",\n \"0.63289535\",\n \"0.63207704\",\n \"0.63154423\",\n \"0.62732965\",\n \"0.6261528\",\n \"0.6167289\",\n \"0.6124796\",\n \"0.61081874\",\n \"0.6068133\",\n \"0.60473025\",\n \"0.5999613\",\n \"0.5988745\",\n \"0.59840715\",\n \"0.5983306\",\n \"0.5973883\",\n \"0.59696484\",\n \"0.59576386\",\n \"0.59197676\",\n \"0.59165156\",\n \"0.587996\",\n \"0.5865504\",\n \"0.5859559\",\n \"0.585895\",\n \"0.5858603\",\n \"0.5855112\",\n \"0.5829298\",\n \"0.58145696\",\n \"0.57965887\",\n \"0.5792907\",\n \"0.57922316\",\n \"0.57863903\",\n \"0.5776798\",\n \"0.5776798\",\n \"0.5770127\",\n \"0.5761446\",\n \"0.57581216\",\n \"0.5758022\",\n \"0.57552683\",\n \"0.5754498\",\n \"0.5751767\",\n \"0.57515454\",\n \"0.57418174\",\n \"0.5736591\",\n \"0.5729933\",\n \"0.5724472\",\n \"0.5712921\",\n \"0.56928974\",\n \"0.5692151\",\n \"0.56806296\",\n \"0.5677196\",\n \"0.56634945\",\n \"0.56594735\",\n \"0.5657584\",\n \"0.5648082\",\n \"0.5647366\",\n \"0.5637153\",\n \"0.5632266\",\n \"0.5629826\",\n \"0.5628365\",\n \"0.56143117\",\n \"0.5604036\",\n \"0.56016886\",\n \"0.55992\",\n \"0.5595613\",\n \"0.5595613\",\n \"0.5594552\",\n \"0.55928564\",\n \"0.55927795\",\n \"0.5592624\",\n \"0.55915564\",\n \"0.5590641\",\n \"0.55886316\",\n \"0.55875444\",\n \"0.55875444\",\n \"0.5581265\",\n \"0.5565706\",\n \"0.55654895\",\n \"0.5562704\",\n \"0.5560306\",\n \"0.55576754\",\n \"0.55576754\",\n \"0.55507755\",\n \"0.5550245\",\n \"0.55489564\",\n \"0.55254537\",\n \"0.55235225\",\n \"0.55218625\",\n \"0.55194646\",\n \"0.55153394\",\n \"0.55142355\",\n \"0.55073756\",\n \"0.55067825\",\n \"0.5504176\",\n \"0.5494338\",\n \"0.54923844\",\n \"0.54922533\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6653622"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3093,"cells":{"query":{"kind":"string","value":"Method which calculate Total Rebound Ofensive Percentage"},"document":{"kind":"string","value":"def set_total_reb_of_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"reb_of\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_of\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_of\"] + opp_team[\"reb_def\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n self.total_reb_of_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def pct(self):\n\t\treturn self.bottle.pct()","def set_total_reb_def_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_def\"] * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team[\"reb_def\"] + opp_team[\"reb_of\"])))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_def_percentage = \"%.2f\" % round(result, 2)","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def pct_bust(data):\n return round((data[\"new_total\"] > 21).sum() / len(data), 3)","def percent_raised(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.total_raised() * 100 / total_cost, 2)\n else:\n return 0","def __call__(self, relsSortedByScores, qrelDict):\n result = 0.\n postQty = len(qrelDict)\n\n pos = 0\n for i, rel in enumerate(relsSortedByScores):\n if rel > RELEVANCE_THRESHOLD:\n pos += 1.\n result += pos / (i + 1.)\n\n return result / postQty","def calculate_profit(self):","def get_free_set_percentage(self, params):\n raise NotImplementedError()","def calculScore(self):\n for cell in self.notComputeRouter:\n if(cell.isCovered==True):\n self.score += 1000\n self.score += self.budget","def overall_reduction(self):\n return 84","def _prorata_rate(self, days_used, days_in_month):\n return (100 * days_used // days_in_month) / 100.0","def getClassBalance(pshapes, bounds, proj):\n\n xmin, ymin, xmax, ymax = bounds\n bpoly = Polygon([(xmin, ymax),\n (xmax, ymax),\n (xmax, ymin),\n (xmin, ymin)])\n project = partial(\n pyproj.transform,\n pyproj.Proj(proj='latlong', datum='WGS84'),\n proj)\n bpolyproj = transform(project, bpoly)\n totalarea = bpolyproj.area\n polyarea = 0\n for pshape in pshapes:\n polyarea += pshape.area\n\n return polyarea/totalarea","def get_load_factor(self):\n # Your code here\n return self.total_items / self.capacity","def CalculateBoundProbability(self, psi):\n\n\t\t_, _, _, boundTotal = self.CalculateBoundDistribution(psi)\n\n\t\treturn boundTotal","def represent_total_percent(self, length):\n numpkgs = self.totals['numpkgs']\n dlpkgs = self.totals['dlpkgs']\n return self.represent_percent(dlpkgs, numpkgs, length)","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def calculate_percent(self, total_number, some_number):\n\t\treturn (some_number * 100) / total_number","def coverage(self):\n try:\n return self.found * 100 / self.needed\n except ZeroDivisionError:\n return 100.0","def ComputeNrb(self):\r\n pass","def fractionPassing(self):\n return self.cut.entries / self.entries","def percentage(count, total):\n return count / total * 100","def _calculate_result(found, total):\n return (found * 100) / total","def rF(count, total):\n\treturn float(count)/float(total)","def exceeded_ratio(self) -> float:\n return self.amount_spent / self.total_amount","def percent_usage(value, total):\n if total:\n return float(value) * 100.0 / (float(total) + float(value))\n else:\n return 100.0","def grand_total(self):\n return sum(self.grid[pos][1] for pos in assignable_positions if self.grid[pos][0]) + self.grid[\"nb\"][1]","def fitness(individual, divider, target_sum, target_multiply):\n\n sum_val = reduce(operator.add, individual[:divider], 0)\n multiply_val = reduce(operator.mul, individual[divider:], 1)\n \n sum_error = abs(target_sum - sum_val)\n sum_error = sum_error / target_sum\n\n multiply_error = abs(target_multiply - multiply_val)\n multiply_error = multiply_error / target_multiply\n\n #print(multiply_error, sum_error)\n #print(sum_error, multiply_error)\n return (multiply_error + sum_error)/2 * 100","def compute_total_customs_duty(self):\n for rec in self:\n total = 0.0\n extra_duty = 0.0\n price_total = rec.quantity * rec.unit_price\n# total = (price_total * duty_percentage)/100\n rec.price_total = price_total\n# for hts in rec.hts_ids:\n# if hts.extra_duty_applicable:\n# extra_duty += ((rec.quantity/hts.quantity) * hts.extra_duty)\n# rec.total = total + extra_duty\n\n return True","def calculate_gpa(self):\n cur_node = self.head\n gpa = 0\n total_credits = 0\n while cur_node is not None:\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\n total_credits += cur_node.data.credit_hr()\n cur_node = cur_node.next\n if total_credits == 0:\n return 0\n return gpa / total_credits","def upper_bound(self) -> float:\n ...","def getPercent(*args):","def getPercent(*args):","def penalty(self):\n return 0","def patrimony_total(self):\n pass","def life_insurance_to_recive_total(self):\n pass","def total_rewards(self) -> float:\n return self.__total_rewards","def mb_r(self) -> float:\n # Calculate metric\n n = self.predicted.size\n tot = 0.0\n for i in range(n):\n tot = tot + np.sum(np.abs(self.predicted - self.true[i]))\n mae_val = np.sum(np.abs(self.predicted - self.true)) / n\n mb = 1 - ((n ** 2) * mae_val / tot)\n\n return float(mb)","def get_percentage(self):\n return self.PotTax_percentage","def cal_hit_gbratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\n score = 0.0\n # golden items hit in the top_K items\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\n\n #print(np.mean(score_ratio))\n #print(score_1)\n #score = score_1 + score_2\n return np.mean(score_ratio)","def update_percent(self):","def percent_b(self) -> float:\n return self._percent_b","def private_pension_total(self):\n pass","def percentage_update(self):\n\n self.event_update()\n return self.percentage","def cost(self) -> float:","def calc_pct_to_save_as_doublets(self):\n x, y = load_expected_doublet_rates( # pylint: disable=invalid-name\n \"/Users/austinhartman/Desktop/doublet-caller/src/expected_doublet_rates.csv\"\n )\n r = calculate_expected_doublet_rate(x, y) # pylint: disable=invalid-name\n return self.num_cells * r[\"coefficient\"] + r[\"intercept\"]","def overhead(readings):\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))","def usage_percent(used, total, _round=None):\r\n try:\r\n ret = (used / total) * 100\r\n except ZeroDivisionError:\r\n ret = 0\r\n if _round is not None:\r\n return round(ret, _round)\r\n else:\r\n return ret","def budget_used(self):\n return int(self.total_spent() / self.budget() * 100.0)","def percentage(self):\n temp = self.cpu_freq_time_spent.copy()\n for i in self.cpu_freq_time_spent:\n total = 0\n for j in self.cpu_freq_time_spent[i]:\n total += self.cpu_freq_time_spent[i][j]\n for j in self.cpu_freq_time_spent[i]:\n if total != 0:\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\n else:\n temp[i][j] = 0\n return temp","def robbins(counts):\n return float(singles(counts))/counts.sum()","def calculate(self) -> float:","def calculate_risk_tol(*args):\n global total_score\n risk_tol_start = 0.0\n\n for risk_per_pg in risk_tol_per_qs.iterkeys():\n try:\n risk_tol_start = risk_tol_start + risk_tol_per_qs[risk_per_pg][-1] # this is the last item in the list of each information in the page\n except IndexError:\n pass\n total_score = risk_tol_start","def get_expected_cost(self):","def total(self) -> float:\n\n remained_to_be_taxed = self.income\n # taxed = list()\n self.tax_amounts = []\n start_tax_range = 0\n end_tax_range = self.bracket\n\n for i, b in enumerate(self.bracket):\n\n amount_to_tax = b.end - start_tax_range\n t = Taxed(min(amount_to_tax, remained_to_be_taxed), b.rate,\n min(amount_to_tax, remained_to_be_taxed) * b.rate)\n self.tax_amounts.append(t)\n # print(i, start_t ax_range, b.end, amount_to_tax, b.rate)\n\n remained_to_be_taxed -= amount_to_tax\n # print(remained_to_be_taxed)\n\n if b.end > self.income:\n break\n\n start_tax_range = b.end\n\n # print(taxed)\n return sum([t.tax for t in self.tax_amounts])","def revenue_landfill(self) -> float:\n return self.income_statement.revenue.operating_revenue * (\n 1 - self.inputs.allocation_to_collection_unit\n )","def return_on_total_assets():\r\n x = float(input(\"Please Enter Net Income Value: \"))\r\n y = float(input(\"Please Enter Interest Expense Value: \"))\r\n z = float(input(\"Please Enter Beginning Total Assets Value: \"))\r\n w = float(input(\"Please Enter Ending Total Assets Value: \"))\r\n d = ((float(x)+float(y)) / ((float(z)+float(w)) / float(2))) * float(100)\r\n print \">> Your Rate of Return on Total Assets is\",round(d,1),\"%\"","def compute_bound(self, sstats, totals):\n w = self.vocab_len\n t = self.num_time_slices\n\n term_1 = 0\n term_2 = 0\n term_3 = 0\n\n val = 0\n ent = 0\n\n chain_variance = self.chain_variance\n # computing mean, fwd_mean\n self.mean, self.fwd_mean = \\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\n self.zeta = self.update_zeta()\n\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\n\n logger.info(\"Computing bound, all times\")\n\n for t in range(1, t + 1):\n term_1 = 0.0\n term_2 = 0.0\n ent = 0.0\n for w in range(w):\n\n m = self.mean[w][t]\n prev_m = self.mean[w][t - 1]\n\n v = self.variance[w][t]\n\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\n # w_phi_l = sslm.w_phi_l[w][t - 1]\n # exp_i = np.exp(-prev_m)\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\n # (v / chain_variance) - np.log(chain_variance)\n\n term_1 += \\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\n term_2 += sstats[w][t - 1] * m\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\n\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\n val += term_2 + term_3 + ent - term_1\n\n return val","def total_sdram_requirements(self):","def rate(self, neighbors, labels):\n num = 0\n den = 0\n for neighbor in neighbors:\n lable = self.labels[neighbor[1]]\n dest_to_neighbor = neighbor[0]\n num += lable / dest_to_neighbor\n den += 1 / dest_to_neighbor\n return num/den","def total_area(self):\n return numpy.prod([r[1] - r[0] for r in self.range_])","def get_tot_occ_rate(self):\n return 10 ** (self.a_value - self.b_value * self.min_mag) - \\\n 10 ** (self.a_value - self.b_value * self.max_mag)","def pct_helper(self,k,d,total):\n if k in d:\n return 100.0*d[k]/total\n else:\n return -100.0","def proper_annulus_centres(self) -> Quantity:\n return self._proper_ann_centres","def current_nbc_coverage():\n covered = 0\n total = 0\n for layer in layer_to_compute:\n covered = covered + np.count_nonzero(nbc_cov_dict[layer.name])\n total = total + np.size(nbc_cov_dict[layer.name])\n return covered / float(total)","def _calcTotalMax(self, item, masterIntf, slaveIntf):\n if self.classmax:\n total = int((self.params[masterIntf]['intf_max']*self.params[masterIntf][slaveIntf]))\n total = int(total/self.params[masterIntf]['total_allocated'])+item['reserved']\n totalAll = item['reqRate'] + item['reserved']\n return max(total, totalAll)\n return item['reqRate'] + item['reserved']","def ram_percent(self):\n self.monitoring_object['ram_percent'] = \\\n psutil.virtual_memory().used","def percent_updated(self):\n return self.percent_complete - self.previous_percent_complete","def findBoundResonances(resonance):\n\n from ccpnmr.analysis.core.AssignmentBasic import getBoundResonances\n \n return getBoundResonances(resonance)","def cf_mean(self):\n return self['capacity_factor'] / 100","def cf_mean(self):\n return self['capacity_factor'] / 100","def per_hour(self):\n if self.is_salary():\n return 0.0\n return self.wage_cents / 100.0","def calculate_finalscore(self):\n\n if self.count!=0:\n print(self.count)\n print(self.badGuess)\n self.finalScore=(self.total/self.count)- ((self.total/self.count)*(10*self.badGuess)/100)\n\n\n else:\n self.finalScore=self.total","def get_total_risk_level(self) -> int:\n origin = Point(0, 0)\n bounded_points = self.grid.get_bounded_points(origin, self.target)\n return sum(self.get_region(point) for point, _ in bounded_points)","def g_score(self):\n _, _, I_CK = self._entropies()\n return 2.0 * I_CK","def get_percentage(self):\n return self.percentage","def get_percentage(self):\n return self.percentage","def compute_quotation_price(self):\n result = decimal.Decimal('0')\n if self.vehiculePrice:\n result = self.vehiculePrice * 2 / 100\n if self.covWind:\n result += get_coverage_price_by_name(\"WIND\")\n if self.covPass:\n result += get_coverage_price_by_name(\"PASS\")\n if self.covFlood:\n result += get_coverage_price_by_name(\"FLOOD\")\n return result","def percent_busy(self):\n return self._percent_busy","def compute_sufficient_stats(self):\n self.counts = (np.sum(self.resp, axis=0) + 10e-30)\n # print(self.counts)\n for k in range(self.k):\n self.means[k] = np.sum(self.resp[n, k] * self.x[n] for n in range(self.n)) / self.counts[k]\n self.covars[k] = np.sum(self.resp[n, k] * (self.x[n] - self.means[k]) @ (self.x[n] - self.means[k]).T\n for n in range(self.n)) / self.counts[k]\n self.covars[k] = np.nan_to_num(self.covars[k])\n self.means[k] = np.nan_to_num(self.means[k])","def _getBaselineThresh(self):\n print('Calculating 10% baseline')\n self.baseline = obrienBaseline.obrienBaseline(\n self.d['dos1rate'], timeWidth=5.0, \n cadence=0.1)\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \n self.baseline[self.peakInd]/10)/ \n np.sqrt(self.d['dos1rate'][self.peakInd]/10))\n return","def percentageChange(self):\n try:\n curPrice = self.dailyData[-1].currentPrice\n closePrice = self.historicData[-1].closePrice\n except IndexError: # Just return zero when no historic or dailyData is available yet\n return 0.0\n return (curPrice - closePrice)/closePrice * 100","def totalValue(self):\n\n\t\tvalue = 0\n\t\tfor bottle in self.bottles:\n\t\t\tvalue += bottle.inflatedCost\n\n\t\treturn value","def lower_bound(self) -> float:\n ...","def tax_rate(self) -> float:\n return round((self.total / self.income) * 100, 2)","def calc_low_energy_bulb_ratio(lighting_outlets_total, lighting_outlets_low_energy):\n return int(100 * float(lighting_outlets_low_energy) / lighting_outlets_total + 0.5) / 100.0","def get_pc_per_range(model, class_name):\n class_total = model.class_counts[class_name]\n if model.num_runs is not None:\n class_total = model.num_runs * class_total * .33\n\n true_positives, totals = model.range_metrics_10[class_name]\n purities = [] # Accuracy per range (true positive/total)\n comps = []\n TP_count = 0\n total_count = 0\n\n for index in reversed(range(len(true_positives))):\n cur_p = 0 # Current purity\n cur_c = 0 # Current completeness\n TP_count += true_positives[index]\n total_count += totals[index]\n if total_count != 0:\n # positive class samples / totals # with prob in range\n cur_p = TP_count / total_count\n if class_total != 0:\n cur_c = TP_count / class_total\n\n purities.append(cur_p)\n comps.append(cur_c)\n purities.reverse()\n comps.reverse()\n return purities, comps","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def _compute_register_bounds(cls, num_values, probability):\n bits = np.arange(1, num_values + 1)\n probs = scipy.stats.geom.cdf(bits, probability)\n return probs / probs[-1]","def ComputeRegenerativeBraking(self):\r\n pass","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def _calc_freeze_probability(self, num_iterations, final_fraction):\n return 1.0 - (final_fraction ** (1.0 / num_iterations))","def rate(self) -> float:\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0","def upper_bound(stock):\n counter=0\n for i in stock_price(stock):\n if i >= resistance(stock):\n counter+=1\n return counter","def recall(self) -> float:\n if self.ref_ignored:\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\n self.num_ignored += num_ref_ignored\n # True Positive = the number of unignored reference mappings that are Positive\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\n # False Negative = the number of unignored reference mappings that are Negative\n fn = len(self.ref_set) - tp - num_ref_ignored\n return tp / (tp + fn)","def percentage_complete(self) -> float:\n return self.__percentage_complete","def compute(self):\n rsa = self._session_graph.get_graph_property(self._FACTOR_KEY)\n rsa = rsa if rsa else 0.\n tr = self._session_graph.graph.num_edges()\n tr = tr if tr > 0 else 1\n rs = self._traffic_record['response_size']\n rsa = ((float(rsa) * (float(tr) - 1.)) + float(rs)) / float(tr)\n self.append_graph_factor('float', rsa)\n\n print \"Response Size Average : \", rsa\n pass","def evaluate_percentage_of_class_for_each_flight(df_flights_info):\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\n for row, col in df_new.iterrows():\n for item in list(df_new):\n number_booking = df_new.loc[row, item]\n total_booking = df_new.loc[row]['Total']\n percentage = float(number_booking / total_booking)\n df_new.at[row, item] = percentage\n df_new = df_new.drop(columns=['Total'])\n df_new = df_new.stack()\n df_new = df_new.reset_index(level=[0, 1])\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\n return df_flights_info","def dilutionneeded(self) -> float:\n return self.stock*1.0/self.final"],"string":"[\n \"def set_total_reb_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n player_rebounds = bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"]\\n team_rebounds = team[\\\"reb_def\\\"] + team[\\\"reb_of\\\"]\\n opp_team_rebounds = opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((player_rebounds * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team_rebounds + opp_team_rebounds)))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def set_total_reb_def_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((bx[\\\"reb_def\\\"] * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"])))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_def_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def pct_bust(data):\\n return round((data[\\\"new_total\\\"] > 21).sum() / len(data), 3)\",\n \"def percent_raised(self):\\n total_cost = self.total_cost()\\n if total_cost:\\n return round(self.total_raised() * 100 / total_cost, 2)\\n else:\\n return 0\",\n \"def __call__(self, relsSortedByScores, qrelDict):\\n result = 0.\\n postQty = len(qrelDict)\\n\\n pos = 0\\n for i, rel in enumerate(relsSortedByScores):\\n if rel > RELEVANCE_THRESHOLD:\\n pos += 1.\\n result += pos / (i + 1.)\\n\\n return result / postQty\",\n \"def calculate_profit(self):\",\n \"def get_free_set_percentage(self, params):\\n raise NotImplementedError()\",\n \"def calculScore(self):\\n for cell in self.notComputeRouter:\\n if(cell.isCovered==True):\\n self.score += 1000\\n self.score += self.budget\",\n \"def overall_reduction(self):\\n return 84\",\n \"def _prorata_rate(self, days_used, days_in_month):\\n return (100 * days_used // days_in_month) / 100.0\",\n \"def getClassBalance(pshapes, bounds, proj):\\n\\n xmin, ymin, xmax, ymax = bounds\\n bpoly = Polygon([(xmin, ymax),\\n (xmax, ymax),\\n (xmax, ymin),\\n (xmin, ymin)])\\n project = partial(\\n pyproj.transform,\\n pyproj.Proj(proj='latlong', datum='WGS84'),\\n proj)\\n bpolyproj = transform(project, bpoly)\\n totalarea = bpolyproj.area\\n polyarea = 0\\n for pshape in pshapes:\\n polyarea += pshape.area\\n\\n return polyarea/totalarea\",\n \"def get_load_factor(self):\\n # Your code here\\n return self.total_items / self.capacity\",\n \"def CalculateBoundProbability(self, psi):\\n\\n\\t\\t_, _, _, boundTotal = self.CalculateBoundDistribution(psi)\\n\\n\\t\\treturn boundTotal\",\n \"def represent_total_percent(self, length):\\n numpkgs = self.totals['numpkgs']\\n dlpkgs = self.totals['dlpkgs']\\n return self.represent_percent(dlpkgs, numpkgs, length)\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def calculate_percent(self, total_number, some_number):\\n\\t\\treturn (some_number * 100) / total_number\",\n \"def coverage(self):\\n try:\\n return self.found * 100 / self.needed\\n except ZeroDivisionError:\\n return 100.0\",\n \"def ComputeNrb(self):\\r\\n pass\",\n \"def fractionPassing(self):\\n return self.cut.entries / self.entries\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def _calculate_result(found, total):\\n return (found * 100) / total\",\n \"def rF(count, total):\\n\\treturn float(count)/float(total)\",\n \"def exceeded_ratio(self) -> float:\\n return self.amount_spent / self.total_amount\",\n \"def percent_usage(value, total):\\n if total:\\n return float(value) * 100.0 / (float(total) + float(value))\\n else:\\n return 100.0\",\n \"def grand_total(self):\\n return sum(self.grid[pos][1] for pos in assignable_positions if self.grid[pos][0]) + self.grid[\\\"nb\\\"][1]\",\n \"def fitness(individual, divider, target_sum, target_multiply):\\n\\n sum_val = reduce(operator.add, individual[:divider], 0)\\n multiply_val = reduce(operator.mul, individual[divider:], 1)\\n \\n sum_error = abs(target_sum - sum_val)\\n sum_error = sum_error / target_sum\\n\\n multiply_error = abs(target_multiply - multiply_val)\\n multiply_error = multiply_error / target_multiply\\n\\n #print(multiply_error, sum_error)\\n #print(sum_error, multiply_error)\\n return (multiply_error + sum_error)/2 * 100\",\n \"def compute_total_customs_duty(self):\\n for rec in self:\\n total = 0.0\\n extra_duty = 0.0\\n price_total = rec.quantity * rec.unit_price\\n# total = (price_total * duty_percentage)/100\\n rec.price_total = price_total\\n# for hts in rec.hts_ids:\\n# if hts.extra_duty_applicable:\\n# extra_duty += ((rec.quantity/hts.quantity) * hts.extra_duty)\\n# rec.total = total + extra_duty\\n\\n return True\",\n \"def calculate_gpa(self):\\n cur_node = self.head\\n gpa = 0\\n total_credits = 0\\n while cur_node is not None:\\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\\n total_credits += cur_node.data.credit_hr()\\n cur_node = cur_node.next\\n if total_credits == 0:\\n return 0\\n return gpa / total_credits\",\n \"def upper_bound(self) -> float:\\n ...\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def penalty(self):\\n return 0\",\n \"def patrimony_total(self):\\n pass\",\n \"def life_insurance_to_recive_total(self):\\n pass\",\n \"def total_rewards(self) -> float:\\n return self.__total_rewards\",\n \"def mb_r(self) -> float:\\n # Calculate metric\\n n = self.predicted.size\\n tot = 0.0\\n for i in range(n):\\n tot = tot + np.sum(np.abs(self.predicted - self.true[i]))\\n mae_val = np.sum(np.abs(self.predicted - self.true)) / n\\n mb = 1 - ((n ** 2) * mae_val / tot)\\n\\n return float(mb)\",\n \"def get_percentage(self):\\n return self.PotTax_percentage\",\n \"def cal_hit_gbratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \\n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\\n\\n #print(np.mean(score_ratio))\\n #print(score_1)\\n #score = score_1 + score_2\\n return np.mean(score_ratio)\",\n \"def update_percent(self):\",\n \"def percent_b(self) -> float:\\n return self._percent_b\",\n \"def private_pension_total(self):\\n pass\",\n \"def percentage_update(self):\\n\\n self.event_update()\\n return self.percentage\",\n \"def cost(self) -> float:\",\n \"def calc_pct_to_save_as_doublets(self):\\n x, y = load_expected_doublet_rates( # pylint: disable=invalid-name\\n \\\"/Users/austinhartman/Desktop/doublet-caller/src/expected_doublet_rates.csv\\\"\\n )\\n r = calculate_expected_doublet_rate(x, y) # pylint: disable=invalid-name\\n return self.num_cells * r[\\\"coefficient\\\"] + r[\\\"intercept\\\"]\",\n \"def overhead(readings):\\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))\",\n \"def usage_percent(used, total, _round=None):\\r\\n try:\\r\\n ret = (used / total) * 100\\r\\n except ZeroDivisionError:\\r\\n ret = 0\\r\\n if _round is not None:\\r\\n return round(ret, _round)\\r\\n else:\\r\\n return ret\",\n \"def budget_used(self):\\n return int(self.total_spent() / self.budget() * 100.0)\",\n \"def percentage(self):\\n temp = self.cpu_freq_time_spent.copy()\\n for i in self.cpu_freq_time_spent:\\n total = 0\\n for j in self.cpu_freq_time_spent[i]:\\n total += self.cpu_freq_time_spent[i][j]\\n for j in self.cpu_freq_time_spent[i]:\\n if total != 0:\\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\\n else:\\n temp[i][j] = 0\\n return temp\",\n \"def robbins(counts):\\n return float(singles(counts))/counts.sum()\",\n \"def calculate(self) -> float:\",\n \"def calculate_risk_tol(*args):\\n global total_score\\n risk_tol_start = 0.0\\n\\n for risk_per_pg in risk_tol_per_qs.iterkeys():\\n try:\\n risk_tol_start = risk_tol_start + risk_tol_per_qs[risk_per_pg][-1] # this is the last item in the list of each information in the page\\n except IndexError:\\n pass\\n total_score = risk_tol_start\",\n \"def get_expected_cost(self):\",\n \"def total(self) -> float:\\n\\n remained_to_be_taxed = self.income\\n # taxed = list()\\n self.tax_amounts = []\\n start_tax_range = 0\\n end_tax_range = self.bracket\\n\\n for i, b in enumerate(self.bracket):\\n\\n amount_to_tax = b.end - start_tax_range\\n t = Taxed(min(amount_to_tax, remained_to_be_taxed), b.rate,\\n min(amount_to_tax, remained_to_be_taxed) * b.rate)\\n self.tax_amounts.append(t)\\n # print(i, start_t ax_range, b.end, amount_to_tax, b.rate)\\n\\n remained_to_be_taxed -= amount_to_tax\\n # print(remained_to_be_taxed)\\n\\n if b.end > self.income:\\n break\\n\\n start_tax_range = b.end\\n\\n # print(taxed)\\n return sum([t.tax for t in self.tax_amounts])\",\n \"def revenue_landfill(self) -> float:\\n return self.income_statement.revenue.operating_revenue * (\\n 1 - self.inputs.allocation_to_collection_unit\\n )\",\n \"def return_on_total_assets():\\r\\n x = float(input(\\\"Please Enter Net Income Value: \\\"))\\r\\n y = float(input(\\\"Please Enter Interest Expense Value: \\\"))\\r\\n z = float(input(\\\"Please Enter Beginning Total Assets Value: \\\"))\\r\\n w = float(input(\\\"Please Enter Ending Total Assets Value: \\\"))\\r\\n d = ((float(x)+float(y)) / ((float(z)+float(w)) / float(2))) * float(100)\\r\\n print \\\">> Your Rate of Return on Total Assets is\\\",round(d,1),\\\"%\\\"\",\n \"def compute_bound(self, sstats, totals):\\n w = self.vocab_len\\n t = self.num_time_slices\\n\\n term_1 = 0\\n term_2 = 0\\n term_3 = 0\\n\\n val = 0\\n ent = 0\\n\\n chain_variance = self.chain_variance\\n # computing mean, fwd_mean\\n self.mean, self.fwd_mean = \\\\\\n (np.array(x) for x in zip(*(self.compute_post_mean(w, self.chain_variance) for w in range(w))))\\n self.zeta = self.update_zeta()\\n\\n val = sum(self.variance[w][0] - self.variance[w][t] for w in range(w)) / 2 * chain_variance\\n\\n logger.info(\\\"Computing bound, all times\\\")\\n\\n for t in range(1, t + 1):\\n term_1 = 0.0\\n term_2 = 0.0\\n ent = 0.0\\n for w in range(w):\\n\\n m = self.mean[w][t]\\n prev_m = self.mean[w][t - 1]\\n\\n v = self.variance[w][t]\\n\\n # w_phi_l is only used in Document Influence Model; the values are always zero in this case\\n # w_phi_l = sslm.w_phi_l[w][t - 1]\\n # exp_i = np.exp(-prev_m)\\n # term_1 += (np.power(m - prev_m - (w_phi_l * exp_i), 2) / (2 * chain_variance)) -\\n # (v / chain_variance) - np.log(chain_variance)\\n\\n term_1 += \\\\\\n (np.power(m - prev_m, 2) / (2 * chain_variance)) - (v / chain_variance) - np.log(chain_variance)\\n term_2 += sstats[w][t - 1] * m\\n ent += np.log(v) / 2 # note the 2pi's cancel with term1 (see doc)\\n\\n term_3 = -totals[t - 1] * np.log(self.zeta[t - 1])\\n val += term_2 + term_3 + ent - term_1\\n\\n return val\",\n \"def total_sdram_requirements(self):\",\n \"def rate(self, neighbors, labels):\\n num = 0\\n den = 0\\n for neighbor in neighbors:\\n lable = self.labels[neighbor[1]]\\n dest_to_neighbor = neighbor[0]\\n num += lable / dest_to_neighbor\\n den += 1 / dest_to_neighbor\\n return num/den\",\n \"def total_area(self):\\n return numpy.prod([r[1] - r[0] for r in self.range_])\",\n \"def get_tot_occ_rate(self):\\n return 10 ** (self.a_value - self.b_value * self.min_mag) - \\\\\\n 10 ** (self.a_value - self.b_value * self.max_mag)\",\n \"def pct_helper(self,k,d,total):\\n if k in d:\\n return 100.0*d[k]/total\\n else:\\n return -100.0\",\n \"def proper_annulus_centres(self) -> Quantity:\\n return self._proper_ann_centres\",\n \"def current_nbc_coverage():\\n covered = 0\\n total = 0\\n for layer in layer_to_compute:\\n covered = covered + np.count_nonzero(nbc_cov_dict[layer.name])\\n total = total + np.size(nbc_cov_dict[layer.name])\\n return covered / float(total)\",\n \"def _calcTotalMax(self, item, masterIntf, slaveIntf):\\n if self.classmax:\\n total = int((self.params[masterIntf]['intf_max']*self.params[masterIntf][slaveIntf]))\\n total = int(total/self.params[masterIntf]['total_allocated'])+item['reserved']\\n totalAll = item['reqRate'] + item['reserved']\\n return max(total, totalAll)\\n return item['reqRate'] + item['reserved']\",\n \"def ram_percent(self):\\n self.monitoring_object['ram_percent'] = \\\\\\n psutil.virtual_memory().used\",\n \"def percent_updated(self):\\n return self.percent_complete - self.previous_percent_complete\",\n \"def findBoundResonances(resonance):\\n\\n from ccpnmr.analysis.core.AssignmentBasic import getBoundResonances\\n \\n return getBoundResonances(resonance)\",\n \"def cf_mean(self):\\n return self['capacity_factor'] / 100\",\n \"def cf_mean(self):\\n return self['capacity_factor'] / 100\",\n \"def per_hour(self):\\n if self.is_salary():\\n return 0.0\\n return self.wage_cents / 100.0\",\n \"def calculate_finalscore(self):\\n\\n if self.count!=0:\\n print(self.count)\\n print(self.badGuess)\\n self.finalScore=(self.total/self.count)- ((self.total/self.count)*(10*self.badGuess)/100)\\n\\n\\n else:\\n self.finalScore=self.total\",\n \"def get_total_risk_level(self) -> int:\\n origin = Point(0, 0)\\n bounded_points = self.grid.get_bounded_points(origin, self.target)\\n return sum(self.get_region(point) for point, _ in bounded_points)\",\n \"def g_score(self):\\n _, _, I_CK = self._entropies()\\n return 2.0 * I_CK\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def compute_quotation_price(self):\\n result = decimal.Decimal('0')\\n if self.vehiculePrice:\\n result = self.vehiculePrice * 2 / 100\\n if self.covWind:\\n result += get_coverage_price_by_name(\\\"WIND\\\")\\n if self.covPass:\\n result += get_coverage_price_by_name(\\\"PASS\\\")\\n if self.covFlood:\\n result += get_coverage_price_by_name(\\\"FLOOD\\\")\\n return result\",\n \"def percent_busy(self):\\n return self._percent_busy\",\n \"def compute_sufficient_stats(self):\\n self.counts = (np.sum(self.resp, axis=0) + 10e-30)\\n # print(self.counts)\\n for k in range(self.k):\\n self.means[k] = np.sum(self.resp[n, k] * self.x[n] for n in range(self.n)) / self.counts[k]\\n self.covars[k] = np.sum(self.resp[n, k] * (self.x[n] - self.means[k]) @ (self.x[n] - self.means[k]).T\\n for n in range(self.n)) / self.counts[k]\\n self.covars[k] = np.nan_to_num(self.covars[k])\\n self.means[k] = np.nan_to_num(self.means[k])\",\n \"def _getBaselineThresh(self):\\n print('Calculating 10% baseline')\\n self.baseline = obrienBaseline.obrienBaseline(\\n self.d['dos1rate'], timeWidth=5.0, \\n cadence=0.1)\\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \\n self.baseline[self.peakInd]/10)/ \\n np.sqrt(self.d['dos1rate'][self.peakInd]/10))\\n return\",\n \"def percentageChange(self):\\n try:\\n curPrice = self.dailyData[-1].currentPrice\\n closePrice = self.historicData[-1].closePrice\\n except IndexError: # Just return zero when no historic or dailyData is available yet\\n return 0.0\\n return (curPrice - closePrice)/closePrice * 100\",\n \"def totalValue(self):\\n\\n\\t\\tvalue = 0\\n\\t\\tfor bottle in self.bottles:\\n\\t\\t\\tvalue += bottle.inflatedCost\\n\\n\\t\\treturn value\",\n \"def lower_bound(self) -> float:\\n ...\",\n \"def tax_rate(self) -> float:\\n return round((self.total / self.income) * 100, 2)\",\n \"def calc_low_energy_bulb_ratio(lighting_outlets_total, lighting_outlets_low_energy):\\n return int(100 * float(lighting_outlets_low_energy) / lighting_outlets_total + 0.5) / 100.0\",\n \"def get_pc_per_range(model, class_name):\\n class_total = model.class_counts[class_name]\\n if model.num_runs is not None:\\n class_total = model.num_runs * class_total * .33\\n\\n true_positives, totals = model.range_metrics_10[class_name]\\n purities = [] # Accuracy per range (true positive/total)\\n comps = []\\n TP_count = 0\\n total_count = 0\\n\\n for index in reversed(range(len(true_positives))):\\n cur_p = 0 # Current purity\\n cur_c = 0 # Current completeness\\n TP_count += true_positives[index]\\n total_count += totals[index]\\n if total_count != 0:\\n # positive class samples / totals # with prob in range\\n cur_p = TP_count / total_count\\n if class_total != 0:\\n cur_c = TP_count / class_total\\n\\n purities.append(cur_p)\\n comps.append(cur_c)\\n purities.reverse()\\n comps.reverse()\\n return purities, comps\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def _compute_register_bounds(cls, num_values, probability):\\n bits = np.arange(1, num_values + 1)\\n probs = scipy.stats.geom.cdf(bits, probability)\\n return probs / probs[-1]\",\n \"def ComputeRegenerativeBraking(self):\\r\\n pass\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def _calc_freeze_probability(self, num_iterations, final_fraction):\\n return 1.0 - (final_fraction ** (1.0 / num_iterations))\",\n \"def rate(self) -> float:\\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0\",\n \"def upper_bound(stock):\\n counter=0\\n for i in stock_price(stock):\\n if i >= resistance(stock):\\n counter+=1\\n return counter\",\n \"def recall(self) -> float:\\n if self.ref_ignored:\\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\\n self.num_ignored += num_ref_ignored\\n # True Positive = the number of unignored reference mappings that are Positive\\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\\n # False Negative = the number of unignored reference mappings that are Negative\\n fn = len(self.ref_set) - tp - num_ref_ignored\\n return tp / (tp + fn)\",\n \"def percentage_complete(self) -> float:\\n return self.__percentage_complete\",\n \"def compute(self):\\n rsa = self._session_graph.get_graph_property(self._FACTOR_KEY)\\n rsa = rsa if rsa else 0.\\n tr = self._session_graph.graph.num_edges()\\n tr = tr if tr > 0 else 1\\n rs = self._traffic_record['response_size']\\n rsa = ((float(rsa) * (float(tr) - 1.)) + float(rs)) / float(tr)\\n self.append_graph_factor('float', rsa)\\n\\n print \\\"Response Size Average : \\\", rsa\\n pass\",\n \"def evaluate_percentage_of_class_for_each_flight(df_flights_info):\\n df_new = df_flights_info[['FlightId', 'FareClass', 'Booking']]\\n df_new = df_new.pivot(index='FlightId', columns='FareClass', values='Booking').astype(float)\\n df_new.loc[:, 'Total'] = df_new.sum(axis=1).astype(float)\\n for row, col in df_new.iterrows():\\n for item in list(df_new):\\n number_booking = df_new.loc[row, item]\\n total_booking = df_new.loc[row]['Total']\\n percentage = float(number_booking / total_booking)\\n df_new.at[row, item] = percentage\\n df_new = df_new.drop(columns=['Total'])\\n df_new = df_new.stack()\\n df_new = df_new.reset_index(level=[0, 1])\\n df_flights_info = pandas.merge(df_flights_info, df_new, how='left', on=['FlightId', 'FareClass'])\\n df_flights_info.rename(columns={0: 'Percentage'}, inplace=True)\\n return df_flights_info\",\n \"def dilutionneeded(self) -> float:\\n return self.stock*1.0/self.final\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68673694","0.66328514","0.65427613","0.64778984","0.64688313","0.64383364","0.63684523","0.6308236","0.6169081","0.6124151","0.60928077","0.60605025","0.6027442","0.60271585","0.60221356","0.60200536","0.6008577","0.6006814","0.5980527","0.5972647","0.5957324","0.5947713","0.5925849","0.5912426","0.5882893","0.5882494","0.58785963","0.58748186","0.587026","0.58699393","0.58682823","0.5865907","0.5845565","0.5845565","0.58424973","0.58351046","0.58340216","0.58212936","0.58189946","0.58134544","0.58093274","0.5808309","0.57993007","0.578817","0.57864535","0.5785923","0.5773871","0.57572144","0.5757201","0.5748954","0.5748799","0.5748273","0.57449937","0.5731056","0.5724983","0.5722081","0.57163554","0.5714958","0.57147497","0.5713325","0.57118773","0.5709847","0.57016456","0.56990707","0.5677512","0.56720984","0.56695664","0.5668416","0.5663785","0.5660913","0.56543","0.56543","0.5651694","0.56430686","0.5639245","0.56349605","0.56294227","0.56294227","0.56277084","0.56253445","0.5624303","0.5624263","0.5620671","0.5618413","0.5618074","0.5611774","0.5605818","0.55979836","0.55946213","0.559111","0.5589614","0.5589394","0.55878824","0.5586106","0.55805075","0.5574297","0.5564137","0.55619425","0.5550346","0.5547965"],"string":"[\n \"0.68673694\",\n \"0.66328514\",\n \"0.65427613\",\n \"0.64778984\",\n \"0.64688313\",\n \"0.64383364\",\n \"0.63684523\",\n \"0.6308236\",\n \"0.6169081\",\n \"0.6124151\",\n \"0.60928077\",\n \"0.60605025\",\n \"0.6027442\",\n \"0.60271585\",\n \"0.60221356\",\n \"0.60200536\",\n \"0.6008577\",\n \"0.6006814\",\n \"0.5980527\",\n \"0.5972647\",\n \"0.5957324\",\n \"0.5947713\",\n \"0.5925849\",\n \"0.5912426\",\n \"0.5882893\",\n \"0.5882494\",\n \"0.58785963\",\n \"0.58748186\",\n \"0.587026\",\n \"0.58699393\",\n \"0.58682823\",\n \"0.5865907\",\n \"0.5845565\",\n \"0.5845565\",\n \"0.58424973\",\n \"0.58351046\",\n \"0.58340216\",\n \"0.58212936\",\n \"0.58189946\",\n \"0.58134544\",\n \"0.58093274\",\n \"0.5808309\",\n \"0.57993007\",\n \"0.578817\",\n \"0.57864535\",\n \"0.5785923\",\n \"0.5773871\",\n \"0.57572144\",\n \"0.5757201\",\n \"0.5748954\",\n \"0.5748799\",\n \"0.5748273\",\n \"0.57449937\",\n \"0.5731056\",\n \"0.5724983\",\n \"0.5722081\",\n \"0.57163554\",\n \"0.5714958\",\n \"0.57147497\",\n \"0.5713325\",\n \"0.57118773\",\n \"0.5709847\",\n \"0.57016456\",\n \"0.56990707\",\n \"0.5677512\",\n \"0.56720984\",\n \"0.56695664\",\n \"0.5668416\",\n \"0.5663785\",\n \"0.5660913\",\n \"0.56543\",\n \"0.56543\",\n \"0.5651694\",\n \"0.56430686\",\n \"0.5639245\",\n \"0.56349605\",\n \"0.56294227\",\n \"0.56294227\",\n \"0.56277084\",\n \"0.56253445\",\n \"0.5624303\",\n \"0.5624263\",\n \"0.5620671\",\n \"0.5618413\",\n \"0.5618074\",\n \"0.5611774\",\n \"0.5605818\",\n \"0.55979836\",\n \"0.55946213\",\n \"0.559111\",\n \"0.5589614\",\n \"0.5589394\",\n \"0.55878824\",\n \"0.5586106\",\n \"0.55805075\",\n \"0.5574297\",\n \"0.5564137\",\n \"0.55619425\",\n \"0.5550346\",\n \"0.5547965\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65185946"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":3094,"cells":{"query":{"kind":"string","value":"Method which calculate Steals Percentage of a player"},"document":{"kind":"string","value":"def set_steals_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n poss = self.get_team_possessions()\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((bx[\"steals\"] * (team[\"minutes\"]/Decimal('5'))) / Decimal(float(bx[\"minutes\"]) * poss)) * 100\n self.steals_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def get_win_percentage(self) -> float:\n if self.wins == 0:\n return 0.0\n else:\n return round((self.wins / (self.wins + self.losses)) * 100, 2)","def pct(self):\n\t\treturn self.bottle.pct()","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def percentage_update(self):\n\n self.event_update()\n return self.percentage","def set_ts_percentage(self):\n bx = self.get_standard_stats()\n ptos = float(bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tsAttempts = float(tcInt + (0.44*float(bx[\"tl_int\"])))\n result = 0.00\n if tsAttempts > 0.00:\n result = (ptos/(2*tsAttempts))*100\n self.ts_percentage = \"%.2f\" % round(result, 2)","def per_hour(self):\n if self.is_salary():\n return 0.0\n return self.wage_cents / 100.0","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def getPercent(*args):","def getPercent(*args):","def percentage(count, total):\n return count / total * 100","def set_assists_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n team_tc_conv = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n player_tc_conv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0:\n result = (bx[\"assists\"] / (((bx[\"minutes\"] / (team[\"minutes\"] / 5)) * team_tc_conv) - player_tc_conv))*100\n result = result if result <= 100 and result >= 0 else 0\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.assists_percentage = \"%.2f\" % round(result, 2)","def get_percentage(self):\n return self.percentage","def get_percentage(self):\n return self.percentage","def p(party, vote_count, s):\n return t(party, vote_count) / d(s)","async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def percentage(self):\n return sum(self.chunk_percentage) / self.total_steps","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)","def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress","def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress","def calculateWinRate():\n times = 10\n winRate = 0.0\n for i in range(times):\n game = Game('user', 6, 6)\n winRate += game.play(5, False, True, False, False)\n winRate = winRate/times\n print \"Winrate:\", winRate","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def get_percent(self):\n return self.percent","def progress(self) -> int:\n return int(round(100 * self.somme() / self.finances))","def getPercent(self):\n if isinstance(self.score,numbers.Number) and self.getMaximum():\n return (1.0*self.score/self.getMaximum())\n return None","def set_usg_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n tcInt = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n a = tcInt + (Decimal('0.44')*bx[\"tl_int\"]) + bx[\"turnovers\"]\n b = team[\"minutes\"]/5\n c = (team[\"t2p_int\"] + team[\"t3p_int\"]) + (Decimal('0.44')*team[\"tl_int\"]) + team[\"turnovers\"]\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((Decimal(a)*Decimal(b))/(bx[\"minutes\"]*c))*100\n self.usg_percentage = \"%.2f\" % round(result, 2)","def percent_raised(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.total_raised() * 100 / total_cost, 2)\n else:\n return 0","def percent_passing(self) -> float:\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\n num_pass = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: m.passed)\n .count(lambda p: bool(p) is True)\n )\n return float(100 * num_pass / num_meas)","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def update_percent(self):","async def get_rob_percentage(level):\n chance = int(6 + (level // 10)) # first 10 levels is 6 for 30% chance\n if chance > 16:\n chance = 16\n return chance","def get_percentage_sf_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_sf)/(votes_f + votes_sf)\n return round(ratio * 100, 1)","def determineAmountToCall(self, player):\n\t\treturn sum(self.currentBet) - sum(player.betAmount)","def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def give_half(self, player):\n self.transfer(\n self,\n player,\n int(ceil(self.account.balance/2.0))\n )\n return '%s spins \\'hey\\' and gets half.' % (player,)","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n #Between 1-8\n return own_moves / opp_moves","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def calculatePercentChange(self, oldValue, newValue):\n return (((newValue - oldValue)/oldValue)*100)","def as_percent(self):\n if self.dynamic:\n self._update_db_obj()\n return f\"{(self._db_obj.progress / self._db_obj.total) * 100}%\"","def winRate(DF):\r\n df = DF[\"return\"]\r\n pos = df[df>1]\r\n neg = df[df<1]\r\n return (len(pos) / len(pos + neg)) * 100","def get_score_percent(self, value):\n qs_related = RoundData.objects.prefetch_related(\n 'shotdata').select_related('shotdata')\n\n round_holes = int(self.round_type)\n\n if value == 'par':\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'birdie_better':\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'tbogey_worse':\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\n if isinstance(value, int):\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)","def shield_percentage(self) -> Union[int, float]:\n if not self.proto.shield_max:\n return 0\n return self.proto.shield / self.proto.shield_max","def shield_percentage(self) -> Union[int, float]:\n if not self.proto.shield_max:\n return 0\n return self.proto.shield / self.proto.shield_max","def percentage_used(self):\n return self.volume_used/self.total_volume * 100.0","def percent(self):\r\n return self._percent","def get_percent_wet():\n # Create an ADS1115 ADC (16-bit) instance.\n adc = Adafruit_ADS1x15.ADS1115()\n\n GAIN = 1\n DRY = 20280 # 100% Dry\n WET = 10140 # 100% Wet\n\n value = adc.read_adc(0, gain=GAIN)\n \n # print \"value: %d\" % value\n \n percent_dry = ((value - WET)*100)/(DRY-WET)\n percent_wet = 100 - percent_dry\n\n return percent_wet","def percent(value, total):\n if total:\n return float(value) * 100.0 / float(total)\n else:\n return 100.0","def __calc_s(self, df):\n df.loc[:, \"avg_num_drivers\"] = df.idle + df.incoming\n s = df.total / df.avg_num_drivers # df.total := amount of demand\n s[s > 1] = 1\n s[np.isnan(s)] = 0.0001\n s[np.isinf(s)] = 1\n\n df.loc[:, \"prob_of_s\"] = s\n df = df[[\"zone_id\", \"prob_of_s\"]]\n return df","def pulse_width_percent(self) -> float:","def _percent(self, lines_total, lines_covered):\n\n if lines_total == 0:\n return '0.0'\n return str(float(float(lines_covered) / float(lines_total)))","def percentage(a, b):\n return (a * 100.0) / b","def exceeded_ratio(self) -> float:\n return self.amount_spent / self.total_amount","def calculate_percent(self, total_number, some_number):\n\t\treturn (some_number * 100) / total_number","def stealability(self):\n stealability_score = float(self.price) / float(self.weight)\n print (stealability_score)\n\n if stealability_score < 0.5:\n return 'Not so stealable...'\n elif stealability_score >= 0.5 and stealability_score < 1.0:\n return 'Kinda stealable.'\n else:\n return 'Very stealable!'","def percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"percentage\")","def pulsewidth2pct(pw): \n shifted = pw - 500.0\n scaled = shifted / 2000.0 * 100.0\n pct = scaled\n return pct","def calculate_profit(self):","def pe_ratio(self):\n try:\n return self.price / self.dividend_yield\n except ZeroDivisionError:\n return 0.0","def abbott_steam():\n per_klb = 20 # dollars per klb of steam\n kwh_eq = to_kwh(1) # kwh equivalent of steam\n per_kwh = per_klb / kwh_eq\n return per_kwh","def get_percentage(self):\n return self.PotTax_percentage","def calculate_probability(self):\n return 0","def calculate_utility(state, player):\n thisPlayer = player\n \n if state.winner() == (not thisPlayer):\n return -BigInitialValue\n if state.winner() == thisPlayer:\n return BigInitialValue\n return calculate_possible_fours(state, thisPlayer) - calculate_possible_fours(state, not thisPlayer)","def percentageChange(self):\n try:\n curPrice = self.dailyData[-1].currentPrice\n closePrice = self.historicData[-1].closePrice\n except IndexError: # Just return zero when no historic or dailyData is available yet\n return 0.0\n return (curPrice - closePrice)/closePrice * 100","def percentage(part, whole):\n return round((100 * float(part)/float(whole)),2)","def utility(self, state, player):\n if state.isWin() or state.isLose():\n return state.getScore()\n\n # In case of cycle.\n if player == PACMAN:\n return INFINITY\n else:\n return -INFINITY","def percent_usage(value, total):\n if total:\n return float(value) * 100.0 / (float(total) + float(value))\n else:\n return 100.0","def calculateSaleReturn(S,R,F,T):\n if (T > S):\n return 0\n\n if F == 100:\n return R*T/S\n\n return float(R) * ( 1.0 - math.pow(float(S-T)/float(S) , (100.0/float(F))))","def get_percentage_f_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_f)/(votes_f + votes_sf)\n return round(ratio * 100, 1)","def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum","def percent(obj,object2):\n if object2:\n return int(float(int(obj))/object2*100)\n else:\n return 0","def calculate_my_win_strength(self):\n self.winStrength = self.strategy(deepcopy(self.currentBoardState))","def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)","def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res","def percentage(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"percentage\")","def value(self, board, current_player, opposite_player):\n my_fours = self.check_for_streak(board, current_player, 4)\n my_threes = self.check_for_streak(board, current_player, 3)\n my_twos = self.check_for_streak(board, current_player, 2)\n opp_fours = self.check_for_streak(board, opposite_player, 4)\n if opp_fours > 0:\n return -100000\n else:\n return my_fours*100000 + my_threes*100 + my_twos","def per(a):\n return a * 100","def get_song_percent_remaining(result):\n return int((1 - (get_song_elapsed_milliseconds(result) / get_song_length_milliseconds(result))) * 100)","def percentage(self) -> str:\n return ranged_value_to_percentage(\n self._device.fan_speed_limits, self._device.fan_speed\n )","def total_rewards(self) -> float:\n return self.__total_rewards","def percentCheck(currentTimeLabel, totalTimeLabel):\n # Updated 11/19/16\n try:\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\n except (ValueError , ZeroDivisionError):\n progPercent = 0\n \n return progPercent","def set_tichu_percentage(threshold):\n tichu_threshold = threshold\n tichu_cnt = 0\n deck = Deck()\n players = [Player(id=0), Player(id=1), Player(id=2), Player(id=3)]\n for i in range(100):\n myhands = deck.shuffle_and_deal()\n for idx in range(4):\n players[idx].assign_hand(myhands[idx])\n score = players[idx].hand_rating\n if score > tichu_threshold:\n tichu_cnt += 1\n players[idx].hand.show()\n print('Player calls Tichu with a hand rating of {:.1f}.'.format(score))\n print('\\n')\n print('Tichu percentage: {:.2f}'.format(tichu_cnt/100))","def calculate_progress_percentage(d):\n successcounter = 0\n for test in d:\n if d[test][\"status\"] != \"not yet run\":\n successcounter += 1\n totalcounter = 0\n for test in d:\n totalcounter += 1\n return int(successcounter / totalcounter * 100)","def rate(self) -> float:\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0","def percentWinMult(percentWin, mult):\n if mult == 2:\n #increase percentage by a bit\n return percentWin - 0.08\n elif mult == 4:\n return percentWin - 0.04\n else:\n return percentWin - (mult/1000)","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def hero_healing_per_min(self):\n return self._hero_healing_per_min","def set_effective_field_goal_percentage(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tcConv = float(bx[\"t2p_conv\"] + bx[\"t3p_conv\"])\n result = 0.00\n if tcInt > 0:\n result = ((tcConv + (0.5 * float(bx[\"t3p_conv\"]))) / tcInt) * 100\n self.effective_field_goal_percentage = \"%.2f\" % round(result, 2)","def host_result_value(winner: Winner) -> float:\n if winner == Winner.HOME:\n return 1\n if winner == Winner.AWAY:\n return 0\n return 0.5","def calculateP(SD, numDiff):\n return numDiff/SD","def calculateP(SD, numDiff):\n return numDiff/SD","def _calculate_result(found, total):\n return (found * 100) / total","def calculate_emission_prob(cls, w, t):\n #\n # p_w_t = cls._emission_counts[w, t]\n # p_t = cls._uni_transition_counts[t]\n\n return float(cls._emission_counts[w, t] / cls._uni_transition_counts[t])","def effectivedb_size_percentage(self):\n if self._vsanobj.id is None:\n raise VsanNotPresent(\"Vsan \" + str(self._vsanobj._id) + \" is not present on the switch.\")\n out = self.__show_zone_status()\n retout = out.get(get_key(zonekeys.EFFDB_PER, self._SW_VER), None)\n if retout is not None:\n return str(retout) + \"%\"\n return None","def calculate(self) -> float:","def playerrawdmg(self):\n playerstr = globalvalues.p1.getstrength()\n # see combatvaluetable.xlsx to see some possible values of\n # playerrawdamage. Base formula is below:\n #\n rawdmg = int((playerstr - 4) * 102 * 0.32)\n\n # Things that will deviate the amount of damage done.\n level = globalvalues.p1.getlevel() - globalvalues.ai.getstatus()[0]\n modvalue = float(1 + level * 0.05)\n rngfactor = float(1 + float(random.randint(85, 105)) / 100)\n\n return int(rawdmg * modvalue * rngfactor)","def percentage_change(old_value, new_value):\n\n result = float(100 * (new_value - old_value) / old_value)\n\n return result","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def health_percentage(self) -> Union[int, float]:\n if not self.proto.health_max:\n return 0\n return self.proto.health / self.proto.health_max","def health_percentage(self) -> Union[int, float]:\n if not self.proto.health_max:\n return 0\n return self.proto.health / self.proto.health_max"],"string":"[\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def get_win_percentage(self) -> float:\\n if self.wins == 0:\\n return 0.0\\n else:\\n return round((self.wins / (self.wins + self.losses)) * 100, 2)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def percentage_update(self):\\n\\n self.event_update()\\n return self.percentage\",\n \"def set_ts_percentage(self):\\n bx = self.get_standard_stats()\\n ptos = float(bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tsAttempts = float(tcInt + (0.44*float(bx[\\\"tl_int\\\"])))\\n result = 0.00\\n if tsAttempts > 0.00:\\n result = (ptos/(2*tsAttempts))*100\\n self.ts_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def per_hour(self):\\n if self.is_salary():\\n return 0.0\\n return self.wage_cents / 100.0\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def set_assists_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n team_tc_conv = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n player_tc_conv = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0:\\n result = (bx[\\\"assists\\\"] / (((bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * team_tc_conv) - player_tc_conv))*100\\n result = result if result <= 100 and result >= 0 else 0\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.assists_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def p(party, vote_count, s):\\n return t(party, vote_count) / d(s)\",\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def percentage(self):\\n return sum(self.chunk_percentage) / self.total_steps\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\",\n \"def percentage_progress(self):\\n\\n if self.total_progress != 0:\\n return float(self.progress) / self.total_progress\\n return self.progress\",\n \"def percentage_progress(self):\\n\\n if self.total_progress != 0:\\n return float(self.progress) / self.total_progress\\n return self.progress\",\n \"def calculateWinRate():\\n times = 10\\n winRate = 0.0\\n for i in range(times):\\n game = Game('user', 6, 6)\\n winRate += game.play(5, False, True, False, False)\\n winRate = winRate/times\\n print \\\"Winrate:\\\", winRate\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def get_percent(self):\\n return self.percent\",\n \"def progress(self) -> int:\\n return int(round(100 * self.somme() / self.finances))\",\n \"def getPercent(self):\\n if isinstance(self.score,numbers.Number) and self.getMaximum():\\n return (1.0*self.score/self.getMaximum())\\n return None\",\n \"def set_usg_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n tcInt = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n a = tcInt + (Decimal('0.44')*bx[\\\"tl_int\\\"]) + bx[\\\"turnovers\\\"]\\n b = team[\\\"minutes\\\"]/5\\n c = (team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]) + (Decimal('0.44')*team[\\\"tl_int\\\"]) + team[\\\"turnovers\\\"]\\n result = 0.00\\n if bx[\\\"minutes\\\"] > 0:\\n result = ((Decimal(a)*Decimal(b))/(bx[\\\"minutes\\\"]*c))*100\\n self.usg_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def percent_raised(self):\\n total_cost = self.total_cost()\\n if total_cost:\\n return round(self.total_raised() * 100 / total_cost, 2)\\n else:\\n return 0\",\n \"def percent_passing(self) -> float:\\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\\n num_pass = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: m.passed)\\n .count(lambda p: bool(p) is True)\\n )\\n return float(100 * num_pass / num_meas)\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def update_percent(self):\",\n \"async def get_rob_percentage(level):\\n chance = int(6 + (level // 10)) # first 10 levels is 6 for 30% chance\\n if chance > 16:\\n chance = 16\\n return chance\",\n \"def get_percentage_sf_votes(self):\\n\\n votes_f = self.get_num_f_votes()\\n votes_sf = self.get_num_sf_votes()\\n\\n # avoid dividing by zero\\n if votes_f + votes_sf == 0:\\n return 0\\n else:\\n ratio = float(votes_sf)/(votes_f + votes_sf)\\n return round(ratio * 100, 1)\",\n \"def determineAmountToCall(self, player):\\n\\t\\treturn sum(self.currentBet) - sum(player.betAmount)\",\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def give_half(self, player):\\n self.transfer(\\n self,\\n player,\\n int(ceil(self.account.balance/2.0))\\n )\\n return '%s spins \\\\'hey\\\\' and gets half.' % (player,)\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n #Between 1-8\\n return own_moves / opp_moves\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def calculatePercentChange(self, oldValue, newValue):\\n return (((newValue - oldValue)/oldValue)*100)\",\n \"def as_percent(self):\\n if self.dynamic:\\n self._update_db_obj()\\n return f\\\"{(self._db_obj.progress / self._db_obj.total) * 100}%\\\"\",\n \"def winRate(DF):\\r\\n df = DF[\\\"return\\\"]\\r\\n pos = df[df>1]\\r\\n neg = df[df<1]\\r\\n return (len(pos) / len(pos + neg)) * 100\",\n \"def get_score_percent(self, value):\\n qs_related = RoundData.objects.prefetch_related(\\n 'shotdata').select_related('shotdata')\\n\\n round_holes = int(self.round_type)\\n\\n if value == 'par':\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'birdie_better':\\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'tbogey_worse':\\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\\n if isinstance(value, int):\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)\",\n \"def shield_percentage(self) -> Union[int, float]:\\n if not self.proto.shield_max:\\n return 0\\n return self.proto.shield / self.proto.shield_max\",\n \"def shield_percentage(self) -> Union[int, float]:\\n if not self.proto.shield_max:\\n return 0\\n return self.proto.shield / self.proto.shield_max\",\n \"def percentage_used(self):\\n return self.volume_used/self.total_volume * 100.0\",\n \"def percent(self):\\r\\n return self._percent\",\n \"def get_percent_wet():\\n # Create an ADS1115 ADC (16-bit) instance.\\n adc = Adafruit_ADS1x15.ADS1115()\\n\\n GAIN = 1\\n DRY = 20280 # 100% Dry\\n WET = 10140 # 100% Wet\\n\\n value = adc.read_adc(0, gain=GAIN)\\n \\n # print \\\"value: %d\\\" % value\\n \\n percent_dry = ((value - WET)*100)/(DRY-WET)\\n percent_wet = 100 - percent_dry\\n\\n return percent_wet\",\n \"def percent(value, total):\\n if total:\\n return float(value) * 100.0 / float(total)\\n else:\\n return 100.0\",\n \"def __calc_s(self, df):\\n df.loc[:, \\\"avg_num_drivers\\\"] = df.idle + df.incoming\\n s = df.total / df.avg_num_drivers # df.total := amount of demand\\n s[s > 1] = 1\\n s[np.isnan(s)] = 0.0001\\n s[np.isinf(s)] = 1\\n\\n df.loc[:, \\\"prob_of_s\\\"] = s\\n df = df[[\\\"zone_id\\\", \\\"prob_of_s\\\"]]\\n return df\",\n \"def pulse_width_percent(self) -> float:\",\n \"def _percent(self, lines_total, lines_covered):\\n\\n if lines_total == 0:\\n return '0.0'\\n return str(float(float(lines_covered) / float(lines_total)))\",\n \"def percentage(a, b):\\n return (a * 100.0) / b\",\n \"def exceeded_ratio(self) -> float:\\n return self.amount_spent / self.total_amount\",\n \"def calculate_percent(self, total_number, some_number):\\n\\t\\treturn (some_number * 100) / total_number\",\n \"def stealability(self):\\n stealability_score = float(self.price) / float(self.weight)\\n print (stealability_score)\\n\\n if stealability_score < 0.5:\\n return 'Not so stealable...'\\n elif stealability_score >= 0.5 and stealability_score < 1.0:\\n return 'Kinda stealable.'\\n else:\\n return 'Very stealable!'\",\n \"def percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"percentage\\\")\",\n \"def pulsewidth2pct(pw): \\n shifted = pw - 500.0\\n scaled = shifted / 2000.0 * 100.0\\n pct = scaled\\n return pct\",\n \"def calculate_profit(self):\",\n \"def pe_ratio(self):\\n try:\\n return self.price / self.dividend_yield\\n except ZeroDivisionError:\\n return 0.0\",\n \"def abbott_steam():\\n per_klb = 20 # dollars per klb of steam\\n kwh_eq = to_kwh(1) # kwh equivalent of steam\\n per_kwh = per_klb / kwh_eq\\n return per_kwh\",\n \"def get_percentage(self):\\n return self.PotTax_percentage\",\n \"def calculate_probability(self):\\n return 0\",\n \"def calculate_utility(state, player):\\n thisPlayer = player\\n \\n if state.winner() == (not thisPlayer):\\n return -BigInitialValue\\n if state.winner() == thisPlayer:\\n return BigInitialValue\\n return calculate_possible_fours(state, thisPlayer) - calculate_possible_fours(state, not thisPlayer)\",\n \"def percentageChange(self):\\n try:\\n curPrice = self.dailyData[-1].currentPrice\\n closePrice = self.historicData[-1].closePrice\\n except IndexError: # Just return zero when no historic or dailyData is available yet\\n return 0.0\\n return (curPrice - closePrice)/closePrice * 100\",\n \"def percentage(part, whole):\\n return round((100 * float(part)/float(whole)),2)\",\n \"def utility(self, state, player):\\n if state.isWin() or state.isLose():\\n return state.getScore()\\n\\n # In case of cycle.\\n if player == PACMAN:\\n return INFINITY\\n else:\\n return -INFINITY\",\n \"def percent_usage(value, total):\\n if total:\\n return float(value) * 100.0 / (float(total) + float(value))\\n else:\\n return 100.0\",\n \"def calculateSaleReturn(S,R,F,T):\\n if (T > S):\\n return 0\\n\\n if F == 100:\\n return R*T/S\\n\\n return float(R) * ( 1.0 - math.pow(float(S-T)/float(S) , (100.0/float(F))))\",\n \"def get_percentage_f_votes(self):\\n\\n votes_f = self.get_num_f_votes()\\n votes_sf = self.get_num_sf_votes()\\n\\n # avoid dividing by zero\\n if votes_f + votes_sf == 0:\\n return 0\\n else:\\n ratio = float(votes_f)/(votes_f + votes_sf)\\n return round(ratio * 100, 1)\",\n \"def do_damage(self) -> float:\\n sum = 0\\n for operator in self.__operators:\\n if operator.is_alive:\\n operator.experience += 1\\n sum += operator.experience / 100\\n return 0.1 + sum\",\n \"def percent(obj,object2):\\n if object2:\\n return int(float(int(obj))/object2*100)\\n else:\\n return 0\",\n \"def calculate_my_win_strength(self):\\n self.winStrength = self.strategy(deepcopy(self.currentBoardState))\",\n \"def set_total_reb_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n player_rebounds = bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"]\\n team_rebounds = team[\\\"reb_def\\\"] + team[\\\"reb_of\\\"]\\n opp_team_rebounds = opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((player_rebounds * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team_rebounds + opp_team_rebounds)))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def do_damage(self) -> float:\\n res = 0.05 + self.experience / 100\\n self.experience = self.experience + 1\\n return res\",\n \"def percentage(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"percentage\\\")\",\n \"def value(self, board, current_player, opposite_player):\\n my_fours = self.check_for_streak(board, current_player, 4)\\n my_threes = self.check_for_streak(board, current_player, 3)\\n my_twos = self.check_for_streak(board, current_player, 2)\\n opp_fours = self.check_for_streak(board, opposite_player, 4)\\n if opp_fours > 0:\\n return -100000\\n else:\\n return my_fours*100000 + my_threes*100 + my_twos\",\n \"def per(a):\\n return a * 100\",\n \"def get_song_percent_remaining(result):\\n return int((1 - (get_song_elapsed_milliseconds(result) / get_song_length_milliseconds(result))) * 100)\",\n \"def percentage(self) -> str:\\n return ranged_value_to_percentage(\\n self._device.fan_speed_limits, self._device.fan_speed\\n )\",\n \"def total_rewards(self) -> float:\\n return self.__total_rewards\",\n \"def percentCheck(currentTimeLabel, totalTimeLabel):\\n # Updated 11/19/16\\n try:\\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\\n except (ValueError , ZeroDivisionError):\\n progPercent = 0\\n \\n return progPercent\",\n \"def set_tichu_percentage(threshold):\\n tichu_threshold = threshold\\n tichu_cnt = 0\\n deck = Deck()\\n players = [Player(id=0), Player(id=1), Player(id=2), Player(id=3)]\\n for i in range(100):\\n myhands = deck.shuffle_and_deal()\\n for idx in range(4):\\n players[idx].assign_hand(myhands[idx])\\n score = players[idx].hand_rating\\n if score > tichu_threshold:\\n tichu_cnt += 1\\n players[idx].hand.show()\\n print('Player calls Tichu with a hand rating of {:.1f}.'.format(score))\\n print('\\\\n')\\n print('Tichu percentage: {:.2f}'.format(tichu_cnt/100))\",\n \"def calculate_progress_percentage(d):\\n successcounter = 0\\n for test in d:\\n if d[test][\\\"status\\\"] != \\\"not yet run\\\":\\n successcounter += 1\\n totalcounter = 0\\n for test in d:\\n totalcounter += 1\\n return int(successcounter / totalcounter * 100)\",\n \"def rate(self) -> float:\\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0\",\n \"def percentWinMult(percentWin, mult):\\n if mult == 2:\\n #increase percentage by a bit\\n return percentWin - 0.08\\n elif mult == 4:\\n return percentWin - 0.04\\n else:\\n return percentWin - (mult/1000)\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def hero_healing_per_min(self):\\n return self._hero_healing_per_min\",\n \"def set_effective_field_goal_percentage(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tcConv = float(bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"])\\n result = 0.00\\n if tcInt > 0:\\n result = ((tcConv + (0.5 * float(bx[\\\"t3p_conv\\\"]))) / tcInt) * 100\\n self.effective_field_goal_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def host_result_value(winner: Winner) -> float:\\n if winner == Winner.HOME:\\n return 1\\n if winner == Winner.AWAY:\\n return 0\\n return 0.5\",\n \"def calculateP(SD, numDiff):\\n return numDiff/SD\",\n \"def calculateP(SD, numDiff):\\n return numDiff/SD\",\n \"def _calculate_result(found, total):\\n return (found * 100) / total\",\n \"def calculate_emission_prob(cls, w, t):\\n #\\n # p_w_t = cls._emission_counts[w, t]\\n # p_t = cls._uni_transition_counts[t]\\n\\n return float(cls._emission_counts[w, t] / cls._uni_transition_counts[t])\",\n \"def effectivedb_size_percentage(self):\\n if self._vsanobj.id is None:\\n raise VsanNotPresent(\\\"Vsan \\\" + str(self._vsanobj._id) + \\\" is not present on the switch.\\\")\\n out = self.__show_zone_status()\\n retout = out.get(get_key(zonekeys.EFFDB_PER, self._SW_VER), None)\\n if retout is not None:\\n return str(retout) + \\\"%\\\"\\n return None\",\n \"def calculate(self) -> float:\",\n \"def playerrawdmg(self):\\n playerstr = globalvalues.p1.getstrength()\\n # see combatvaluetable.xlsx to see some possible values of\\n # playerrawdamage. Base formula is below:\\n #\\n rawdmg = int((playerstr - 4) * 102 * 0.32)\\n\\n # Things that will deviate the amount of damage done.\\n level = globalvalues.p1.getlevel() - globalvalues.ai.getstatus()[0]\\n modvalue = float(1 + level * 0.05)\\n rngfactor = float(1 + float(random.randint(85, 105)) / 100)\\n\\n return int(rawdmg * modvalue * rngfactor)\",\n \"def percentage_change(old_value, new_value):\\n\\n result = float(100 * (new_value - old_value) / old_value)\\n\\n return result\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def health_percentage(self) -> Union[int, float]:\\n if not self.proto.health_max:\\n return 0\\n return self.proto.health / self.proto.health_max\",\n \"def health_percentage(self) -> Union[int, float]:\\n if not self.proto.health_max:\\n return 0\\n return self.proto.health / self.proto.health_max\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6973858","0.68804467","0.68694776","0.6837882","0.6696774","0.65600723","0.6460961","0.6452967","0.64353186","0.6403429","0.6403429","0.6369753","0.6368016","0.63537014","0.63537014","0.63495165","0.6336215","0.632231","0.62704694","0.6268536","0.6268536","0.6254428","0.6247955","0.6245096","0.62445295","0.62402153","0.62060624","0.6184223","0.61820304","0.61702466","0.6142152","0.6132354","0.6111506","0.6107117","0.6100469","0.605308","0.6049747","0.6041493","0.60408485","0.6017065","0.60161644","0.6013737","0.6000771","0.6000771","0.59895474","0.5989106","0.5988089","0.59849375","0.5980745","0.597904","0.59272516","0.591619","0.59120876","0.59110737","0.5907079","0.5906812","0.5903063","0.59011483","0.59008044","0.5900661","0.58983564","0.5897182","0.5894933","0.5878522","0.58627117","0.58596164","0.5855341","0.5850596","0.58428746","0.58392054","0.58179814","0.5810939","0.58104855","0.58061993","0.58019394","0.5795628","0.5781964","0.57778084","0.57708776","0.57687443","0.5763945","0.576002","0.5757731","0.5753007","0.5752791","0.57383066","0.57375306","0.5713636","0.5711137","0.5709597","0.5709597","0.5704546","0.5698478","0.5696937","0.56958026","0.5695302","0.56939775","0.56873477","0.5686056","0.5686056"],"string":"[\n \"0.6973858\",\n \"0.68804467\",\n \"0.68694776\",\n \"0.6837882\",\n \"0.6696774\",\n \"0.65600723\",\n \"0.6460961\",\n \"0.6452967\",\n \"0.64353186\",\n \"0.6403429\",\n \"0.6403429\",\n \"0.6369753\",\n \"0.6368016\",\n \"0.63537014\",\n \"0.63537014\",\n \"0.63495165\",\n \"0.6336215\",\n \"0.632231\",\n \"0.62704694\",\n \"0.6268536\",\n \"0.6268536\",\n \"0.6254428\",\n \"0.6247955\",\n \"0.6245096\",\n \"0.62445295\",\n \"0.62402153\",\n \"0.62060624\",\n \"0.6184223\",\n \"0.61820304\",\n \"0.61702466\",\n \"0.6142152\",\n \"0.6132354\",\n \"0.6111506\",\n \"0.6107117\",\n \"0.6100469\",\n \"0.605308\",\n \"0.6049747\",\n \"0.6041493\",\n \"0.60408485\",\n \"0.6017065\",\n \"0.60161644\",\n \"0.6013737\",\n \"0.6000771\",\n \"0.6000771\",\n \"0.59895474\",\n \"0.5989106\",\n \"0.5988089\",\n \"0.59849375\",\n \"0.5980745\",\n \"0.597904\",\n \"0.59272516\",\n \"0.591619\",\n \"0.59120876\",\n \"0.59110737\",\n \"0.5907079\",\n \"0.5906812\",\n \"0.5903063\",\n \"0.59011483\",\n \"0.59008044\",\n \"0.5900661\",\n \"0.58983564\",\n \"0.5897182\",\n \"0.5894933\",\n \"0.5878522\",\n \"0.58627117\",\n \"0.58596164\",\n \"0.5855341\",\n \"0.5850596\",\n \"0.58428746\",\n \"0.58392054\",\n \"0.58179814\",\n \"0.5810939\",\n \"0.58104855\",\n \"0.58061993\",\n \"0.58019394\",\n \"0.5795628\",\n \"0.5781964\",\n \"0.57778084\",\n \"0.57708776\",\n \"0.57687443\",\n \"0.5763945\",\n \"0.576002\",\n \"0.5757731\",\n \"0.5753007\",\n \"0.5752791\",\n \"0.57383066\",\n \"0.57375306\",\n \"0.5713636\",\n \"0.5711137\",\n \"0.5709597\",\n \"0.5709597\",\n \"0.5704546\",\n \"0.5698478\",\n \"0.5696937\",\n \"0.56958026\",\n \"0.5695302\",\n \"0.56939775\",\n \"0.56873477\",\n \"0.5686056\",\n \"0.5686056\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77550447"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3095,"cells":{"query":{"kind":"string","value":"Method which calculate Effective Field Goal (eTC) of a player"},"document":{"kind":"string","value":"def set_effective_field_goal_percentage(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tcConv = float(bx[\"t2p_conv\"] + bx[\"t3p_conv\"])\n result = 0.00\n if tcInt > 0:\n result = ((tcConv + (0.5 * float(bx[\"t3p_conv\"]))) / tcInt) * 100\n self.effective_field_goal_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getETA():","def getETA():","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def calculate_utility(state, player):\n thisPlayer = player\n \n if state.winner() == (not thisPlayer):\n return -BigInitialValue\n if state.winner() == thisPlayer:\n return BigInitialValue\n return calculate_possible_fours(state, thisPlayer) - calculate_possible_fours(state, not thisPlayer)","def other(player):\n return 1 - player","def other(player):\n return 1 - player","def other(player):\n return 1 - player","def calculate_titer(self):\n reactor = self.reactor\n (reactor.specification or reactor._run)()\n effluent = self.effluent\n # F_mass_products = effluent.imass[self.products].sum()\n # if F_mass_products: \n # return F_mass_products / effluent.F_vol\n # else:\n # return 0.\n return reactor.effluent_titer","def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\n phi = 0.0\n\n ## Approach A - NREL Approach\n if approach_call == \"A\":\n\n phi = float(Q_load_W) / float(Q_design_W)\n eta_max = 0.425 # from energy.gov\n\n if phi >= phi_threshold: # from NREL-Shape\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\n\n if phi < phi_threshold:\n if phi <= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\n\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3.0 + \\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\n\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\n\n eta_therm_max = 0.45 # constant, after energy.gov\n\n if phi < phi_threshold:\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\n\n else:\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\n\n ## Approach B - Empiric Approach\n if approach_call == \"B\":\n\n if Q_design_W > 0:\n phi = float(Q_load_W) / float(Q_design_W)\n\n else:\n phi = 0\n\n eta_el_max = 0.39\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\n\n eta_el = eta_el_max * eta_el_score\n eta_therm = eta_therm_max * eta_therm_score\n\n if phi < 0.2:\n eta_el = 0\n\n return eta_el, eta_therm","def e(p, reported, recount):\n return t(p, reported) - t(p, recount)","def heuristic_2_reflection(game, player) -> float:\n\n reflection_available_factor = get_reflection_available_factor(game, player)\n\n return float(reflection_available_factor)","def PV_BenefitDeath(t):\n if t > last_t:\n return 0\n else:\n return (-prj_bnft_Death(t) + PV_BenefitDeath(t + 1)) / (1 + DiscRate(t))","def getEta(self):\n self.__eta = 3./8.*(1. - self.__alpha0 - self.__alpha1 - 2.*self.__beta)\n if self.__eta<0.: self.__eta=0. # erreur d'arrondi\n return self.__eta","def hit_stand_ev_diff(hand, shoe, dealer_hand, dealer_probabilities):\n dealer_end_probs = dealer_probabilities[dealer_hand]\n # maps a player's hand to his or her (hit_ev, stand_ev, max_ev)\n player_payoffs = get_player_payoff(dealer_end_probs)\n\n ev = 0 # contains weighted ev\n total = 0 # contains total weights, to normalized at the end\n val, hard = hand\n for card in shoe:\n weight = shoe[card] # number of a card in the shoe\n total += weight\n if hard and 11 <= val <= 21:\n new_hand = (val + card, hard)\n if new_hand[0] > 21:\n ev -= weight # default loss\n else:\n ev += weight * player_payoffs[new_hand][-1]\n elif not hard and 12 <= val <= 21:\n new_val = val + card\n new_hard = False\n if new_val > 21: # go back to hard value, take A = 1\n new_val -= 10\n new_hard = True\n ev += weight * player_payoffs[(new_val, new_hard)][-1]\n elif hard and 4 <= val <= 10:\n new_val = val + card\n new_hard = True\n if card == 1: # go to soft value, take A = 11\n new_val += 10\n new_hard = False\n ev += weight * player_payoffs[(new_val, new_hard)][-1]\n else:\n raise RuntimeError(\"Should not get here: \" + str(hand))\n return (1.0 * ev / total) - player_payoffs[hand][1] # hit ev - stand ev","def U_Function(currentPlayer, oppositePlayer, N, maxEntity):\n EndPointPlayer1 = Posisi.Posisi(N - 1, N - 1)\n EndPointPlayer2 = Posisi.Posisi(0, 0)\n \n sumPionPlayer1 = 0\n sumPionPlayer2 = 0\n\n if (currentPlayer.noPlayer == 1):\n for Pion in currentPlayer.arrayPion:\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\n for Pion in oppositePlayer.arrayPion:\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\n \n if (currentPlayer.noPlayer == 2):\n for Pion in currentPlayer.arrayPion:\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\n for Pion in oppositePlayer.arrayPion:\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\n\n if (maxEntity == 1):\n return -sumPionPlayer1 + sumPionPlayer2\n else:\n return -sumPionPlayer2 + sumPionPlayer1","def airfoilEffT(self):\n return float(Importer(Component='Evaluations',\n VariableName='Wing airfoil efficiency factor',\n Default=.95,\n Path=self.filePath).getValue)","def material_advantage(state, player):\n ma = 0\n if player == cc.WHITE_ACTIVE:\n white_factor = 1\n black_factor = -1\n else:\n white_factor = -1\n black_factor = 1\n \n for rank in range(8):\n for column in range(8):\n piece = state.board[rank, column]\n if piece == cc.NO_PIECE:\n continue\n elif piece in cc.WHITE_PIECES:\n if piece == cc.W_PAWN:\n ma += white_factor * cc.MA_PAWN\n elif piece == cc.W_KNIGHT:\n ma += white_factor * cc.MA_KNIGHT\n elif piece == cc.W_BISHOP:\n ma += white_factor * cc.MA_BISHOP\n elif piece == cc.W_ROOK:\n ma += white_factor * cc.MA_ROOK\n elif piece == cc.W_QUEEN:\n ma += white_factor * cc.MA_QUEEN\n elif piece == cc.W_KING:\n ma += white_factor * cc.MA_KING\n elif piece in cc.BLACK_PIECES:\n if piece == cc.B_PAWN:\n ma += black_factor * cc.MA_PAWN\n elif piece == cc.B_KNIGHT:\n ma += black_factor * cc.MA_KNIGHT\n elif piece == cc.B_BISHOP:\n ma += black_factor * cc.MA_BISHOP\n elif piece == cc.B_ROOK:\n ma += black_factor * cc.MA_ROOK\n elif piece == cc.B_QUEEN:\n ma += black_factor * cc.MA_QUEEN\n elif piece == cc.B_KING:\n ma += black_factor * cc.MA_KING\n return ma","def custom_score(game, player):\n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the improved score\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n improved = len(player_legal_moves) - len(opponent_legal_moves)\n if improved != 0:\n return float(improved)\n \n # Second get differences from center\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n player_coordinates = game.get_player_location(player)\n opponent_coordinates = game.get_player_location(opponent)\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\n center_dist_diff = player_center_dist - opponent_center_dist\n \n # Third obtain next_moves\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \n improved_next = len(player_next_moves) - len(opponent_next_moves)\n \n # Put player and opponent feature differences in a tuple/vector surrogoate\n feature_diff_vector = (improved, center_dist_diff, improved_next)\n \n # Provide a weighting vector for the features of each player-participant\n weight_vector = (1.5,0.1,1.0)\n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(feature_diff_vector, weight_vector))\n \n return float(weighted_difference_dot_product)","def calc_ertelPV(n2, bx, rel_vorticity, g=9.8,f=-1e-4):\n\n # vertical component\n\n qvert = (f+rel_vorticity)*n2\n\n # baroclinic component\n qbc = -bx**2/f\n\n # Ertel PV\n\n ertelPV = qvert + qbc\n\n # If PV is unstable\n fq = ertelPV*f # fq > 0 stable\n\n return ertelPV, qvert, qbc, fq","def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum","def KentFosterII_calc(TP, FP, FN, TN):\n try:\n part1 = ((TN + FP) * (TN + FN)) / (TN + FP + FN)\n return (TN - part1) / (TN - part1 + FP + FN)\n except Exception:\n return \"None\"","def gtf(self):\n\t #if tank is empty, conductance is 0\n\t if self.tx <= 0:\n\t return 0.\n\t\t#returns 0.5, as a function of TAI\n\t else:\n\t return 0.5","def evaluate(game, player):\n weights = [2, 200, 2000, 20000]\n reward = 0\n opponent = get_opponent(player)\n for length in range(2, 6):\n reward += weights[length - 2] * get_num_series(game, player, length)\n reward -= weights[length - 2] * get_num_series(game, opponent, length)\n return reward","def compute_uct(self):\n if self.visits != 0:\n return - self.reward / self.visits + self.C * math.sqrt(math.log(self.parent.visits) / self.visits)\n else:\n return float('inf')","def calculate_advantage(stage_0, stage_1):\n # Improvement in hp difference is good.\n hp_pct_0 = (float(stage_0.friendly_life)/MAX_FRIENDLY_LIFE) - (float(stage_0.enemy_life)/MAX_ENEMY_LIFE)\n hp_pct_1 = (float(stage_1.friendly_life)/MAX_FRIENDLY_LIFE) - (float(stage_1.enemy_life)/MAX_ENEMY_LIFE)\n return hp_pct_1 - hp_pct_0","def fermi(E,mu,T):\n if (E-mu)/T > 600:\n f=0\n\t\t\t\t\n else:\n f=1/(math.exp((E-mu)/(kB*T) )+1)\n return(f)","def Eg_fct_T(Eg0,alpha,beta,T) :\n return Eg0-((T*T*alpha*1e-3)/(beta+T))","def energy_func(self):\n i = self.inl[0].to_flow()\n o = self.outl[0].to_flow()\n\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\n\n iam = (\n 1 - self.iam_1.val * abs(self.aoi.val) -\n self.iam_2.val * self.aoi.val ** 2)\n\n return (i[0] * (o[2] - i[2]) -\n self.A.val * (\n self.E.val * self.eta_opt.val * self.doc.val ** 1.5 * iam -\n (T_m - self.Tamb.val_SI) * self.c_1.val -\n self.c_2.val * (T_m - self.Tamb.val_SI) ** 2))","def calc_ev(p1_strat, p2_strat, cards, history, active_player):\n if KuhnPoker.is_terminal(history):\n return -KuhnPoker.get_payoff(history, cards)\n my_card = cards[active_player]\n next_player = (active_player + 1) % 2\n if active_player == 0:\n strat = p1_strat[my_card + history]\n else:\n strat = p2_strat[my_card + history]\n return -np.dot(strat, [calc_ev(p1_strat, p2_strat, cards, history + a, next_player) for a in KUHN_ACTIONS])","def eval_func(self, game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n \n if game.is_winner(player):\n return float(\"inf\")\n \n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n if game.move_count < ((game.height * game.width)/2):\n return float(self.weights[0] * own_moves - \n self.weights[1] * opp_moves - \n self.weights[2] * __distance_from_center__(game, player))\n else:\n return float(self.weights[3] * own_moves - \n self.weights[4] * opp_moves - \n self.weights[5] * __distance_from_center__(game, player))","def energy(e: float) -> float:\n\n return (1/np.sqrt(2))*(gamma(-e/2+1/2)/(gamma(-e/2+3/4)))","def _fv(self):\n return self.beta * (self.x ** self.c)","def compute_utility(self, board, move, player):\n r_alive = 0\n b_alive = 0\n rk_alive = 0\n bk_alive = 0\n for line in range(8):\n for col in range(8):\n if board[line][col] == \"R\":\n r_alive += 1\n elif board[line][col] == \"B\":\n b_alive += 1\n elif board[line][col] == \"RK\":\n rk_alive += 1\n elif board[line][col] == \"BK\":\n bk_alive += 1\n # if r_Alive > b_Alive:\n # if b_Alive == 0:\n # return 1\n # else: return 0\n # elif r_Alive == 0:\n # return -1\n powkings = 1.2\n result = 0\n if player == 'B':\n result = rk_alive*powkings + r_alive - bk_alive*powkings - b_alive\n else:\n result = bk_alive*powkings + b_alive - rk_alive*powkings - r_alive\n return result","def heuristic_combined_2_3(game, player) -> float:\n\n reflection_available_factor = get_reflection_available_factor(game, player)\n partition_possible_factor = get_partition_possible_factor(game, player)\n\n return float(reflection_available_factor + partition_possible_factor)","def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res","def get_cost(self) -> float:\n return math.e / self.fitness","def calculate(self) -> float:","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n agreement = tp + tn\n chance0 = (tn + fn) * (tn + fp)\n chance1 = (fp + tp) * (fn + tp)\n sum_ = tn + fn + fp + tp\n chance = (chance0 + chance1) / sum_\n\n return (agreement - chance) / (sum_ - chance)","def compute_efftime(table,\n kterm=0.114, # KERM\n ebv_r_coeff=2.165,\n fiber_diameter_arcsec=1.52):\n\n exptime = table[\"EXPTIME\"]\n skymag = table[\"SKY_MAG_R_SPEC\"]\n sky = 10**(-0.4*(skymag-22.5)) # nMgy/arcsec**2\n ebv = table[\"EBV\"]\n transparency = table[\"TRANSPARENCY_GFA\"]\n airmass = table[\"AIRMASS\"]\n fiberfac_psf = table[\"FIBERFAC_GFA\"] # fiber_frac * transparency normalized to 1 for nominal conditions\n fiberfac_elg = table[\"FIBERFAC_ELG_GFA\"] # fiber_frac * transparency normalized to 1 for nominal conditions\n fiberfac_bgs = table[\"FIBERFAC_BGS_GFA\"] # fiber_frac * transparency normalized to 1 for nominal conditions\n\n fiber_fracflux_bgs = table[\"FIBER_FRACFLUX_BGS_GFA\"] # fraction of light down fiber\n fiber_fracflux_psf = table[\"FIBER_FRACFLUX_GFA\"]\n\n exptime_nom = 1000.0 # AR seconds\n sky_nom = 3.73 # AR nMgy/arcsec**2\n flux_bright_nom = 15.8 # nMgy (r=19.5 mag for de Vaucouleurs rhalf=1.5\" BGS)\n flux_backup_nom = 27.5 # nMgy (r=18.9 mag star)\n\n # AR airmass term\n airfac = 10.0 ** (kterm * (airmass - 1.0) / 2.5)\n # AR ebv term\n ebvfac = 10.0 ** (ebv_r_coeff * ebv / 2.5)\n # AR sky readnoise\n sky_rdn = 0.932 # AR nMgy/arcsec**2\n\n # AR \"limit\" fiber flux\n fiber_area_arcsec2 = np.pi*(fiber_diameter_arcsec/2)**2\n\n # flux in fiber artificially divided by fiber_area_arcsec2 because the sky flux is per arcsec2\n fflux_bright = flux_bright_nom * transparency * fiber_fracflux_bgs / airfac / ebvfac / fiber_area_arcsec2\n fflux_backup = flux_backup_nom * transparency * fiber_fracflux_psf / airfac / ebvfac / fiber_area_arcsec2\n\n # AR effective sky\n effsky_dark = (sky + sky_rdn * exptime_nom / exptime) / (1.0 + sky_rdn / sky_nom)\n effsky_bright = (sky + sky_rdn * exptime_nom / exptime + fflux_bright) / (\n 1.0 + sky_rdn / sky_nom + fflux_bright / sky_nom\n )\n effsky_backup = (sky + sky_rdn * exptime_nom / exptime + fflux_backup) / (\n 1.0 + sky_rdn / sky_nom + fflux_backup / sky_nom\n )\n # AR effective exposure time\n efftime_dark = (\n exptime\n * (fiberfac_elg / airfac) ** 2\n * (sky_nom / effsky_dark)\n / ebvfac ** 2\n )\n efftime_bright = (\n exptime\n * (fiberfac_bgs / airfac) ** 2\n * (sky_nom / effsky_bright)\n / ebvfac ** 2\n )\n efftime_backup = (\n exptime\n * (fiberfac_psf / airfac) ** 2\n * (sky_nom / effsky_backup)\n / ebvfac ** 2\n )\n\n # set to -1 values with incorrect inputs\n bad=table[\"AIRMASS\"]<0.99\n bad |=(table[\"FIBER_FRACFLUX_GFA\"]==0)\n bad |=(table[\"TRANSPARENCY_GFA\"]>2)\n efftime_dark[bad]=0.\n efftime_bright[bad]=0.\n efftime_backup[bad]=0.\n\n return efftime_dark , efftime_bright , efftime_backup","def getReward (events_counters):\n global P_0, P_1, C_0, C_1, C_2 \n return (P_0 - C_0) * events_counters[0] - (C_0 + C_1) * events_counters[1] - (\n C_2 * events_counters[2] - P_1 * events_counters[3])","def custom_score_3(game, player):\n \n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n player_legal_move_count, opponent_legal_move_count = \\\n len(player_legal_moves), len(opponent_legal_moves)\n move_count_difference = player_legal_move_count - opponent_legal_move_count\n # Find coordinates of center box\n h, w = get_center_coordinates(game)\n # Retrieve player's coordinates\n y, x = game.get_player_location(player)\n # Obtain coordinate further, closest to origin\n furthest_coord, closest_coord = max(h - y, w -x), min(h - y, w - x)\n # Return weighted, vector-valued length from origin / sum of weights\n weighted_distance_from_center = \\\n math.sqrt((closest_coord**2 + 2*(furthest_coord**2)))/3\n feature_vector = (move_count_difference, weighted_distance_from_center)\n \n weight_vector = (1.0,0.1)\n \n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(weight_vector, feature_vector)) \n \n return float(weighted_difference_dot_product)","def determineAmountToCall(self, player):\n\t\treturn sum(self.currentBet) - sum(player.betAmount)","def acceleration(v,u,t):\n return ((v-u)/t)","def KentFosterI_calc(TP, FP, FN, TN):\n try:\n part1 = ((TP + FP) * (TP + FN)) / (TP + FP + FN)\n return (TP - part1) / (TP - part1 + FP + FN)\n except Exception:\n return \"None\"","def vanilaScore(self,attended,state,W):","def heuristic_combined_1_2(game, player) -> float:\n\n center_available_factor = get_center_available_factor(game, player)\n reflection_available_factor = get_reflection_available_factor(game, player)\n\n return float(center_available_factor + reflection_available_factor)","def get_delta_v_tot(f, e, a, P):\n\n coeff = (2.0*np.pi/P) * a / np.sqrt(1.0 - e*e)\n delta_v_tot = coeff * (1.0 + 2.0*e*np.cos(f) + e*e) / 1.0e5\n\n return delta_v_tot","def time_elapsed(session, player):\n #TODO (also needs to be added to bot logic)","def self_energy(gf_imp0, gf_imp):\n return 1/gf_imp0 - 1/gf_imp","def cal_eta(self):\n\n if not self.check_def(['E','px','py','pz']):\n sys.exit('Particle error: Quadri impulsion not define (error for eta routine)')\n \n theta=math.acos(self.pz/math.sqrt(self.px**2+self.py**2+self.pz**2))\n self.eta=-math.log(math.tan(theta/2.0))","def advancedStats():","def report_result(force_a_before, force_b_before, force_a_after, force_b_after):\n damage_a = 0.0\n damage_b = 0.0\n ################################# YOUR CODE HERE #################################\n damage_a = calculate_training_cost(force_a_before) - calculate_training_cost(force_a_after)\n damage_b = calculate_training_cost(force_b_before) - calculate_training_cost(force_b_after)\n ##################################################################################\n return damage_a, damage_b","def energy_func(self):\n i = self.inl[0].to_flow()\n o = self.outl[0].to_flow()\n\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\n\n return (i[0] * (o[2] - i[2]) -\n self.A.val * (\n self.E.val * self.eta_opt.val -\n (T_m - self.Tamb.val_SI) * self.lkf_lin.val -\n self.lkf_quad.val * (T_m - self.Tamb.val_SI) ** 2))","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the base information to calculate player & opponent\n # feature values\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n if len(player_legal_moves) != len(opponent_legal_moves):\n return float(len(player_legal_moves) - len(opponent_legal_moves))\n \n # Get_center_coordinates and opponent. Then set the list of participants\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n participants = [player, opponent]\n \n # Then, for each participant obtain his/her feature values \n for participant in participants:\n if participant == player:\n p_legal_moves = player_legal_moves\n player_either = player\n participant_coordinates = p_y, p_x = \\\n game.get_player_location(participant)\n player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, \\\n player_path_count, player_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either,participant_coordinates, p_legal_moves)\n else:\n p_legal_moves = opponent_legal_moves\n player_either = opponent\n participant_coordinates = p_y, p_x \\\n = game.get_player_location(participant)\n opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, opponent_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either, participant_coordinates, p_legal_moves)\n \n # Place each participant's feature values in a tuple/vector surrogate \n pro_player_vector = \\\n (player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, player_path_count, \\\n opponent_min_center_diff)\n pro_opponent_vector = \\\n (opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, player_min_center_diff)\n \n # Provide a weighting vector for the features \n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\n \n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\n \n return float(weighted_difference_dot_product)","def cost(self) -> float:","def value(self, board, current_player, opposite_player):\n my_fours = self.check_for_streak(board, current_player, 4)\n my_threes = self.check_for_streak(board, current_player, 3)\n my_twos = self.check_for_streak(board, current_player, 2)\n opp_fours = self.check_for_streak(board, opposite_player, 4)\n if opp_fours > 0:\n return -100000\n else:\n return my_fours*100000 + my_threes*100 + my_twos","def _evaluate_electric(snapshot, params):\n positions = snapshot.particles.position\n charges = snapshot.particles.charge\n E_field = params\n energies = -charges * np.dot(positions, E_field)\n forces = np.outer(charges, E_field)\n return forces, energies","def act(self, image, player_info):\n action = {'acceleration': 1, 'brake': False, 'drift': False, 'nitro': False, 'rescue': False, 'steer': np.random.uniform(-1,1)}\n \"\"\"\n Your code here.\n \"\"\"\n\n return action","def playerdefeated(self):\n globalvalues.gameover_combat()","def eta_details(self):\n\t\t# Experimentation gives you 72pts to a random science every production\n\t\t# Stupid brute force implementation for now\n\t\trequired = self.required\n\t\trate = self.player.science\n\t\tdef combine(base, add, add_time, chance):\n\t\t\t# add given add into base with +add_time tick and modified by chance\n\t\t\tfor time, p in add.items():\n\t\t\t\ttime += add_time\n\t\t\t\tp *= chance\n\t\t\t\tbase[time] = base.get(time, 0) + p\n\t\tdef _eta_details(value, time_to_prod=self.galaxy.production_rate):\n\t\t\tnaive_eta = max(0, int(math.ceil((required - value)/rate)))\n\t\t\tif naive_eta <= time_to_prod: return {naive_eta: 1}\n\t\t\tbase = {}\n\t\t\twithout_extra = _eta_details(value + rate*time_to_prod)\n\t\t\twith_extra = _eta_details(value + rate*time_to_prod + 72)\n\t\t\tcombine(base, without_extra, time_to_prod, 6/7.)\n\t\t\tcombine(base, with_extra, time_to_prod, 1/7.)\n\t\t\treturn base\n\t\treturn _eta_details(self.current, self.galaxy.production_rate - self.galaxy.production_counter)","def _compute_f(self, p, dh, dv):\n return dh / (self.beta * p * dv)","def betterEvaluationFunction(currentGameState):\n \"*** YOUR CODE HERE ***\"\n pacmanPos = currentGameState.getPacmanPosition()\n\n food = currentGameState.getFood()\n capsules = currentGameState.getCapsules()\n return currentGameState.getScore() - 10 * capsuleDistancePlan(pacmanPos, capsules) - foodDistPlan(pacmanPos, food)","def calculate(self):\n\n tp = self.confusion_matrix.tp\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n return 1 - abs(fn - fp) / (2 * tp + fn + fp)","def delta_energy(atom,layer1,layer2):\n global r,c,h\n return float('%.2E' % Decimal(str(r*((atom**2/layer1**2)-(atom**2/layer2**2)))))","def betterEvaluationFunction(currentGameState):\n \"*** YOUR CODE HERE ***\"\n \n newPos = currentGameState.getPacmanPosition()\n newFood = currentGameState.getFood()\n newGhostStates = currentGameState.getGhostStates()\n GhostLocs = currentGameState.getGhostPositions()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n capsuleLocations = currentGameState.getCapsules()\n Hueristic = 0.0\n \n if currentGameState.isWin():\n return 10000\n if currentGameState.isLose():\n return -10000\n\n FoodDistances = []\n foodLocations = newFood.asList()\n for food in foodLocations:\n FoodDistances.append(manhattanDistance(newPos,food))\n closestFood = min(FoodDistances)\n closestFoodLocation = foodLocations[FoodDistances.index(closestFood)]\n\n GhostsToMe = []\n GhostsToFood = []\n for ghost in GhostLocs:\n GhostsToMe.append(manhattanDistance(newPos,ghost))\n GhostsToFood.append(manhattanDistance(closestFoodLocation,ghost))\n closestGhostToMe = min(GhostsToMe)\n closestGhostToClosestFood = min(GhostsToFood)\n closestGhostLocation = GhostLocs[GhostsToMe.index(closestGhostToMe)]\n\n if newPos in currentGameState.getCapsules():\n capsule = 100\n else: \n capsule = 0\n \n if closestGhostToClosestFood < closestFood:\n if closestGhostToMe > 4:\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*50 - (1/closestGhostToMe)*5\n else:\n Hueristic = (-1/closestGhostToMe)*50\n else:\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*50 - (1/closestGhostToMe)*5\n return Hueristic","def get_f_score(self):\n return self.get_g_score() + self.get_h_score()","def pot_energy_morse(r_12, D, alpha,r_e):\n\n potential=float(D)*(((1.0-m.exp(-float(alpha)*(float(r_12)-float(r_e))))**2.0)-1.0)\n return potential","def E(self, t):\n\n\t\tE = self.E0\n\n\t\t# Gaussian pulse shape\n\t\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\n\n\t\t# Instantaneous phase\n\t\tif self.phase:\n\t\t\tE *= np.cos(self.omega*(t-self.t0))\n\n\t\t# Transmition\n\t\tif self.remove_reflected_part and self.domain.D == 0:\n\t\t\tmaterial = self.domain.materials[0]\n\t\t\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\n\n\t\treturn E","def deathSubtractor(self, damage, target, caller):\n target_body = target.db.body\n target_bleed_points = target.db.bleed_points\n target_death_points = target.db.death_points\n\n if target_body and damage:\n body_damage = target_body - damage\n if body_damage < 0:\n damage = abs(body_damage)\n target.db.body = 0\n else:\n target.db.body = body_damage\n damage = 0\n\n if target_bleed_points and damage:\n bleed_damage = target_bleed_points - damage\n if bleed_damage < 0:\n damage = abs(bleed_damage)\n target.db.bleed_points = 0\n target.db.weakness = 1\n else:\n target.db.bleed_points = bleed_damage\n damage = 0\n target.db.weakness = 1\n\n target.msg(\"|430You are bleeding profusely from many wounds and can no longer use any active martial skills.\\n|n\")\n target.location.msg_contents(f\"{target.key} |025is bleeding profusely from many wounds and will soon lose consciousness.|n\")\n\n\n if target_death_points and damage:\n death_damage = target_death_points - damage\n if death_damage < 0:\n damage = abs(death_damage)\n target.db.death_points = 0\n else:\n target.db.death_points = death_damage\n damage = 0\n\n target.msg(\"|300You are unconscious and can no longer move of your own volition.|n\")\n target.location.msg_contents(f\"{target.key} |025does not seem to be moving.|n\")\n\n else:\n pass","def compute(self) -> torch.Tensor:\n return _fbeta_compute(self.true_positives, self.predicted_positives,\n self.actual_positives, self.beta, self.average)","def _decisionFunction(self):\n #THIS IS WHERE THE INTELLIGENT AGENT CODE MAKES DECISION\n #since this is the hand coded extension, I'm just going to hard code some stuff\n #q learning and Sarsa should hopefully do better\n \n #this is some other hand coded stuff that you read in stone's paper\n c1 = 64 #c1 = distance in pixels\n c2 = 2.5#c2 = something to multiply angle by\n c3 = 77 #c3 is the number of pixels you assume are in 5 meteres\n #state variable 7 is distance in pixels from K1 to T1\n if self.stateVariables[7] > c1:\n self._holdBall()\n else:\n passMax = float(\"-Inf\")\n passMaxArg = None\n for i in range(1,3):\n var = (c2 * arccos(self.stateVariables[10+i])) + (self.stateVariables[8+i] / c3)\n \"\"\"\n print(\"var = \", var)\n print(\"stateVariable[\", 10 + i, \"]=\", self.stateVariables[10+i] )\n print(\"arccos of stateVariable[\", 10 + i, \"]=\", arccos(self.stateVariables[10+i]) )\n print(\"stateVariable[\", 8 + i, \"]=\", self.stateVariables[8+i] )\n \"\"\"\n \n if var > passMax:\n passMax = var\n passMaxArg = i\n self._passBall(passMaxArg)","def generate_transE_score(self, hs, ts, r):\n\n all_embeddings = self._get_ego_embeddings()\n h_e = all_embeddings[hs]\n t_e = all_embeddings[ts]\n r_e = self.relation_embedding.weight[r]\n r_trans_w = self.trans_w.weight[r].view(\n self.embedding_size, self.kg_embedding_size\n )\n\n h_e = torch.matmul(h_e, r_trans_w)\n t_e = torch.matmul(t_e, r_trans_w)\n\n kg_score = torch.mul(t_e, self.tanh(h_e + r_e)).sum(dim=1)\n\n return kg_score","def fight(self):\r\n\t\tif self.death():\r\n\t\t\treturn 0\r\n\t\tif self.ctime < 1:\r\n\t\t\tself.ctime += 0.05\r\n\t\telse:\r\n\t\t\tself.ctime = 0\r\n\t\t\tself.hit()","def test_positive_electrode_potential_profile(self):\n\n # TODO: add these when have averages","def TPR(self):\n return _div(self.TP, self.TP + self.FN)","def get_expected_cost(self):","def p_funct(self, yi, p, t): \t\t\n\t\t\n\t\tglobal Cg \n\t\tCg = abs(yi[0])\n\t\tglobal Ch \n\t\tCh = abs(yi[1])\n\t\tglobal tin_g \n\t\ttin_g = abs(yi[2])\n\t\tglobal tin_h \n\t\ttin_h = abs(yi[3])\n\t\t\n\t\ty = state_at(t)\n\t\trisk = 1 - (y[-1][0] + y[-1][3]) / sum(y[-1])\n\t\t\n\t\treturn abs(risk - p)","def compute_utility(board, color):\n player1_score = 0\n player2_score = 0\n\n score = get_score(board)\n if color == 1:\n return score[0] - score[1]\n else:\n return score[1] - score[0]","def etrf_func(et_inst, etr):\n return et_inst / etr","def rhs_fenics(y,t):\n #print \"time: \",t\n uprev.vector()[:]=y\n f.t = t #dolfin needs to know the current time for cos(t)\n uprime_solver.solve()\n return uprime_solution.vector().array()","def evaluate(self):\n # if player has no move, then player lost, -inf or inf depend on who the player is\n # if player has moves, use heuristics.\n \n #checkColorMoves = self.getAvailableMoves(self.colorIndex)\n #otherColorMoves = self.getAvailableMoves(1-self.colorIndex)\n \n checkColorMoves = self.getAvailableMovesPreferLonger(self.colorIndex)\n otherColorMoves = self.getAvailableMovesPreferLonger(1-self.colorIndex)\n\n checkColorPieces = self.getPieceCount(self.colorIndex)\n otherColorPieces = self.getPieceCount(1-self.colorIndex)\n\n #checkColorEdgePieces = self.getEgdePieceCount(self.colorIndex)\n #otherColorEdgePieces = self.getEgdePieceCount(1-self.colorIndex)\n\n if self.player == 'computer':\n if checkColorMoves == 0: #computer doesn't have moves\n return float('-inf')\n elif otherColorMoves == 0: #user doesn't have moves\n return float('inf')\n else:\n #return checkColorPieces - otherColorPieces\n return checkColorMoves - otherColorMoves\n else:\n if checkColorMoves == 0: #user doesn't have moves\n return float('inf')\n elif otherColorMoves == 0: #computer doesn't have moves\n return float('-inf')\n else:\n #return otherColorPieces - checkColorPieces\n return otherColorMoves - checkColorMoves","def calculate(self):\n\n tp = self.confusion_matrix.tp\n tn = self.confusion_matrix.tn\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n n = tp + tn + fp + fn\n e1 = (fn * (fn + 2 * tp) / (tp + fn) + fp * (fp + 2 * tn) / (tn + fp)) / n\n e2 = (fp * (fp + 2 * tp) / (tp + fp) + fn * (fn + 2 * tn) / (tn + fn)) / n\n\n return min(e1, e2)","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def reward(self, player, winning_state):\n if winning_state == \"Tie\":\n return 1\n elif winning_state == \"Resume\":\n return -1\n else:\n if player == \"agent\":\n return 10\n else:\n return -10","def tdew_from_ea(ea):\n return (237.3 * np.log(ea / 0.6108)) / (17.27 - np.log(ea / 0.6108))","def calculate_value(self, hand):\n global FACE_CARDS\n #could refactor the 2 hand possiblities into methods of a Dealer and Player Class\n if hand == \"player\":\n if self.player_hand[-1].value in FACE_CARDS:\n self.player_value += 10\n elif self.player_hand[-1].value == \"A\":\n self.player_value += 11\n self.player_ace_count += 1\n else:\n self.player_value += int(self.player_hand[-1].value)\n\n if self.player_value > 21:\n if self.player_ace_count > self.player_almost_bust:\n #To prevent a Bust, your Ace became a one\n self.player_value -= 10\n self.player_almost_bust += 1\n else:\n self.player_lose()\n elif self.player_value == 21:\n self.blackjack = True\n self.endgame()\n\n elif hand == \"dealer\":\n if len(self.dealer_hand) > 1:\n if self.dealer_hand[-1].value in FACE_CARDS:\n self.dealer_value += 10\n elif self.dealer_hand[-1].value == \"A\":\n self.dealer_value += 11\n self.dealer_ace_count += 1\n else:\n self.dealer_value += int(self.dealer_hand[-1].value)\n\n if self.dealer_value > 21:\n if self.dealer_ace_count > self.dealer_almost_bust:\n #To prevent a Bust, the Dealer's Ace became a one\n self.dealer_value -= 10\n self.dealer_almost_bust += 1\n else:\n self.player_win()\n elif self.dealer_value == 21:\n self.player_lose()","def calculate(self):\n\n tp = self.confusion_matrix.tp\n fp = self.confusion_matrix.fp\n fn = self.confusion_matrix.fn\n\n return tp / (tp + fp + fn)","def KendallTau_calc(TP, FP, FN, TN):\n try:\n n = TP + FP + FN + TN\n return (2 * (TP + TN - FP - FN)) / (n * (n - 1))\n except Exception:\n return \"None\"","def evaluationFunction(self, currentGameState, action):\n # Useful information you can extract from a GameState (pacman.py)\n successorGameState = currentGameState.generatePacmanSuccessor(action)\n newPos = successorGameState.getPacmanPosition()\n newFood = successorGameState.getFood()\n newGhostStates = successorGameState.getGhostStates()\n GhostLocs = successorGameState.getGhostPositions()\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\n capsuleLocations = successorGameState.getCapsules()\n\n \"*** YOUR CODE HERE ***\"\n \"\"\" factors: proximity to food, proximity to ghosts \n \"\"\" \n if successorGameState.isWin():\n return 10000\n if successorGameState.isLose():\n return -10000\n\n FoodDistances = []\n foodLocations = newFood.asList()\n for food in foodLocations:\n FoodDistances.append(manhattanDistance(newPos,food))\n closestFood = min(FoodDistances)\n closestFoodLocation = foodLocations[FoodDistances.index(closestFood)]\n\n\n GhostsToMe = []\n GhostsToFood = []\n for ghost in GhostLocs:\n GhostsToMe.append(manhattanDistance(newPos,ghost))\n GhostsToFood.append(manhattanDistance(closestFoodLocation,ghost))\n closestGhostToMe = min(GhostsToMe)\n closestGhostToClosestFood = min(GhostsToFood)\n closestGhostLocation = GhostLocs[GhostsToMe.index(closestGhostToMe)] \n Hueristic = 0.0\n if closestGhostToClosestFood < closestFood:\n if closestGhostToMe > 5:\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*10 - (1/closestGhostToMe)*5\n else:\n Hueristic = (-1/closestGhostToMe)*10000\n #Ghost is closer to me than nearest food so avoid ghost\n else:\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*10 - (1/closestGhostToMe)*5\n return Hueristic","def _get_reward(self, player_score, opponent_score):\n return player_score - opponent_score","def test_get_team_strength(self):\n pass","def ti_func(self):\n return self.ti.val - self.calc_ti()","def life_value(ship_class, t):\n\n # Read the external CSV file with the coefficient values\n life_coefficients = pd.read_csv(\"life_coefficients.csv\", index_col=0, header=0)\n # Character of construction coefficient\n a = life_coefficients.loc[ship_class, \"character_of_construction\"]\n # Above-water tonnage coefficient\n b = life_coefficients.loc[ship_class, \"above_water_tonnage\"]\n # Q is unity for 14-inch shells\n q = 1\n # Square root of the ratio of total area to area of vitals\n sqrt_r = life_coefficients.loc[ship_class, \"sqrt_area_to_vitals\"]\n # Probability factor (Construction of Fire Effect Tables 1922, p. 31)\n p = (b * t ** (2/3)) / ((b * t ** (2/3)) + 3)\n # Life formula (Construction of Fire Effect Tables 1922, p. 31)\n life = a * (p * sqrt_r) * (b * t ** (1/3))\n return round(life, 2)","def manage_ev(agent, total_power, time_scale):\n # Dismantle the tuple, it was there just for compactness\n total_active_power, total_reactive_power = total_power\n if agent.electrical_vehicle.is_active():\n # If EV is in supply mode, then it acts as an additional battery\n if agent.electrical_vehicle.power_supplier == 1:\n\n # Compute the desired active and reactive powers according to the power demand and\n # the contribution of the EV\n desired_active_power_from_electrical_vehicle = total_active_power * \\\n agent.electrical_vehicle.contribution_active\n desired_reactive_power_from_electrical_vehicle = total_reactive_power * \\\n agent.electrical_vehicle.contribution_reactive\n desired_power_from_electrical_vehicle = np.abs(\n np.complex(desired_active_power_from_electrical_vehicle,\n desired_reactive_power_from_electrical_vehicle))\n\n # Try to get the power out of the EV\n if agent.electrical_vehicle.erogate(power=desired_power_from_electrical_vehicle, time_scale=time_scale):\n # If you manage to get the power that you want, then update the demand\n total_active_power -= desired_active_power_from_electrical_vehicle\n total_reactive_power -= desired_reactive_power_from_electrical_vehicle\n\n # If EV is in charging mode, then it gets power from the grid\n else:\n total_active_power += agent.electrical_vehicle.charge_current * agent.voltage_rating # To be checked (\n # Riccardo)\n agent.electrical_vehicle.charge(current=agent.electrical_vehicle.charge_current, time_scale=time_scale)\n return total_active_power, total_reactive_power","def __toonTrackExp(self, toonId, track):\n # CCC look at next attacks that are the same track, take the max\n # toon track exp and use that for this attack\n toon = self.battle.getToon(toonId)\n if (toon != None):\n toonExpLvl = toon.experience.getExpLevel(track)\n exp = self.AttackExpPerTrack[toonExpLvl]\n if track == HEAL:\n exp = exp * 0.5\n self.notify.debug(\"Toon track exp: \" + str(toonExpLvl) +\n \" and resulting acc bonus: \" + str(exp))\n return exp\n else:\n return 0","def calculate(self):\n\n return 2 * self.confusion_matrix.tp / \\\n (2 * self.confusion_matrix.tp + self.confusion_matrix.fp + self.confusion_matrix.fn)","def effectiveness(self):\n self._effectiveness = 0.20 * self.ANA + 0.20 * self.DAM + 0.20 * self.MOA + 0.20 * self.MFA + 0.20 * self.NOP\n return round(self._effectiveness, 5)","def set_offensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0 and (bx[\"t2p_int\"] + bx[\"t3p_int\"]) > 0:\n fgm = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n fga = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n team_fgm = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n team_fga = team[\"t2p_int\"] + team[\"t3p_int\"]\n team_points = team[\"t2p_conv\"]*2 + team[\"t3p_conv\"]*3 + team[\"tl_conv\"]\n points = bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"]\n\n try:\n qAST = (Decimal(bx[\"minutes\"] / (team[\"minutes\"] / 5)) * (Decimal('1.14') * Decimal((team[\"assists\"] - bx[\"assists\"]) / team_fgm))) + \\\n Decimal((((team[\"assists\"] / team[\"minutes\"]) * bx[\"minutes\"] * 5 - bx[\"assists\"]) / ((team_fgm / team[\"minutes\"]) * bx[\"minutes\"] * 5 - fgm)) * (1 - (bx[\"minutes\"] / (team[\"minutes\"] / 5))))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n qAST = 1\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n qAST = 1\n\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2*(team_fga - fga))) * bx[\"assists\"]\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n ast_part = 0\n\n if bx[\"tl_int\"] > 0:\n ft_part = Decimal(1 - (1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_part = 0\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\"tl_conv\"] / team[\"tl_int\"]))**2) * team[\"tl_int\"] * Decimal('0.4'))\n try:\n team_orb_percentage = Decimal(team[\"reb_of\"] / (team[\"reb_of\"] + ((opp_team[\"reb_def\"] + opp_team[\"reb_of\"]) - opp_team[\"reb_of\"])))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\"tl_int\"] * Decimal('0.4') + team[\"turnovers\"]))\n try:\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_weight = 0\n\n orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage\n\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\n if bx[\"tl_conv\"] > 0:\n ft_x_poss = Decimal((1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_x_poss = Decimal(1 - (bx[\"tl_conv\"] / 1)**2) * Decimal('0.4') * bx[\"tl_int\"]\n try:\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n sc_poss =0\n\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\"turnovers\"]\n\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\"t3p_conv\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\"t3p_conv\"] - bx[\"t3p_conv\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2 * (team_fga - fga))) * bx[\"assists\"]\n except:\n pprod_ast_part = 0\n\n pprod_orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\"tl_conv\"] / team[\"tl_int\"])**2) * Decimal('0.4') * team[\"tl_int\"]))\n try:\n pprod = (pprod_fg_part + pprod_ast_part + bx[\"tl_conv\"]) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n pprod = 0\n\n try:\n result = 100 * (pprod / tot_poss)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n result = 0\n\n # print(\"fgm: \" + str(fgm))\n # print(\"fga: \" + str(fga))\n # print(\"team_fgm: \" + str(team_fgm))\n # print(\"team_fga: \" + str(team_fga))\n # print(\"team_points: \" + str(team_points))\n # print(\"points: \" + str(points))\n # print(\"qAST: \" + str(qAST))\n # print(\"fg_part: \" + str(fg_part))\n # print(\"ast_part: \" + str(ast_part))\n # print(\"ft_part: \" + str(ft_part))\n # print(\"team_scoring_poss: \" + str(team_scoring_poss))\n # print(\"team_orb_percentage: \" + str(team_orb_percentage))\n # print(\"team_play_percentage: \" + str(team_play_percentage))\n # print(\"team_orb_weight: \" + str(team_orb_weight))\n # print(\"orb_part: \" + str(orb_part))\n # print(\"fg_x_poss: \" + str(fg_x_poss))\n # print(\"ft_x_poss: \" + str(ft_x_poss))\n # print(\"sc_poss: \" + str(sc_poss))\n # print(\"tot_poss: \" + str(tot_poss))\n # print(\"pprod_fg_part: \" + str(pprod_fg_part))\n # print(\"pprod_ast_part: \" + str(pprod_ast_part))\n # print(\"pprod_orb_part: \" + str(pprod_orb_part))\n # print(\"pprod: \" + str(pprod))\n # print(\"result: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n\n self.ortg = \"%.2f\" % round(result, 2)\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\n \"\"\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \n using team's formula\"\"\"\n print(BCOLORS.OKBLUE + \"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\" + BCOLORS.ENDC)\n bx = self.get_standard_stats()\n result = round((bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])/self.get_team_possessions(), 2)\n self.ortg = \"%.2f\" % result","def uncertainty_ee(self,e1,e2):\n # reco\n unc = (self._eleRecoWeight[(e1.pt(),e1.eta())][1]/self._eleRecoWeight[(e1.pt(),e1.eta())][0] + \\\n self._eleRecoWeight[(e2.pt(),e2.eta())][1]/self._eleRecoWeight[(e2.pt(),e2.eta())][0])**2\n # id-isolation\n unc += (self._eleIdIsoWeight[(e1.pt(),e1.eta())][1]/self._eleIdIsoWeight[(e1.pt(),e1.eta())][0] + \\\n self._eleIdIsoWeight[(e2.pt(),e2.eta())][1]/self._eleIdIsoWeight[(e2.pt(),e2.eta())][0])**2\n # trigger (approximate)\n unc += (abs(self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1])/ \\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\n unc += ((self._ele8TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][1])/ \\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\n #outcome\n return sqrt(unc)","def score(guess, e, v, per_pixel=False):\n e_guess = surface2im(guess, v)\n cost = (e_guess - e)**2\n if per_pixel:\n cost = torch.average(cost)\n return torch.sum(cost)"],"string":"[\n \"def getETA():\",\n \"def getETA():\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def calculate_utility(state, player):\\n thisPlayer = player\\n \\n if state.winner() == (not thisPlayer):\\n return -BigInitialValue\\n if state.winner() == thisPlayer:\\n return BigInitialValue\\n return calculate_possible_fours(state, thisPlayer) - calculate_possible_fours(state, not thisPlayer)\",\n \"def other(player):\\n return 1 - player\",\n \"def other(player):\\n return 1 - player\",\n \"def other(player):\\n return 1 - player\",\n \"def calculate_titer(self):\\n reactor = self.reactor\\n (reactor.specification or reactor._run)()\\n effluent = self.effluent\\n # F_mass_products = effluent.imass[self.products].sum()\\n # if F_mass_products: \\n # return F_mass_products / effluent.F_vol\\n # else:\\n # return 0.\\n return reactor.effluent_titer\",\n \"def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\\n phi = 0.0\\n\\n ## Approach A - NREL Approach\\n if approach_call == \\\"A\\\":\\n\\n phi = float(Q_load_W) / float(Q_design_W)\\n eta_max = 0.425 # from energy.gov\\n\\n if phi >= phi_threshold: # from NREL-Shape\\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\\n\\n if phi < phi_threshold:\\n if phi <= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\\n\\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3.0 + \\\\\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\\n\\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\\\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\\n\\n eta_therm_max = 0.45 # constant, after energy.gov\\n\\n if phi < phi_threshold:\\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\\n\\n else:\\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\\n\\n ## Approach B - Empiric Approach\\n if approach_call == \\\"B\\\":\\n\\n if Q_design_W > 0:\\n phi = float(Q_load_W) / float(Q_design_W)\\n\\n else:\\n phi = 0\\n\\n eta_el_max = 0.39\\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\\n\\n eta_el = eta_el_max * eta_el_score\\n eta_therm = eta_therm_max * eta_therm_score\\n\\n if phi < 0.2:\\n eta_el = 0\\n\\n return eta_el, eta_therm\",\n \"def e(p, reported, recount):\\n return t(p, reported) - t(p, recount)\",\n \"def heuristic_2_reflection(game, player) -> float:\\n\\n reflection_available_factor = get_reflection_available_factor(game, player)\\n\\n return float(reflection_available_factor)\",\n \"def PV_BenefitDeath(t):\\n if t > last_t:\\n return 0\\n else:\\n return (-prj_bnft_Death(t) + PV_BenefitDeath(t + 1)) / (1 + DiscRate(t))\",\n \"def getEta(self):\\n self.__eta = 3./8.*(1. - self.__alpha0 - self.__alpha1 - 2.*self.__beta)\\n if self.__eta<0.: self.__eta=0. # erreur d'arrondi\\n return self.__eta\",\n \"def hit_stand_ev_diff(hand, shoe, dealer_hand, dealer_probabilities):\\n dealer_end_probs = dealer_probabilities[dealer_hand]\\n # maps a player's hand to his or her (hit_ev, stand_ev, max_ev)\\n player_payoffs = get_player_payoff(dealer_end_probs)\\n\\n ev = 0 # contains weighted ev\\n total = 0 # contains total weights, to normalized at the end\\n val, hard = hand\\n for card in shoe:\\n weight = shoe[card] # number of a card in the shoe\\n total += weight\\n if hard and 11 <= val <= 21:\\n new_hand = (val + card, hard)\\n if new_hand[0] > 21:\\n ev -= weight # default loss\\n else:\\n ev += weight * player_payoffs[new_hand][-1]\\n elif not hard and 12 <= val <= 21:\\n new_val = val + card\\n new_hard = False\\n if new_val > 21: # go back to hard value, take A = 1\\n new_val -= 10\\n new_hard = True\\n ev += weight * player_payoffs[(new_val, new_hard)][-1]\\n elif hard and 4 <= val <= 10:\\n new_val = val + card\\n new_hard = True\\n if card == 1: # go to soft value, take A = 11\\n new_val += 10\\n new_hard = False\\n ev += weight * player_payoffs[(new_val, new_hard)][-1]\\n else:\\n raise RuntimeError(\\\"Should not get here: \\\" + str(hand))\\n return (1.0 * ev / total) - player_payoffs[hand][1] # hit ev - stand ev\",\n \"def U_Function(currentPlayer, oppositePlayer, N, maxEntity):\\n EndPointPlayer1 = Posisi.Posisi(N - 1, N - 1)\\n EndPointPlayer2 = Posisi.Posisi(0, 0)\\n \\n sumPionPlayer1 = 0\\n sumPionPlayer2 = 0\\n\\n if (currentPlayer.noPlayer == 1):\\n for Pion in currentPlayer.arrayPion:\\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\\n for Pion in oppositePlayer.arrayPion:\\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\\n \\n if (currentPlayer.noPlayer == 2):\\n for Pion in currentPlayer.arrayPion:\\n sumPionPlayer2 += Pion.currentPosition.euclidean(EndPointPlayer2)\\n for Pion in oppositePlayer.arrayPion:\\n sumPionPlayer1 += Pion.currentPosition.euclidean(EndPointPlayer1)\\n\\n if (maxEntity == 1):\\n return -sumPionPlayer1 + sumPionPlayer2\\n else:\\n return -sumPionPlayer2 + sumPionPlayer1\",\n \"def airfoilEffT(self):\\n return float(Importer(Component='Evaluations',\\n VariableName='Wing airfoil efficiency factor',\\n Default=.95,\\n Path=self.filePath).getValue)\",\n \"def material_advantage(state, player):\\n ma = 0\\n if player == cc.WHITE_ACTIVE:\\n white_factor = 1\\n black_factor = -1\\n else:\\n white_factor = -1\\n black_factor = 1\\n \\n for rank in range(8):\\n for column in range(8):\\n piece = state.board[rank, column]\\n if piece == cc.NO_PIECE:\\n continue\\n elif piece in cc.WHITE_PIECES:\\n if piece == cc.W_PAWN:\\n ma += white_factor * cc.MA_PAWN\\n elif piece == cc.W_KNIGHT:\\n ma += white_factor * cc.MA_KNIGHT\\n elif piece == cc.W_BISHOP:\\n ma += white_factor * cc.MA_BISHOP\\n elif piece == cc.W_ROOK:\\n ma += white_factor * cc.MA_ROOK\\n elif piece == cc.W_QUEEN:\\n ma += white_factor * cc.MA_QUEEN\\n elif piece == cc.W_KING:\\n ma += white_factor * cc.MA_KING\\n elif piece in cc.BLACK_PIECES:\\n if piece == cc.B_PAWN:\\n ma += black_factor * cc.MA_PAWN\\n elif piece == cc.B_KNIGHT:\\n ma += black_factor * cc.MA_KNIGHT\\n elif piece == cc.B_BISHOP:\\n ma += black_factor * cc.MA_BISHOP\\n elif piece == cc.B_ROOK:\\n ma += black_factor * cc.MA_ROOK\\n elif piece == cc.B_QUEEN:\\n ma += black_factor * cc.MA_QUEEN\\n elif piece == cc.B_KING:\\n ma += black_factor * cc.MA_KING\\n return ma\",\n \"def custom_score(game, player):\\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the improved score\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n improved = len(player_legal_moves) - len(opponent_legal_moves)\\n if improved != 0:\\n return float(improved)\\n \\n # Second get differences from center\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n player_coordinates = game.get_player_location(player)\\n opponent_coordinates = game.get_player_location(opponent)\\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\\n center_dist_diff = player_center_dist - opponent_center_dist\\n \\n # Third obtain next_moves\\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \\n improved_next = len(player_next_moves) - len(opponent_next_moves)\\n \\n # Put player and opponent feature differences in a tuple/vector surrogoate\\n feature_diff_vector = (improved, center_dist_diff, improved_next)\\n \\n # Provide a weighting vector for the features of each player-participant\\n weight_vector = (1.5,0.1,1.0)\\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(feature_diff_vector, weight_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def calc_ertelPV(n2, bx, rel_vorticity, g=9.8,f=-1e-4):\\n\\n # vertical component\\n\\n qvert = (f+rel_vorticity)*n2\\n\\n # baroclinic component\\n qbc = -bx**2/f\\n\\n # Ertel PV\\n\\n ertelPV = qvert + qbc\\n\\n # If PV is unstable\\n fq = ertelPV*f # fq > 0 stable\\n\\n return ertelPV, qvert, qbc, fq\",\n \"def do_damage(self) -> float:\\n sum = 0\\n for operator in self.__operators:\\n if operator.is_alive:\\n operator.experience += 1\\n sum += operator.experience / 100\\n return 0.1 + sum\",\n \"def KentFosterII_calc(TP, FP, FN, TN):\\n try:\\n part1 = ((TN + FP) * (TN + FN)) / (TN + FP + FN)\\n return (TN - part1) / (TN - part1 + FP + FN)\\n except Exception:\\n return \\\"None\\\"\",\n \"def gtf(self):\\n\\t #if tank is empty, conductance is 0\\n\\t if self.tx <= 0:\\n\\t return 0.\\n\\t\\t#returns 0.5, as a function of TAI\\n\\t else:\\n\\t return 0.5\",\n \"def evaluate(game, player):\\n weights = [2, 200, 2000, 20000]\\n reward = 0\\n opponent = get_opponent(player)\\n for length in range(2, 6):\\n reward += weights[length - 2] * get_num_series(game, player, length)\\n reward -= weights[length - 2] * get_num_series(game, opponent, length)\\n return reward\",\n \"def compute_uct(self):\\n if self.visits != 0:\\n return - self.reward / self.visits + self.C * math.sqrt(math.log(self.parent.visits) / self.visits)\\n else:\\n return float('inf')\",\n \"def calculate_advantage(stage_0, stage_1):\\n # Improvement in hp difference is good.\\n hp_pct_0 = (float(stage_0.friendly_life)/MAX_FRIENDLY_LIFE) - (float(stage_0.enemy_life)/MAX_ENEMY_LIFE)\\n hp_pct_1 = (float(stage_1.friendly_life)/MAX_FRIENDLY_LIFE) - (float(stage_1.enemy_life)/MAX_ENEMY_LIFE)\\n return hp_pct_1 - hp_pct_0\",\n \"def fermi(E,mu,T):\\n if (E-mu)/T > 600:\\n f=0\\n\\t\\t\\t\\t\\n else:\\n f=1/(math.exp((E-mu)/(kB*T) )+1)\\n return(f)\",\n \"def Eg_fct_T(Eg0,alpha,beta,T) :\\n return Eg0-((T*T*alpha*1e-3)/(beta+T))\",\n \"def energy_func(self):\\n i = self.inl[0].to_flow()\\n o = self.outl[0].to_flow()\\n\\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\\n\\n iam = (\\n 1 - self.iam_1.val * abs(self.aoi.val) -\\n self.iam_2.val * self.aoi.val ** 2)\\n\\n return (i[0] * (o[2] - i[2]) -\\n self.A.val * (\\n self.E.val * self.eta_opt.val * self.doc.val ** 1.5 * iam -\\n (T_m - self.Tamb.val_SI) * self.c_1.val -\\n self.c_2.val * (T_m - self.Tamb.val_SI) ** 2))\",\n \"def calc_ev(p1_strat, p2_strat, cards, history, active_player):\\n if KuhnPoker.is_terminal(history):\\n return -KuhnPoker.get_payoff(history, cards)\\n my_card = cards[active_player]\\n next_player = (active_player + 1) % 2\\n if active_player == 0:\\n strat = p1_strat[my_card + history]\\n else:\\n strat = p2_strat[my_card + history]\\n return -np.dot(strat, [calc_ev(p1_strat, p2_strat, cards, history + a, next_player) for a in KUHN_ACTIONS])\",\n \"def eval_func(self, game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n \\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n if game.move_count < ((game.height * game.width)/2):\\n return float(self.weights[0] * own_moves - \\n self.weights[1] * opp_moves - \\n self.weights[2] * __distance_from_center__(game, player))\\n else:\\n return float(self.weights[3] * own_moves - \\n self.weights[4] * opp_moves - \\n self.weights[5] * __distance_from_center__(game, player))\",\n \"def energy(e: float) -> float:\\n\\n return (1/np.sqrt(2))*(gamma(-e/2+1/2)/(gamma(-e/2+3/4)))\",\n \"def _fv(self):\\n return self.beta * (self.x ** self.c)\",\n \"def compute_utility(self, board, move, player):\\n r_alive = 0\\n b_alive = 0\\n rk_alive = 0\\n bk_alive = 0\\n for line in range(8):\\n for col in range(8):\\n if board[line][col] == \\\"R\\\":\\n r_alive += 1\\n elif board[line][col] == \\\"B\\\":\\n b_alive += 1\\n elif board[line][col] == \\\"RK\\\":\\n rk_alive += 1\\n elif board[line][col] == \\\"BK\\\":\\n bk_alive += 1\\n # if r_Alive > b_Alive:\\n # if b_Alive == 0:\\n # return 1\\n # else: return 0\\n # elif r_Alive == 0:\\n # return -1\\n powkings = 1.2\\n result = 0\\n if player == 'B':\\n result = rk_alive*powkings + r_alive - bk_alive*powkings - b_alive\\n else:\\n result = bk_alive*powkings + b_alive - rk_alive*powkings - r_alive\\n return result\",\n \"def heuristic_combined_2_3(game, player) -> float:\\n\\n reflection_available_factor = get_reflection_available_factor(game, player)\\n partition_possible_factor = get_partition_possible_factor(game, player)\\n\\n return float(reflection_available_factor + partition_possible_factor)\",\n \"def do_damage(self) -> float:\\n res = 0.05 + self.experience / 100\\n self.experience = self.experience + 1\\n return res\",\n \"def get_cost(self) -> float:\\n return math.e / self.fitness\",\n \"def calculate(self) -> float:\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n agreement = tp + tn\\n chance0 = (tn + fn) * (tn + fp)\\n chance1 = (fp + tp) * (fn + tp)\\n sum_ = tn + fn + fp + tp\\n chance = (chance0 + chance1) / sum_\\n\\n return (agreement - chance) / (sum_ - chance)\",\n \"def compute_efftime(table,\\n kterm=0.114, # KERM\\n ebv_r_coeff=2.165,\\n fiber_diameter_arcsec=1.52):\\n\\n exptime = table[\\\"EXPTIME\\\"]\\n skymag = table[\\\"SKY_MAG_R_SPEC\\\"]\\n sky = 10**(-0.4*(skymag-22.5)) # nMgy/arcsec**2\\n ebv = table[\\\"EBV\\\"]\\n transparency = table[\\\"TRANSPARENCY_GFA\\\"]\\n airmass = table[\\\"AIRMASS\\\"]\\n fiberfac_psf = table[\\\"FIBERFAC_GFA\\\"] # fiber_frac * transparency normalized to 1 for nominal conditions\\n fiberfac_elg = table[\\\"FIBERFAC_ELG_GFA\\\"] # fiber_frac * transparency normalized to 1 for nominal conditions\\n fiberfac_bgs = table[\\\"FIBERFAC_BGS_GFA\\\"] # fiber_frac * transparency normalized to 1 for nominal conditions\\n\\n fiber_fracflux_bgs = table[\\\"FIBER_FRACFLUX_BGS_GFA\\\"] # fraction of light down fiber\\n fiber_fracflux_psf = table[\\\"FIBER_FRACFLUX_GFA\\\"]\\n\\n exptime_nom = 1000.0 # AR seconds\\n sky_nom = 3.73 # AR nMgy/arcsec**2\\n flux_bright_nom = 15.8 # nMgy (r=19.5 mag for de Vaucouleurs rhalf=1.5\\\" BGS)\\n flux_backup_nom = 27.5 # nMgy (r=18.9 mag star)\\n\\n # AR airmass term\\n airfac = 10.0 ** (kterm * (airmass - 1.0) / 2.5)\\n # AR ebv term\\n ebvfac = 10.0 ** (ebv_r_coeff * ebv / 2.5)\\n # AR sky readnoise\\n sky_rdn = 0.932 # AR nMgy/arcsec**2\\n\\n # AR \\\"limit\\\" fiber flux\\n fiber_area_arcsec2 = np.pi*(fiber_diameter_arcsec/2)**2\\n\\n # flux in fiber artificially divided by fiber_area_arcsec2 because the sky flux is per arcsec2\\n fflux_bright = flux_bright_nom * transparency * fiber_fracflux_bgs / airfac / ebvfac / fiber_area_arcsec2\\n fflux_backup = flux_backup_nom * transparency * fiber_fracflux_psf / airfac / ebvfac / fiber_area_arcsec2\\n\\n # AR effective sky\\n effsky_dark = (sky + sky_rdn * exptime_nom / exptime) / (1.0 + sky_rdn / sky_nom)\\n effsky_bright = (sky + sky_rdn * exptime_nom / exptime + fflux_bright) / (\\n 1.0 + sky_rdn / sky_nom + fflux_bright / sky_nom\\n )\\n effsky_backup = (sky + sky_rdn * exptime_nom / exptime + fflux_backup) / (\\n 1.0 + sky_rdn / sky_nom + fflux_backup / sky_nom\\n )\\n # AR effective exposure time\\n efftime_dark = (\\n exptime\\n * (fiberfac_elg / airfac) ** 2\\n * (sky_nom / effsky_dark)\\n / ebvfac ** 2\\n )\\n efftime_bright = (\\n exptime\\n * (fiberfac_bgs / airfac) ** 2\\n * (sky_nom / effsky_bright)\\n / ebvfac ** 2\\n )\\n efftime_backup = (\\n exptime\\n * (fiberfac_psf / airfac) ** 2\\n * (sky_nom / effsky_backup)\\n / ebvfac ** 2\\n )\\n\\n # set to -1 values with incorrect inputs\\n bad=table[\\\"AIRMASS\\\"]<0.99\\n bad |=(table[\\\"FIBER_FRACFLUX_GFA\\\"]==0)\\n bad |=(table[\\\"TRANSPARENCY_GFA\\\"]>2)\\n efftime_dark[bad]=0.\\n efftime_bright[bad]=0.\\n efftime_backup[bad]=0.\\n\\n return efftime_dark , efftime_bright , efftime_backup\",\n \"def getReward (events_counters):\\n global P_0, P_1, C_0, C_1, C_2 \\n return (P_0 - C_0) * events_counters[0] - (C_0 + C_1) * events_counters[1] - (\\n C_2 * events_counters[2] - P_1 * events_counters[3])\",\n \"def custom_score_3(game, player):\\n \\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n player_legal_move_count, opponent_legal_move_count = \\\\\\n len(player_legal_moves), len(opponent_legal_moves)\\n move_count_difference = player_legal_move_count - opponent_legal_move_count\\n # Find coordinates of center box\\n h, w = get_center_coordinates(game)\\n # Retrieve player's coordinates\\n y, x = game.get_player_location(player)\\n # Obtain coordinate further, closest to origin\\n furthest_coord, closest_coord = max(h - y, w -x), min(h - y, w - x)\\n # Return weighted, vector-valued length from origin / sum of weights\\n weighted_distance_from_center = \\\\\\n math.sqrt((closest_coord**2 + 2*(furthest_coord**2)))/3\\n feature_vector = (move_count_difference, weighted_distance_from_center)\\n \\n weight_vector = (1.0,0.1)\\n \\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(weight_vector, feature_vector)) \\n \\n return float(weighted_difference_dot_product)\",\n \"def determineAmountToCall(self, player):\\n\\t\\treturn sum(self.currentBet) - sum(player.betAmount)\",\n \"def acceleration(v,u,t):\\n return ((v-u)/t)\",\n \"def KentFosterI_calc(TP, FP, FN, TN):\\n try:\\n part1 = ((TP + FP) * (TP + FN)) / (TP + FP + FN)\\n return (TP - part1) / (TP - part1 + FP + FN)\\n except Exception:\\n return \\\"None\\\"\",\n \"def vanilaScore(self,attended,state,W):\",\n \"def heuristic_combined_1_2(game, player) -> float:\\n\\n center_available_factor = get_center_available_factor(game, player)\\n reflection_available_factor = get_reflection_available_factor(game, player)\\n\\n return float(center_available_factor + reflection_available_factor)\",\n \"def get_delta_v_tot(f, e, a, P):\\n\\n coeff = (2.0*np.pi/P) * a / np.sqrt(1.0 - e*e)\\n delta_v_tot = coeff * (1.0 + 2.0*e*np.cos(f) + e*e) / 1.0e5\\n\\n return delta_v_tot\",\n \"def time_elapsed(session, player):\\n #TODO (also needs to be added to bot logic)\",\n \"def self_energy(gf_imp0, gf_imp):\\n return 1/gf_imp0 - 1/gf_imp\",\n \"def cal_eta(self):\\n\\n if not self.check_def(['E','px','py','pz']):\\n sys.exit('Particle error: Quadri impulsion not define (error for eta routine)')\\n \\n theta=math.acos(self.pz/math.sqrt(self.px**2+self.py**2+self.pz**2))\\n self.eta=-math.log(math.tan(theta/2.0))\",\n \"def advancedStats():\",\n \"def report_result(force_a_before, force_b_before, force_a_after, force_b_after):\\n damage_a = 0.0\\n damage_b = 0.0\\n ################################# YOUR CODE HERE #################################\\n damage_a = calculate_training_cost(force_a_before) - calculate_training_cost(force_a_after)\\n damage_b = calculate_training_cost(force_b_before) - calculate_training_cost(force_b_after)\\n ##################################################################################\\n return damage_a, damage_b\",\n \"def energy_func(self):\\n i = self.inl[0].to_flow()\\n o = self.outl[0].to_flow()\\n\\n T_m = (T_mix_ph(i, T0=self.inl[0].T.val_SI) +\\n T_mix_ph(o, T0=self.outl[0].T.val_SI)) / 2\\n\\n return (i[0] * (o[2] - i[2]) -\\n self.A.val * (\\n self.E.val * self.eta_opt.val -\\n (T_m - self.Tamb.val_SI) * self.lkf_lin.val -\\n self.lkf_quad.val * (T_m - self.Tamb.val_SI) ** 2))\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the base information to calculate player & opponent\\n # feature values\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n if len(player_legal_moves) != len(opponent_legal_moves):\\n return float(len(player_legal_moves) - len(opponent_legal_moves))\\n \\n # Get_center_coordinates and opponent. Then set the list of participants\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n participants = [player, opponent]\\n \\n # Then, for each participant obtain his/her feature values \\n for participant in participants:\\n if participant == player:\\n p_legal_moves = player_legal_moves\\n player_either = player\\n participant_coordinates = p_y, p_x = \\\\\\n game.get_player_location(participant)\\n player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, \\\\\\n player_path_count, player_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either,participant_coordinates, p_legal_moves)\\n else:\\n p_legal_moves = opponent_legal_moves\\n player_either = opponent\\n participant_coordinates = p_y, p_x \\\\\\n = game.get_player_location(participant)\\n opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, opponent_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either, participant_coordinates, p_legal_moves)\\n \\n # Place each participant's feature values in a tuple/vector surrogate \\n pro_player_vector = \\\\\\n (player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, player_path_count, \\\\\\n opponent_min_center_diff)\\n pro_opponent_vector = \\\\\\n (opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, player_min_center_diff)\\n \\n # Provide a weighting vector for the features \\n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\\n \\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\\\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def cost(self) -> float:\",\n \"def value(self, board, current_player, opposite_player):\\n my_fours = self.check_for_streak(board, current_player, 4)\\n my_threes = self.check_for_streak(board, current_player, 3)\\n my_twos = self.check_for_streak(board, current_player, 2)\\n opp_fours = self.check_for_streak(board, opposite_player, 4)\\n if opp_fours > 0:\\n return -100000\\n else:\\n return my_fours*100000 + my_threes*100 + my_twos\",\n \"def _evaluate_electric(snapshot, params):\\n positions = snapshot.particles.position\\n charges = snapshot.particles.charge\\n E_field = params\\n energies = -charges * np.dot(positions, E_field)\\n forces = np.outer(charges, E_field)\\n return forces, energies\",\n \"def act(self, image, player_info):\\n action = {'acceleration': 1, 'brake': False, 'drift': False, 'nitro': False, 'rescue': False, 'steer': np.random.uniform(-1,1)}\\n \\\"\\\"\\\"\\n Your code here.\\n \\\"\\\"\\\"\\n\\n return action\",\n \"def playerdefeated(self):\\n globalvalues.gameover_combat()\",\n \"def eta_details(self):\\n\\t\\t# Experimentation gives you 72pts to a random science every production\\n\\t\\t# Stupid brute force implementation for now\\n\\t\\trequired = self.required\\n\\t\\trate = self.player.science\\n\\t\\tdef combine(base, add, add_time, chance):\\n\\t\\t\\t# add given add into base with +add_time tick and modified by chance\\n\\t\\t\\tfor time, p in add.items():\\n\\t\\t\\t\\ttime += add_time\\n\\t\\t\\t\\tp *= chance\\n\\t\\t\\t\\tbase[time] = base.get(time, 0) + p\\n\\t\\tdef _eta_details(value, time_to_prod=self.galaxy.production_rate):\\n\\t\\t\\tnaive_eta = max(0, int(math.ceil((required - value)/rate)))\\n\\t\\t\\tif naive_eta <= time_to_prod: return {naive_eta: 1}\\n\\t\\t\\tbase = {}\\n\\t\\t\\twithout_extra = _eta_details(value + rate*time_to_prod)\\n\\t\\t\\twith_extra = _eta_details(value + rate*time_to_prod + 72)\\n\\t\\t\\tcombine(base, without_extra, time_to_prod, 6/7.)\\n\\t\\t\\tcombine(base, with_extra, time_to_prod, 1/7.)\\n\\t\\t\\treturn base\\n\\t\\treturn _eta_details(self.current, self.galaxy.production_rate - self.galaxy.production_counter)\",\n \"def _compute_f(self, p, dh, dv):\\n return dh / (self.beta * p * dv)\",\n \"def betterEvaluationFunction(currentGameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n pacmanPos = currentGameState.getPacmanPosition()\\n\\n food = currentGameState.getFood()\\n capsules = currentGameState.getCapsules()\\n return currentGameState.getScore() - 10 * capsuleDistancePlan(pacmanPos, capsules) - foodDistPlan(pacmanPos, food)\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n return 1 - abs(fn - fp) / (2 * tp + fn + fp)\",\n \"def delta_energy(atom,layer1,layer2):\\n global r,c,h\\n return float('%.2E' % Decimal(str(r*((atom**2/layer1**2)-(atom**2/layer2**2)))))\",\n \"def betterEvaluationFunction(currentGameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n newPos = currentGameState.getPacmanPosition()\\n newFood = currentGameState.getFood()\\n newGhostStates = currentGameState.getGhostStates()\\n GhostLocs = currentGameState.getGhostPositions()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n capsuleLocations = currentGameState.getCapsules()\\n Hueristic = 0.0\\n \\n if currentGameState.isWin():\\n return 10000\\n if currentGameState.isLose():\\n return -10000\\n\\n FoodDistances = []\\n foodLocations = newFood.asList()\\n for food in foodLocations:\\n FoodDistances.append(manhattanDistance(newPos,food))\\n closestFood = min(FoodDistances)\\n closestFoodLocation = foodLocations[FoodDistances.index(closestFood)]\\n\\n GhostsToMe = []\\n GhostsToFood = []\\n for ghost in GhostLocs:\\n GhostsToMe.append(manhattanDistance(newPos,ghost))\\n GhostsToFood.append(manhattanDistance(closestFoodLocation,ghost))\\n closestGhostToMe = min(GhostsToMe)\\n closestGhostToClosestFood = min(GhostsToFood)\\n closestGhostLocation = GhostLocs[GhostsToMe.index(closestGhostToMe)]\\n\\n if newPos in currentGameState.getCapsules():\\n capsule = 100\\n else: \\n capsule = 0\\n \\n if closestGhostToClosestFood < closestFood:\\n if closestGhostToMe > 4:\\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*50 - (1/closestGhostToMe)*5\\n else:\\n Hueristic = (-1/closestGhostToMe)*50\\n else:\\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*50 - (1/closestGhostToMe)*5\\n return Hueristic\",\n \"def get_f_score(self):\\n return self.get_g_score() + self.get_h_score()\",\n \"def pot_energy_morse(r_12, D, alpha,r_e):\\n\\n potential=float(D)*(((1.0-m.exp(-float(alpha)*(float(r_12)-float(r_e))))**2.0)-1.0)\\n return potential\",\n \"def E(self, t):\\n\\n\\t\\tE = self.E0\\n\\n\\t\\t# Gaussian pulse shape\\n\\t\\tE *= np.exp(-2.*np.log(2.)*((t-self.t0)/self.pulse_duration)**2.)\\n\\n\\t\\t# Instantaneous phase\\n\\t\\tif self.phase:\\n\\t\\t\\tE *= np.cos(self.omega*(t-self.t0))\\n\\n\\t\\t# Transmition\\n\\t\\tif self.remove_reflected_part and self.domain.D == 0:\\n\\t\\t\\tmaterial = self.domain.materials[0]\\n\\t\\t\\tE *= ((1.-material.Reflectivity)/material._Drude_index.real)**0.5\\n\\n\\t\\treturn E\",\n \"def deathSubtractor(self, damage, target, caller):\\n target_body = target.db.body\\n target_bleed_points = target.db.bleed_points\\n target_death_points = target.db.death_points\\n\\n if target_body and damage:\\n body_damage = target_body - damage\\n if body_damage < 0:\\n damage = abs(body_damage)\\n target.db.body = 0\\n else:\\n target.db.body = body_damage\\n damage = 0\\n\\n if target_bleed_points and damage:\\n bleed_damage = target_bleed_points - damage\\n if bleed_damage < 0:\\n damage = abs(bleed_damage)\\n target.db.bleed_points = 0\\n target.db.weakness = 1\\n else:\\n target.db.bleed_points = bleed_damage\\n damage = 0\\n target.db.weakness = 1\\n\\n target.msg(\\\"|430You are bleeding profusely from many wounds and can no longer use any active martial skills.\\\\n|n\\\")\\n target.location.msg_contents(f\\\"{target.key} |025is bleeding profusely from many wounds and will soon lose consciousness.|n\\\")\\n\\n\\n if target_death_points and damage:\\n death_damage = target_death_points - damage\\n if death_damage < 0:\\n damage = abs(death_damage)\\n target.db.death_points = 0\\n else:\\n target.db.death_points = death_damage\\n damage = 0\\n\\n target.msg(\\\"|300You are unconscious and can no longer move of your own volition.|n\\\")\\n target.location.msg_contents(f\\\"{target.key} |025does not seem to be moving.|n\\\")\\n\\n else:\\n pass\",\n \"def compute(self) -> torch.Tensor:\\n return _fbeta_compute(self.true_positives, self.predicted_positives,\\n self.actual_positives, self.beta, self.average)\",\n \"def _decisionFunction(self):\\n #THIS IS WHERE THE INTELLIGENT AGENT CODE MAKES DECISION\\n #since this is the hand coded extension, I'm just going to hard code some stuff\\n #q learning and Sarsa should hopefully do better\\n \\n #this is some other hand coded stuff that you read in stone's paper\\n c1 = 64 #c1 = distance in pixels\\n c2 = 2.5#c2 = something to multiply angle by\\n c3 = 77 #c3 is the number of pixels you assume are in 5 meteres\\n #state variable 7 is distance in pixels from K1 to T1\\n if self.stateVariables[7] > c1:\\n self._holdBall()\\n else:\\n passMax = float(\\\"-Inf\\\")\\n passMaxArg = None\\n for i in range(1,3):\\n var = (c2 * arccos(self.stateVariables[10+i])) + (self.stateVariables[8+i] / c3)\\n \\\"\\\"\\\"\\n print(\\\"var = \\\", var)\\n print(\\\"stateVariable[\\\", 10 + i, \\\"]=\\\", self.stateVariables[10+i] )\\n print(\\\"arccos of stateVariable[\\\", 10 + i, \\\"]=\\\", arccos(self.stateVariables[10+i]) )\\n print(\\\"stateVariable[\\\", 8 + i, \\\"]=\\\", self.stateVariables[8+i] )\\n \\\"\\\"\\\"\\n \\n if var > passMax:\\n passMax = var\\n passMaxArg = i\\n self._passBall(passMaxArg)\",\n \"def generate_transE_score(self, hs, ts, r):\\n\\n all_embeddings = self._get_ego_embeddings()\\n h_e = all_embeddings[hs]\\n t_e = all_embeddings[ts]\\n r_e = self.relation_embedding.weight[r]\\n r_trans_w = self.trans_w.weight[r].view(\\n self.embedding_size, self.kg_embedding_size\\n )\\n\\n h_e = torch.matmul(h_e, r_trans_w)\\n t_e = torch.matmul(t_e, r_trans_w)\\n\\n kg_score = torch.mul(t_e, self.tanh(h_e + r_e)).sum(dim=1)\\n\\n return kg_score\",\n \"def fight(self):\\r\\n\\t\\tif self.death():\\r\\n\\t\\t\\treturn 0\\r\\n\\t\\tif self.ctime < 1:\\r\\n\\t\\t\\tself.ctime += 0.05\\r\\n\\t\\telse:\\r\\n\\t\\t\\tself.ctime = 0\\r\\n\\t\\t\\tself.hit()\",\n \"def test_positive_electrode_potential_profile(self):\\n\\n # TODO: add these when have averages\",\n \"def TPR(self):\\n return _div(self.TP, self.TP + self.FN)\",\n \"def get_expected_cost(self):\",\n \"def p_funct(self, yi, p, t): \\t\\t\\n\\t\\t\\n\\t\\tglobal Cg \\n\\t\\tCg = abs(yi[0])\\n\\t\\tglobal Ch \\n\\t\\tCh = abs(yi[1])\\n\\t\\tglobal tin_g \\n\\t\\ttin_g = abs(yi[2])\\n\\t\\tglobal tin_h \\n\\t\\ttin_h = abs(yi[3])\\n\\t\\t\\n\\t\\ty = state_at(t)\\n\\t\\trisk = 1 - (y[-1][0] + y[-1][3]) / sum(y[-1])\\n\\t\\t\\n\\t\\treturn abs(risk - p)\",\n \"def compute_utility(board, color):\\n player1_score = 0\\n player2_score = 0\\n\\n score = get_score(board)\\n if color == 1:\\n return score[0] - score[1]\\n else:\\n return score[1] - score[0]\",\n \"def etrf_func(et_inst, etr):\\n return et_inst / etr\",\n \"def rhs_fenics(y,t):\\n #print \\\"time: \\\",t\\n uprev.vector()[:]=y\\n f.t = t #dolfin needs to know the current time for cos(t)\\n uprime_solver.solve()\\n return uprime_solution.vector().array()\",\n \"def evaluate(self):\\n # if player has no move, then player lost, -inf or inf depend on who the player is\\n # if player has moves, use heuristics.\\n \\n #checkColorMoves = self.getAvailableMoves(self.colorIndex)\\n #otherColorMoves = self.getAvailableMoves(1-self.colorIndex)\\n \\n checkColorMoves = self.getAvailableMovesPreferLonger(self.colorIndex)\\n otherColorMoves = self.getAvailableMovesPreferLonger(1-self.colorIndex)\\n\\n checkColorPieces = self.getPieceCount(self.colorIndex)\\n otherColorPieces = self.getPieceCount(1-self.colorIndex)\\n\\n #checkColorEdgePieces = self.getEgdePieceCount(self.colorIndex)\\n #otherColorEdgePieces = self.getEgdePieceCount(1-self.colorIndex)\\n\\n if self.player == 'computer':\\n if checkColorMoves == 0: #computer doesn't have moves\\n return float('-inf')\\n elif otherColorMoves == 0: #user doesn't have moves\\n return float('inf')\\n else:\\n #return checkColorPieces - otherColorPieces\\n return checkColorMoves - otherColorMoves\\n else:\\n if checkColorMoves == 0: #user doesn't have moves\\n return float('inf')\\n elif otherColorMoves == 0: #computer doesn't have moves\\n return float('-inf')\\n else:\\n #return otherColorPieces - checkColorPieces\\n return otherColorMoves - checkColorMoves\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n tn = self.confusion_matrix.tn\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n n = tp + tn + fp + fn\\n e1 = (fn * (fn + 2 * tp) / (tp + fn) + fp * (fp + 2 * tn) / (tn + fp)) / n\\n e2 = (fp * (fp + 2 * tp) / (tp + fp) + fn * (fn + 2 * tn) / (tn + fn)) / n\\n\\n return min(e1, e2)\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def reward(self, player, winning_state):\\n if winning_state == \\\"Tie\\\":\\n return 1\\n elif winning_state == \\\"Resume\\\":\\n return -1\\n else:\\n if player == \\\"agent\\\":\\n return 10\\n else:\\n return -10\",\n \"def tdew_from_ea(ea):\\n return (237.3 * np.log(ea / 0.6108)) / (17.27 - np.log(ea / 0.6108))\",\n \"def calculate_value(self, hand):\\n global FACE_CARDS\\n #could refactor the 2 hand possiblities into methods of a Dealer and Player Class\\n if hand == \\\"player\\\":\\n if self.player_hand[-1].value in FACE_CARDS:\\n self.player_value += 10\\n elif self.player_hand[-1].value == \\\"A\\\":\\n self.player_value += 11\\n self.player_ace_count += 1\\n else:\\n self.player_value += int(self.player_hand[-1].value)\\n\\n if self.player_value > 21:\\n if self.player_ace_count > self.player_almost_bust:\\n #To prevent a Bust, your Ace became a one\\n self.player_value -= 10\\n self.player_almost_bust += 1\\n else:\\n self.player_lose()\\n elif self.player_value == 21:\\n self.blackjack = True\\n self.endgame()\\n\\n elif hand == \\\"dealer\\\":\\n if len(self.dealer_hand) > 1:\\n if self.dealer_hand[-1].value in FACE_CARDS:\\n self.dealer_value += 10\\n elif self.dealer_hand[-1].value == \\\"A\\\":\\n self.dealer_value += 11\\n self.dealer_ace_count += 1\\n else:\\n self.dealer_value += int(self.dealer_hand[-1].value)\\n\\n if self.dealer_value > 21:\\n if self.dealer_ace_count > self.dealer_almost_bust:\\n #To prevent a Bust, the Dealer's Ace became a one\\n self.dealer_value -= 10\\n self.dealer_almost_bust += 1\\n else:\\n self.player_win()\\n elif self.dealer_value == 21:\\n self.player_lose()\",\n \"def calculate(self):\\n\\n tp = self.confusion_matrix.tp\\n fp = self.confusion_matrix.fp\\n fn = self.confusion_matrix.fn\\n\\n return tp / (tp + fp + fn)\",\n \"def KendallTau_calc(TP, FP, FN, TN):\\n try:\\n n = TP + FP + FN + TN\\n return (2 * (TP + TN - FP - FN)) / (n * (n - 1))\\n except Exception:\\n return \\\"None\\\"\",\n \"def evaluationFunction(self, currentGameState, action):\\n # Useful information you can extract from a GameState (pacman.py)\\n successorGameState = currentGameState.generatePacmanSuccessor(action)\\n newPos = successorGameState.getPacmanPosition()\\n newFood = successorGameState.getFood()\\n newGhostStates = successorGameState.getGhostStates()\\n GhostLocs = successorGameState.getGhostPositions()\\n newScaredTimes = [ghostState.scaredTimer for ghostState in newGhostStates]\\n capsuleLocations = successorGameState.getCapsules()\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\\"\\\"\\\" factors: proximity to food, proximity to ghosts \\n \\\"\\\"\\\" \\n if successorGameState.isWin():\\n return 10000\\n if successorGameState.isLose():\\n return -10000\\n\\n FoodDistances = []\\n foodLocations = newFood.asList()\\n for food in foodLocations:\\n FoodDistances.append(manhattanDistance(newPos,food))\\n closestFood = min(FoodDistances)\\n closestFoodLocation = foodLocations[FoodDistances.index(closestFood)]\\n\\n\\n GhostsToMe = []\\n GhostsToFood = []\\n for ghost in GhostLocs:\\n GhostsToMe.append(manhattanDistance(newPos,ghost))\\n GhostsToFood.append(manhattanDistance(closestFoodLocation,ghost))\\n closestGhostToMe = min(GhostsToMe)\\n closestGhostToClosestFood = min(GhostsToFood)\\n closestGhostLocation = GhostLocs[GhostsToMe.index(closestGhostToMe)] \\n Hueristic = 0.0\\n if closestGhostToClosestFood < closestFood:\\n if closestGhostToMe > 5:\\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*10 - (1/closestGhostToMe)*5\\n else:\\n Hueristic = (-1/closestGhostToMe)*10000\\n #Ghost is closer to me than nearest food so avoid ghost\\n else:\\n Hueristic = (1.0/(closestFood+1.0))*20 - len(foodLocations)*10 - (1/closestGhostToMe)*5\\n return Hueristic\",\n \"def _get_reward(self, player_score, opponent_score):\\n return player_score - opponent_score\",\n \"def test_get_team_strength(self):\\n pass\",\n \"def ti_func(self):\\n return self.ti.val - self.calc_ti()\",\n \"def life_value(ship_class, t):\\n\\n # Read the external CSV file with the coefficient values\\n life_coefficients = pd.read_csv(\\\"life_coefficients.csv\\\", index_col=0, header=0)\\n # Character of construction coefficient\\n a = life_coefficients.loc[ship_class, \\\"character_of_construction\\\"]\\n # Above-water tonnage coefficient\\n b = life_coefficients.loc[ship_class, \\\"above_water_tonnage\\\"]\\n # Q is unity for 14-inch shells\\n q = 1\\n # Square root of the ratio of total area to area of vitals\\n sqrt_r = life_coefficients.loc[ship_class, \\\"sqrt_area_to_vitals\\\"]\\n # Probability factor (Construction of Fire Effect Tables 1922, p. 31)\\n p = (b * t ** (2/3)) / ((b * t ** (2/3)) + 3)\\n # Life formula (Construction of Fire Effect Tables 1922, p. 31)\\n life = a * (p * sqrt_r) * (b * t ** (1/3))\\n return round(life, 2)\",\n \"def manage_ev(agent, total_power, time_scale):\\n # Dismantle the tuple, it was there just for compactness\\n total_active_power, total_reactive_power = total_power\\n if agent.electrical_vehicle.is_active():\\n # If EV is in supply mode, then it acts as an additional battery\\n if agent.electrical_vehicle.power_supplier == 1:\\n\\n # Compute the desired active and reactive powers according to the power demand and\\n # the contribution of the EV\\n desired_active_power_from_electrical_vehicle = total_active_power * \\\\\\n agent.electrical_vehicle.contribution_active\\n desired_reactive_power_from_electrical_vehicle = total_reactive_power * \\\\\\n agent.electrical_vehicle.contribution_reactive\\n desired_power_from_electrical_vehicle = np.abs(\\n np.complex(desired_active_power_from_electrical_vehicle,\\n desired_reactive_power_from_electrical_vehicle))\\n\\n # Try to get the power out of the EV\\n if agent.electrical_vehicle.erogate(power=desired_power_from_electrical_vehicle, time_scale=time_scale):\\n # If you manage to get the power that you want, then update the demand\\n total_active_power -= desired_active_power_from_electrical_vehicle\\n total_reactive_power -= desired_reactive_power_from_electrical_vehicle\\n\\n # If EV is in charging mode, then it gets power from the grid\\n else:\\n total_active_power += agent.electrical_vehicle.charge_current * agent.voltage_rating # To be checked (\\n # Riccardo)\\n agent.electrical_vehicle.charge(current=agent.electrical_vehicle.charge_current, time_scale=time_scale)\\n return total_active_power, total_reactive_power\",\n \"def __toonTrackExp(self, toonId, track):\\n # CCC look at next attacks that are the same track, take the max\\n # toon track exp and use that for this attack\\n toon = self.battle.getToon(toonId)\\n if (toon != None):\\n toonExpLvl = toon.experience.getExpLevel(track)\\n exp = self.AttackExpPerTrack[toonExpLvl]\\n if track == HEAL:\\n exp = exp * 0.5\\n self.notify.debug(\\\"Toon track exp: \\\" + str(toonExpLvl) +\\n \\\" and resulting acc bonus: \\\" + str(exp))\\n return exp\\n else:\\n return 0\",\n \"def calculate(self):\\n\\n return 2 * self.confusion_matrix.tp / \\\\\\n (2 * self.confusion_matrix.tp + self.confusion_matrix.fp + self.confusion_matrix.fn)\",\n \"def effectiveness(self):\\n self._effectiveness = 0.20 * self.ANA + 0.20 * self.DAM + 0.20 * self.MOA + 0.20 * self.MFA + 0.20 * self.NOP\\n return round(self._effectiveness, 5)\",\n \"def set_offensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0 and (bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]) > 0:\\n fgm = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n fga = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n team_fgm = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n team_fga = team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]\\n team_points = team[\\\"t2p_conv\\\"]*2 + team[\\\"t3p_conv\\\"]*3 + team[\\\"tl_conv\\\"]\\n points = bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"]\\n\\n try:\\n qAST = (Decimal(bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * (Decimal('1.14') * Decimal((team[\\\"assists\\\"] - bx[\\\"assists\\\"]) / team_fgm))) + \\\\\\n Decimal((((team[\\\"assists\\\"] / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - bx[\\\"assists\\\"]) / ((team_fgm / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - fgm)) * (1 - (bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5))))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n qAST = 1\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n qAST = 1\\n\\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2*(team_fga - fga))) * bx[\\\"assists\\\"]\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n ast_part = 0\\n\\n if bx[\\\"tl_int\\\"] > 0:\\n ft_part = Decimal(1 - (1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_part = 0\\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"]))**2) * team[\\\"tl_int\\\"] * Decimal('0.4'))\\n try:\\n team_orb_percentage = Decimal(team[\\\"reb_of\\\"] / (team[\\\"reb_of\\\"] + ((opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]) - opp_team[\\\"reb_of\\\"])))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n\\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\\\"tl_int\\\"] * Decimal('0.4') + team[\\\"turnovers\\\"]))\\n try:\\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_weight = 0\\n\\n orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage\\n\\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\\n if bx[\\\"tl_conv\\\"] > 0:\\n ft_x_poss = Decimal((1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_x_poss = Decimal(1 - (bx[\\\"tl_conv\\\"] / 1)**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n try:\\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n sc_poss =0\\n\\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\\\"turnovers\\\"]\\n\\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\\\"t3p_conv\\\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\\\"t3p_conv\\\"] - bx[\\\"t3p_conv\\\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2 * (team_fga - fga))) * bx[\\\"assists\\\"]\\n except:\\n pprod_ast_part = 0\\n\\n pprod_orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"])**2) * Decimal('0.4') * team[\\\"tl_int\\\"]))\\n try:\\n pprod = (pprod_fg_part + pprod_ast_part + bx[\\\"tl_conv\\\"]) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n pprod = 0\\n\\n try:\\n result = 100 * (pprod / tot_poss)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n result = 0\\n\\n # print(\\\"fgm: \\\" + str(fgm))\\n # print(\\\"fga: \\\" + str(fga))\\n # print(\\\"team_fgm: \\\" + str(team_fgm))\\n # print(\\\"team_fga: \\\" + str(team_fga))\\n # print(\\\"team_points: \\\" + str(team_points))\\n # print(\\\"points: \\\" + str(points))\\n # print(\\\"qAST: \\\" + str(qAST))\\n # print(\\\"fg_part: \\\" + str(fg_part))\\n # print(\\\"ast_part: \\\" + str(ast_part))\\n # print(\\\"ft_part: \\\" + str(ft_part))\\n # print(\\\"team_scoring_poss: \\\" + str(team_scoring_poss))\\n # print(\\\"team_orb_percentage: \\\" + str(team_orb_percentage))\\n # print(\\\"team_play_percentage: \\\" + str(team_play_percentage))\\n # print(\\\"team_orb_weight: \\\" + str(team_orb_weight))\\n # print(\\\"orb_part: \\\" + str(orb_part))\\n # print(\\\"fg_x_poss: \\\" + str(fg_x_poss))\\n # print(\\\"ft_x_poss: \\\" + str(ft_x_poss))\\n # print(\\\"sc_poss: \\\" + str(sc_poss))\\n # print(\\\"tot_poss: \\\" + str(tot_poss))\\n # print(\\\"pprod_fg_part: \\\" + str(pprod_fg_part))\\n # print(\\\"pprod_ast_part: \\\" + str(pprod_ast_part))\\n # print(\\\"pprod_orb_part: \\\" + str(pprod_orb_part))\\n # print(\\\"pprod: \\\" + str(pprod))\\n # print(\\\"result: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n\\n self.ortg = \\\"%.2f\\\" % round(result, 2)\\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\\n \\\"\\\"\\\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \\n using team's formula\\\"\\\"\\\"\\n print(BCOLORS.OKBLUE + \\\"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\\\" + BCOLORS.ENDC)\\n bx = self.get_standard_stats()\\n result = round((bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])/self.get_team_possessions(), 2)\\n self.ortg = \\\"%.2f\\\" % result\",\n \"def uncertainty_ee(self,e1,e2):\\n # reco\\n unc = (self._eleRecoWeight[(e1.pt(),e1.eta())][1]/self._eleRecoWeight[(e1.pt(),e1.eta())][0] + \\\\\\n self._eleRecoWeight[(e2.pt(),e2.eta())][1]/self._eleRecoWeight[(e2.pt(),e2.eta())][0])**2\\n # id-isolation\\n unc += (self._eleIdIsoWeight[(e1.pt(),e1.eta())][1]/self._eleIdIsoWeight[(e1.pt(),e1.eta())][0] + \\\\\\n self._eleIdIsoWeight[(e2.pt(),e2.eta())][1]/self._eleIdIsoWeight[(e2.pt(),e2.eta())][0])**2\\n # trigger (approximate)\\n unc += (abs(self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][1])/ \\\\\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\\n unc += ((self._ele8TrgWeight[(e1.pt(),e1.eta())][1]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][1])/ \\\\\\n (self._ele8TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]+ \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele8TrgWeight[(e2.pt(),e2.eta())][0]- \\\\\\n self._ele17TrgWeight[(e1.pt(),e1.eta())][0]*self._ele17TrgWeight[(e2.pt(),e2.eta())][0]))**2\\n #outcome\\n return sqrt(unc)\",\n \"def score(guess, e, v, per_pixel=False):\\n e_guess = surface2im(guess, v)\\n cost = (e_guess - e)**2\\n if per_pixel:\\n cost = torch.average(cost)\\n return torch.sum(cost)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5827492","0.5827492","0.5789208","0.5724517","0.5719123","0.5719123","0.5719123","0.56517696","0.5605782","0.55988175","0.5591225","0.55509675","0.55410445","0.5514421","0.5474888","0.54631376","0.54623526","0.5455384","0.54417086","0.5441079","0.54320216","0.54271054","0.5407109","0.5406066","0.53894025","0.5385769","0.5382831","0.5372122","0.5359537","0.53455734","0.5345241","0.53443116","0.53300303","0.53276527","0.5317901","0.5314616","0.5313489","0.5310168","0.53064","0.5301012","0.52887684","0.52884823","0.52883035","0.5283646","0.52775794","0.52697885","0.52486014","0.5246515","0.5237797","0.523161","0.5225441","0.5224762","0.5224647","0.52220327","0.52151376","0.52143574","0.52133083","0.5193439","0.5187924","0.5183968","0.5183794","0.5169784","0.51673716","0.51666826","0.5163875","0.5163034","0.51613337","0.5161094","0.51536965","0.5151077","0.5148891","0.51425964","0.513458","0.5133674","0.51332223","0.5133011","0.5132489","0.51294065","0.5127724","0.51247627","0.5122119","0.5118707","0.511702","0.51155984","0.51144","0.51141536","0.5113","0.5108362","0.51069224","0.5106404","0.5101454","0.51004153","0.5098319","0.509586","0.5093799","0.5088446","0.50766206","0.50649506","0.50562996","0.5052945"],"string":"[\n \"0.5827492\",\n \"0.5827492\",\n \"0.5789208\",\n \"0.5724517\",\n \"0.5719123\",\n \"0.5719123\",\n \"0.5719123\",\n \"0.56517696\",\n \"0.5605782\",\n \"0.55988175\",\n \"0.5591225\",\n \"0.55509675\",\n \"0.55410445\",\n \"0.5514421\",\n \"0.5474888\",\n \"0.54631376\",\n \"0.54623526\",\n \"0.5455384\",\n \"0.54417086\",\n \"0.5441079\",\n \"0.54320216\",\n \"0.54271054\",\n \"0.5407109\",\n \"0.5406066\",\n \"0.53894025\",\n \"0.5385769\",\n \"0.5382831\",\n \"0.5372122\",\n \"0.5359537\",\n \"0.53455734\",\n \"0.5345241\",\n \"0.53443116\",\n \"0.53300303\",\n \"0.53276527\",\n \"0.5317901\",\n \"0.5314616\",\n \"0.5313489\",\n \"0.5310168\",\n \"0.53064\",\n \"0.5301012\",\n \"0.52887684\",\n \"0.52884823\",\n \"0.52883035\",\n \"0.5283646\",\n \"0.52775794\",\n \"0.52697885\",\n \"0.52486014\",\n \"0.5246515\",\n \"0.5237797\",\n \"0.523161\",\n \"0.5225441\",\n \"0.5224762\",\n \"0.5224647\",\n \"0.52220327\",\n \"0.52151376\",\n \"0.52143574\",\n \"0.52133083\",\n \"0.5193439\",\n \"0.5187924\",\n \"0.5183968\",\n \"0.5183794\",\n \"0.5169784\",\n \"0.51673716\",\n \"0.51666826\",\n \"0.5163875\",\n \"0.5163034\",\n \"0.51613337\",\n \"0.5161094\",\n \"0.51536965\",\n \"0.5151077\",\n \"0.5148891\",\n \"0.51425964\",\n \"0.513458\",\n \"0.5133674\",\n \"0.51332223\",\n \"0.5133011\",\n \"0.5132489\",\n \"0.51294065\",\n \"0.5127724\",\n \"0.51247627\",\n \"0.5122119\",\n \"0.5118707\",\n \"0.511702\",\n \"0.51155984\",\n \"0.51144\",\n \"0.51141536\",\n \"0.5113\",\n \"0.5108362\",\n \"0.51069224\",\n \"0.5106404\",\n \"0.5101454\",\n \"0.51004153\",\n \"0.5098319\",\n \"0.509586\",\n \"0.5093799\",\n \"0.5088446\",\n \"0.50766206\",\n \"0.50649506\",\n \"0.50562996\",\n \"0.5052945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5157421"},"document_rank":{"kind":"string","value":"68"}}},{"rowIdx":3096,"cells":{"query":{"kind":"string","value":"Method which calculate Assists Percentage of a player"},"document":{"kind":"string","value":"def set_assists_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n team_tc_conv = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n player_tc_conv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0:\n result = (bx[\"assists\"] / (((bx[\"minutes\"] / (team[\"minutes\"] / 5)) * team_tc_conv) - player_tc_conv))*100\n result = result if result <= 100 and result >= 0 else 0\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.assists_percentage = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def percentage(count, total):\n return count / total * 100","def getPercent(*args):","def getPercent(*args):","def set_assists_ratio(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n denominador = tcInt + (0.44 * float(bx[\"tl_int\"])) + float(bx[\"assists\"]) +float(bx[\"turnovers\"])\n numerador = float(bx[\"assists\"])\n result = 0.00\n if denominador > 0:\n result = (numerador / denominador) * 100\n self.assists_ratio = \"%.2f\" % round(result, 2)","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def pct(self):\n\t\treturn self.bottle.pct()","def percentage(a, b):\n return (a * 100.0) / b","def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def administer(self):\n\n score = 0.0\n for question in self.questions:\n if question.ask_and_evaluate() is True:\n score += 1\n return (score / len(self.questions)) * 100","def get_percentage(self):\n return self.percentage","def get_percentage(self):\n return self.percentage","async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def getPercent(self):\n if isinstance(self.score,numbers.Number) and self.getMaximum():\n return (1.0*self.score/self.getMaximum())\n return None","def set_assists_per_turnover(self):\n bx = self.get_standard_stats()\n ratio = bx[\"assists\"]\n if bx[\"turnovers\"] > 0:\n ratio = bx[\"assists\"] / bx[\"turnovers\"]\n self.assists_per_turnover = \"%.2f\" % round(ratio, 2)","def get_crawlera_incapsula_percent(crawlera_user):\n if crawlera_user:\n return 0\n else:\n return 100","def percentage_update(self):\n\n self.event_update()\n return self.percentage","def get_percent(self):\n return self.percent","def as_percent(self):\n if self.dynamic:\n self._update_db_obj()\n return f\"{(self._db_obj.progress / self._db_obj.total) * 100}%\"","def walkout_percentage_average(df,start_year, end_year,bat_met, player_name):\n base_fields = ['PA']\n emp_list = check_base_fields(df,base_fields)\n\n if not emp_list:\n bb_val = round((pd.to_numeric(df['BB.'].str.split('%').str[0])/100)*df['PA'],0).sum()\n pa_total = df['PA'].fillna(0).sum()\n return \"{:.2%}\".format(bb_val / pa_total)\n else:\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\n return walkout_percentage_average(df,start_year, end_year,bat_met, player_name)","def percentage(part, whole):\n return round((100 * float(part)/float(whole)),2)","def get_win_percentage(self) -> float:\n if self.wins == 0:\n return 0.0\n else:\n return round((self.wins / (self.wins + self.losses)) * 100, 2)","def _percent(self, lines_total, lines_covered):\n\n if lines_total == 0:\n return '0.0'\n return str(float(float(lines_covered) / float(lines_total)))","def percentCheck(currentTimeLabel, totalTimeLabel):\n # Updated 11/19/16\n try:\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\n except (ValueError , ZeroDivisionError):\n progPercent = 0\n \n return progPercent","def percent_passing(self) -> float:\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\n num_pass = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: m.passed)\n .count(lambda p: bool(p) is True)\n )\n return float(100 * num_pass / num_meas)","def update_percent(self):","def calculate_percent(self, total_number, some_number):\n\t\treturn (some_number * 100) / total_number","def percent_of(part, whole):\n return part * 100 / whole","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def percentage(self):\n return sum(self.chunk_percentage) / self.total_steps","def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress","def percentage_progress(self):\n\n if self.total_progress != 0:\n return float(self.progress) / self.total_progress\n return self.progress","def _calculate_hours_percent(used_hours, estimated_hours):\n percent = (used_hours * 100) / estimated_hours\n return percent","def percent(self):\r\n return self._percent","def percent_processed(self):\n try:\n return (self.pos / self.data_encap.size) * 100.0\n except ZeroDivisionError:\n return 100.0","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def percent_usage(value, total):\n if total:\n return float(value) * 100.0 / (float(total) + float(value))\n else:\n return 100.0","def percent(value, total):\n if total:\n return float(value) * 100.0 / float(total)\n else:\n return 100.0","def strikeout_percentage_average(df,start_year, end_year,bat_met, player_name):\n\n base_fields = ['PA']\n emp_list = check_base_fields(df,base_fields)\n\n if not emp_list:\n k_val = round((pd.to_numeric(df['K.'].str.split('%').str[0])/100)*df['PA'],0).sum()\n pa_total = df['PA'].fillna(0).sum()\n return \"{:.2%}\".format(k_val / pa_total)\n else:\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\n return strikeout_percentage_average(df,start_year, end_year,bat_met, player_name)","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n #Between 1-8\n return own_moves / opp_moves","def _calculate_result(found, total):\n return (found * 100) / total","def percent(obj,object2):\n if object2:\n return int(float(int(obj))/object2*100)\n else:\n return 0","def get_song_percent_remaining(result):\n return int((1 - (get_song_elapsed_milliseconds(result) / get_song_length_milliseconds(result))) * 100)","def get_hit_percent(self, area, value):\n qs_related = RoundData.objects.prefetch_related(\n 'shotdata').select_related('shotdata')\n\n round_holes = int(self.round_type)\n\n if area == 'fairway':\n total_fairways = (int(self.round_type) -\n qs_related.filter(shotdata__hole__par=3).count())\n\n return round(qs_related.filter(shotdata__fairway_hit=value).count()/total_fairways, 2)\n\n if area == 'approach':\n return round(qs_related.filter(shotdata__gir_flag=value).count()/round_holes, 2)\n\n if area == 'putts':\n return round(qs_related.filter(shotdata__putt_accuracy=value).count()/round_holes, 2)","def pct_helper(self,k,d,total):\n if k in d:\n return 100.0*d[k]/total\n else:\n return -100.0","def set_effective_field_goal_percentage(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tcConv = float(bx[\"t2p_conv\"] + bx[\"t3p_conv\"])\n result = 0.00\n if tcInt > 0:\n result = ((tcConv + (0.5 * float(bx[\"t3p_conv\"]))) / tcInt) * 100\n self.effective_field_goal_percentage = \"%.2f\" % round(result, 2)","def calculate(self):\n\n s_sum = 0\n class_num = len(self.scores)\n \n for i in range(class_num):\n s_sum += self.scores[i]\n\n av = float(s_sum)/class_num\n if av >= 90:\n return 'O'\n elif av >= 80:\n return 'E'\n elif av >= 70:\n return 'A'\n elif av >= 55:\n return 'P'\n elif av >= 40:\n return 'D'\n else:\n return 'T'","def percentage(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"percentage\")","def GetResult(self, playerjm):\n return self.score / len(self.scores)","def health_percentage(self) -> Union[int, float]:\n if not self.proto.health_max:\n return 0\n return self.proto.health / self.proto.health_max","def health_percentage(self) -> Union[int, float]:\n if not self.proto.health_max:\n return 0\n return self.proto.health / self.proto.health_max","def percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"percentage\")","def displayed_percent(self):\n return (self.displayed_words / self.total_words) * 100","def custom_score(game, player):\n if game.is_loser(player):\n return -math.inf\n\n if game.is_winner(player):\n return math.inf\n\n opp_moves = game.get_legal_moves(game.get_opponent(player))\n own_moves = game.get_legal_moves(player)\n\n return len(own_moves) / max(len(opp_moves), 1e-6)","def pct_status(self):\r\n # DEPRECATED: self.info.n_answers will be removed\r\n # DEPRECATED: use self.t.n_answers instead\r\n if (self.info.get('n_answers')):\r\n self.n_answers = int(self.info['n_answers'])\r\n if self.n_answers != 0 and self.n_answers != None:\r\n return float(len(self.task_runs)) / self.n_answers\r\n else: # pragma: no cover\r\n return float(0)","def get_percent_completed(self):\n completed = self.object_list.filter(status__exact=True).count()\n total = len(self.object_list)\n return int(100 * completed / total) if total > 0 else 0","def set_usg_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n tcInt = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n a = tcInt + (Decimal('0.44')*bx[\"tl_int\"]) + bx[\"turnovers\"]\n b = team[\"minutes\"]/5\n c = (team[\"t2p_int\"] + team[\"t3p_int\"]) + (Decimal('0.44')*team[\"tl_int\"]) + team[\"turnovers\"]\n result = 0.00\n if bx[\"minutes\"] > 0:\n result = ((Decimal(a)*Decimal(b))/(bx[\"minutes\"]*c))*100\n self.usg_percentage = \"%.2f\" % round(result, 2)","def percentage_used(self):\n return self.volume_used/self.total_volume * 100.0","def set_ts_percentage(self):\n bx = self.get_standard_stats()\n ptos = float(bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n tsAttempts = float(tcInt + (0.44*float(bx[\"tl_int\"])))\n result = 0.00\n if tsAttempts > 0.00:\n result = (ptos/(2*tsAttempts))*100\n self.ts_percentage = \"%.2f\" % round(result, 2)","def get_percentage_practices(measure_table):\n with open(OUTPUT_DIR / \"practice_count.json\") as f:\n num_practices = json.load(f)[\"num_practices\"]\n\n num_practices_in_study = get_number_practices(measure_table)\n\n return np.round((num_practices_in_study / num_practices) * 100, 2)","def getGCpercentage(DNA):\n dnaLength = len(DNA) #counts the length of the DNA string\n findG = DNA.count(\"G\") #finds the letter G in DNA string\n findC = DNA.count(\"C\") #finds the letter C in DNA string\n print(findG)\n print(findC)\n print(dnaLength)\n GCpercent = ((findC + findG)/dnaLength) * 100 #calculates percentage of Gs and Cs\n print(\"Percentage of G and C:\",\" %6.2f\" % GCpercent)\n \n return getGCpercentage","def get_score_percent(self, value):\n qs_related = RoundData.objects.prefetch_related(\n 'shotdata').select_related('shotdata')\n\n round_holes = int(self.round_type)\n\n if value == 'par':\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'birdie_better':\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\n if value == 'tbogey_worse':\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\n if isinstance(value, int):\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)","def points_percentage(plane, p, points, total):\n match = 0\n for point in points:\n if distance_to_plane(plane, point) <= p:\n match += 1\n\n return match / total","def per(a):\n return a * 100","def letter_percent(s):\r\n\r\n alpha = 'abcdefghijklmnopqrstuvwxyz'\r\n s_lower = s.lower()\r\n s_length = 0\r\n letter_count = {} # empty dictionary\r\n keys = letter_count.keys()\r\n\r\n for char in s_lower:\r\n if char in alpha:\r\n s_length = s_length + 1\r\n if char in letter_count:\r\n letter_count[char] = letter_count[char] + 1\r\n else:\r\n letter_count[char] = 1\r\n\r\n for char in sorted(keys):\r\n letter_count[char] = (letter_count[char] / s_length) * 100\r\n print(char, \"{:.1f}%\".format(letter_count[char]))","def percentageCompletion(url, workflow, dataset):\n inputEvents = reqMgrClient.getInputEvents(url, workflow)\n outputEvents = reqMgrClient.getOutputEvents(url, workflow, dataset)\n if inputEvents == 0:\n return 0\n if not outputEvents:\n return 0\n percentage = outputEvents/float(inputEvents)\n return percentage","def calculate_progress_percentage(d):\n successcounter = 0\n for test in d:\n if d[test][\"status\"] != \"not yet run\":\n successcounter += 1\n totalcounter = 0\n for test in d:\n totalcounter += 1\n return int(successcounter / totalcounter * 100)","def p(party, vote_count, s):\n return t(party, vote_count) / d(s)","def percentage(x, y):\n try:\n return 100 * (float(x) / y)\n except ZeroDivisionError:\n return \"undefined\"","def percentage(my_list, item):\n return 100.0 * frequency(my_list, item)","def update_stats(home_player: Player, away_player: Player,\n home_score: int, away_score: int) -> None:\n home_player.goals_for += home_score\n home_player.goals_against += away_score\n away_player.goals_for += away_score\n away_player.goals_against += home_score\n\n # home won\n if (home_score > away_score):\n home_player.wins += 1\n away_player.losses += 1\n # away won\n elif (home_score < away_score):\n home_player.losses += 1\n away_player.wins += 1\n # draw\n else:\n home_player.draws += 1\n away_player.draws += 1","def occurance(row):\r\n # divide the row's highest counted cause by the row's total number of deaths\r\n percentage = row['max_count'] / row['all_count']\r\n percentage *= 100\r\n # round the percentage up so it's two digits\r\n return round(percentage)","def as_percentages(self):\n if self.e_pct is None:\n self.calculate_percentages()\n\n score_str = 'E/I: ' + str(self.e_pct) + '%/' + str(self.i_pct) + '%; '\n score_str += 'N/S: ' + str(self.n_pct) + '%/' + str(self.s_pct) + '%; '\n score_str += 'F/T: ' + str(self.f_pct) + '%/' + str(self.t_pct) + '%; '\n score_str += 'J/P: ' + str(self.j_pct) + '%/' + str(self.p_pct) + '%'\n return score_str","def calc_stats(hits, misses):\n try:\n result = (float(misses) / float(hits)) * 100.0\n except ZeroDivisionError:\n if misses == 0:\n result = 0.0\n else:\n result = 100.0\n return result","def calculatePercentChange(self, oldValue, newValue):\n return (((newValue - oldValue)/oldValue)*100)","def as_counts_and_pcts(self):\n if self.e_pct is None:\n self.calculate_percentages()\n\n score_str = 'E: ' + str(self.e_score) + '(' + str(self.e_pct) + '%)/'\n score_str += 'I: ' + str(self.i_score) + '(' + str(self.i_pct) + '%) - '\n score_str += 'N: ' + str(self.n_score) + '(' + str(self.n_pct) + '%)/'\n score_str += 'S: ' + str(self.s_score) + '(' + str(self.s_pct) + '%) - '\n score_str += 'F: ' + str(self.f_score) + '(' + str(self.f_pct) + '%)/'\n score_str += 'T: ' + str(self.t_score) + '(' + str(self.t_pct) + '%) - '\n score_str += 'J: ' + str(self.j_score) + '(' + str(self.j_pct) + '%)/'\n score_str += 'P: ' + str(self.p_score) + '(' + str(self.p_pct) + '%)'\n return score_str","def get_attendance(self):\n\n if len(self.attendance_list):\n attendance_sum = 0\n for attendance in self.attendance_list:\n attendance_sum += attendance.attendance_state\n return attendance_sum/len(self.attendance_list) * 100\n\n else:\n return 100.0","async def get_rob_percentage(level):\n chance = int(6 + (level // 10)) # first 10 levels is 6 for 30% chance\n if chance > 16:\n chance = 16\n return chance","def custom_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player) / 8\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n\n # Calculate centerness_score\n completeness = completeness_of_game(game)\n centerness_score = 0\n if completeness < 0.5:\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n own_centerness = centerness(game, player) / centerness_max\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def percent_frequencies(self):\n word_count = 0\n local = self.frequencies()\n for key in local.keys():\n i = local[key]\n word_count += int(i)\n for key in local.keys():\n i = local[key]\n percentage = float(i) / float(word_count)\n local[key] = percentage\n return local","def percent_rating(value):\n value = Decimal(value)\n value = round(value / 3, 2) * 100\n return value","def get_proficiency_percentage(self):\n choice_values = [choice[0] for choice in self.PROFICIENCY_CHOICES]\n if '' in choice_values:\n choice_values.remove('') # Remove the empty proficiency choice\n choice_values.sort() # Ensure values are in the correct order\n\n value = choice_values.index(self.proficiency) + 1\n factor = 100 / len(choice_values)\n percentage = round(value * factor)\n\n return percentage","def percent_raised(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.total_raised() * 100 / total_cost, 2)\n else:\n return 0","def value_to_percent(value):\n return ...","def percent_community(self):\n total_cost = self.total_cost()\n if total_cost:\n return round(self.community_contribution * 100 / total_cost, 2)\n else:\n return 0","def get_total_health(self,obs):\n total_health = 0\n for unit in obs.observation.raw_units:\n if(unit.alliance == PlayerRelative.SELF):\n total_health += unit[FeatureUnit.health]\n return total_health","def percentage(context, num, total_num):\n\n p = float(num)/float(total_num) * 100\n percent = str(p) + \"%\"\n return percent","def response_count_percentage(this_count):\n num_targets = db.session.query(ColourTargetColBG.id).count()\n return (this_count / num_targets) * 100.0","def represent_total_percent(self, length):\n numpkgs = self.totals['numpkgs']\n dlpkgs = self.totals['dlpkgs']\n return self.represent_percent(dlpkgs, numpkgs, length)","def percent_updated(self):\n return self.percent_complete - self.previous_percent_complete","def percent(num):\n return round(num * 100, 1)","def calculate_probability(self):\n return 0","def percentage_complete(self) -> float:\n return self.__percentage_complete","def availability(self, up_time=100, down_time=0, dec_point=3):\n self.up_time = up_time\n self.down_time = down_time\n self.dec_point = dec_point\n avail_percentage = round(float((up_time/(up_time+down_time))*100),dec_point) \n return avail_percentage","def find_percentage(urls):\n # n is the number of pages that lead to philosophy\n n = 0\n for url in urls:\n if find_philosophy(url, [], 0) != -1:\n n += 1\n percentage = n * 100 / len(urls)\n return percentage"],"string":"[\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def percentage(count, total):\\n return count / total * 100\",\n \"def getPercent(*args):\",\n \"def getPercent(*args):\",\n \"def set_assists_ratio(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n denominador = tcInt + (0.44 * float(bx[\\\"tl_int\\\"])) + float(bx[\\\"assists\\\"]) +float(bx[\\\"turnovers\\\"])\\n numerador = float(bx[\\\"assists\\\"])\\n result = 0.00\\n if denominador > 0:\\n result = (numerador / denominador) * 100\\n self.assists_ratio = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def percentage(a, b):\\n return (a * 100.0) / b\",\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def administer(self):\\n\\n score = 0.0\\n for question in self.questions:\\n if question.ask_and_evaluate() is True:\\n score += 1\\n return (score / len(self.questions)) * 100\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"def get_percentage(self):\\n return self.percentage\",\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def getPercent(self):\\n if isinstance(self.score,numbers.Number) and self.getMaximum():\\n return (1.0*self.score/self.getMaximum())\\n return None\",\n \"def set_assists_per_turnover(self):\\n bx = self.get_standard_stats()\\n ratio = bx[\\\"assists\\\"]\\n if bx[\\\"turnovers\\\"] > 0:\\n ratio = bx[\\\"assists\\\"] / bx[\\\"turnovers\\\"]\\n self.assists_per_turnover = \\\"%.2f\\\" % round(ratio, 2)\",\n \"def get_crawlera_incapsula_percent(crawlera_user):\\n if crawlera_user:\\n return 0\\n else:\\n return 100\",\n \"def percentage_update(self):\\n\\n self.event_update()\\n return self.percentage\",\n \"def get_percent(self):\\n return self.percent\",\n \"def as_percent(self):\\n if self.dynamic:\\n self._update_db_obj()\\n return f\\\"{(self._db_obj.progress / self._db_obj.total) * 100}%\\\"\",\n \"def walkout_percentage_average(df,start_year, end_year,bat_met, player_name):\\n base_fields = ['PA']\\n emp_list = check_base_fields(df,base_fields)\\n\\n if not emp_list:\\n bb_val = round((pd.to_numeric(df['BB.'].str.split('%').str[0])/100)*df['PA'],0).sum()\\n pa_total = df['PA'].fillna(0).sum()\\n return \\\"{:.2%}\\\".format(bb_val / pa_total)\\n else:\\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\\n return walkout_percentage_average(df,start_year, end_year,bat_met, player_name)\",\n \"def percentage(part, whole):\\n return round((100 * float(part)/float(whole)),2)\",\n \"def get_win_percentage(self) -> float:\\n if self.wins == 0:\\n return 0.0\\n else:\\n return round((self.wins / (self.wins + self.losses)) * 100, 2)\",\n \"def _percent(self, lines_total, lines_covered):\\n\\n if lines_total == 0:\\n return '0.0'\\n return str(float(float(lines_covered) / float(lines_total)))\",\n \"def percentCheck(currentTimeLabel, totalTimeLabel):\\n # Updated 11/19/16\\n try:\\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\\n except (ValueError , ZeroDivisionError):\\n progPercent = 0\\n \\n return progPercent\",\n \"def percent_passing(self) -> float:\\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\\n num_pass = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: m.passed)\\n .count(lambda p: bool(p) is True)\\n )\\n return float(100 * num_pass / num_meas)\",\n \"def update_percent(self):\",\n \"def calculate_percent(self, total_number, some_number):\\n\\t\\treturn (some_number * 100) / total_number\",\n \"def percent_of(part, whole):\\n return part * 100 / whole\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def percentage(self):\\n return sum(self.chunk_percentage) / self.total_steps\",\n \"def percentage_progress(self):\\n\\n if self.total_progress != 0:\\n return float(self.progress) / self.total_progress\\n return self.progress\",\n \"def percentage_progress(self):\\n\\n if self.total_progress != 0:\\n return float(self.progress) / self.total_progress\\n return self.progress\",\n \"def _calculate_hours_percent(used_hours, estimated_hours):\\n percent = (used_hours * 100) / estimated_hours\\n return percent\",\n \"def percent(self):\\r\\n return self._percent\",\n \"def percent_processed(self):\\n try:\\n return (self.pos / self.data_encap.size) * 100.0\\n except ZeroDivisionError:\\n return 100.0\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def percent_usage(value, total):\\n if total:\\n return float(value) * 100.0 / (float(total) + float(value))\\n else:\\n return 100.0\",\n \"def percent(value, total):\\n if total:\\n return float(value) * 100.0 / float(total)\\n else:\\n return 100.0\",\n \"def strikeout_percentage_average(df,start_year, end_year,bat_met, player_name):\\n\\n base_fields = ['PA']\\n emp_list = check_base_fields(df,base_fields)\\n\\n if not emp_list:\\n k_val = round((pd.to_numeric(df['K.'].str.split('%').str[0])/100)*df['PA'],0).sum()\\n pa_total = df['PA'].fillna(0).sum()\\n return \\\"{:.2%}\\\".format(k_val / pa_total)\\n else:\\n df = original_dataframe(start_year,end_year,bat_met+emp_list,player_name)\\n return strikeout_percentage_average(df,start_year, end_year,bat_met, player_name)\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n #Between 1-8\\n return own_moves / opp_moves\",\n \"def _calculate_result(found, total):\\n return (found * 100) / total\",\n \"def percent(obj,object2):\\n if object2:\\n return int(float(int(obj))/object2*100)\\n else:\\n return 0\",\n \"def get_song_percent_remaining(result):\\n return int((1 - (get_song_elapsed_milliseconds(result) / get_song_length_milliseconds(result))) * 100)\",\n \"def get_hit_percent(self, area, value):\\n qs_related = RoundData.objects.prefetch_related(\\n 'shotdata').select_related('shotdata')\\n\\n round_holes = int(self.round_type)\\n\\n if area == 'fairway':\\n total_fairways = (int(self.round_type) -\\n qs_related.filter(shotdata__hole__par=3).count())\\n\\n return round(qs_related.filter(shotdata__fairway_hit=value).count()/total_fairways, 2)\\n\\n if area == 'approach':\\n return round(qs_related.filter(shotdata__gir_flag=value).count()/round_holes, 2)\\n\\n if area == 'putts':\\n return round(qs_related.filter(shotdata__putt_accuracy=value).count()/round_holes, 2)\",\n \"def pct_helper(self,k,d,total):\\n if k in d:\\n return 100.0*d[k]/total\\n else:\\n return -100.0\",\n \"def set_effective_field_goal_percentage(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tcConv = float(bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"])\\n result = 0.00\\n if tcInt > 0:\\n result = ((tcConv + (0.5 * float(bx[\\\"t3p_conv\\\"]))) / tcInt) * 100\\n self.effective_field_goal_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def calculate(self):\\n\\n s_sum = 0\\n class_num = len(self.scores)\\n \\n for i in range(class_num):\\n s_sum += self.scores[i]\\n\\n av = float(s_sum)/class_num\\n if av >= 90:\\n return 'O'\\n elif av >= 80:\\n return 'E'\\n elif av >= 70:\\n return 'A'\\n elif av >= 55:\\n return 'P'\\n elif av >= 40:\\n return 'D'\\n else:\\n return 'T'\",\n \"def percentage(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"percentage\\\")\",\n \"def GetResult(self, playerjm):\\n return self.score / len(self.scores)\",\n \"def health_percentage(self) -> Union[int, float]:\\n if not self.proto.health_max:\\n return 0\\n return self.proto.health / self.proto.health_max\",\n \"def health_percentage(self) -> Union[int, float]:\\n if not self.proto.health_max:\\n return 0\\n return self.proto.health / self.proto.health_max\",\n \"def percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"percentage\\\")\",\n \"def displayed_percent(self):\\n return (self.displayed_words / self.total_words) * 100\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return -math.inf\\n\\n if game.is_winner(player):\\n return math.inf\\n\\n opp_moves = game.get_legal_moves(game.get_opponent(player))\\n own_moves = game.get_legal_moves(player)\\n\\n return len(own_moves) / max(len(opp_moves), 1e-6)\",\n \"def pct_status(self):\\r\\n # DEPRECATED: self.info.n_answers will be removed\\r\\n # DEPRECATED: use self.t.n_answers instead\\r\\n if (self.info.get('n_answers')):\\r\\n self.n_answers = int(self.info['n_answers'])\\r\\n if self.n_answers != 0 and self.n_answers != None:\\r\\n return float(len(self.task_runs)) / self.n_answers\\r\\n else: # pragma: no cover\\r\\n return float(0)\",\n \"def get_percent_completed(self):\\n completed = self.object_list.filter(status__exact=True).count()\\n total = len(self.object_list)\\n return int(100 * completed / total) if total > 0 else 0\",\n \"def set_usg_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n tcInt = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n a = tcInt + (Decimal('0.44')*bx[\\\"tl_int\\\"]) + bx[\\\"turnovers\\\"]\\n b = team[\\\"minutes\\\"]/5\\n c = (team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]) + (Decimal('0.44')*team[\\\"tl_int\\\"]) + team[\\\"turnovers\\\"]\\n result = 0.00\\n if bx[\\\"minutes\\\"] > 0:\\n result = ((Decimal(a)*Decimal(b))/(bx[\\\"minutes\\\"]*c))*100\\n self.usg_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def percentage_used(self):\\n return self.volume_used/self.total_volume * 100.0\",\n \"def set_ts_percentage(self):\\n bx = self.get_standard_stats()\\n ptos = float(bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n tsAttempts = float(tcInt + (0.44*float(bx[\\\"tl_int\\\"])))\\n result = 0.00\\n if tsAttempts > 0.00:\\n result = (ptos/(2*tsAttempts))*100\\n self.ts_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def get_percentage_practices(measure_table):\\n with open(OUTPUT_DIR / \\\"practice_count.json\\\") as f:\\n num_practices = json.load(f)[\\\"num_practices\\\"]\\n\\n num_practices_in_study = get_number_practices(measure_table)\\n\\n return np.round((num_practices_in_study / num_practices) * 100, 2)\",\n \"def getGCpercentage(DNA):\\n dnaLength = len(DNA) #counts the length of the DNA string\\n findG = DNA.count(\\\"G\\\") #finds the letter G in DNA string\\n findC = DNA.count(\\\"C\\\") #finds the letter C in DNA string\\n print(findG)\\n print(findC)\\n print(dnaLength)\\n GCpercent = ((findC + findG)/dnaLength) * 100 #calculates percentage of Gs and Cs\\n print(\\\"Percentage of G and C:\\\",\\\" %6.2f\\\" % GCpercent)\\n \\n return getGCpercentage\",\n \"def get_score_percent(self, value):\\n qs_related = RoundData.objects.prefetch_related(\\n 'shotdata').select_related('shotdata')\\n\\n round_holes = int(self.round_type)\\n\\n if value == 'par':\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'birdie_better':\\n return round((qs_related.filter(shotdata__nr_strokes__lt=F('shotdata__hole__par')).count()/round_holes), 2)\\n if value == 'tbogey_worse':\\n return round((qs_related.filter(shotdata__nr_strokes__gte=F('shotdata__hole__par')+3).count()/round_holes), 2)\\n if isinstance(value, int):\\n return round((qs_related.filter(shotdata__nr_strokes=F('shotdata__hole__par') + value).count()/round_holes), 2)\",\n \"def points_percentage(plane, p, points, total):\\n match = 0\\n for point in points:\\n if distance_to_plane(plane, point) <= p:\\n match += 1\\n\\n return match / total\",\n \"def per(a):\\n return a * 100\",\n \"def letter_percent(s):\\r\\n\\r\\n alpha = 'abcdefghijklmnopqrstuvwxyz'\\r\\n s_lower = s.lower()\\r\\n s_length = 0\\r\\n letter_count = {} # empty dictionary\\r\\n keys = letter_count.keys()\\r\\n\\r\\n for char in s_lower:\\r\\n if char in alpha:\\r\\n s_length = s_length + 1\\r\\n if char in letter_count:\\r\\n letter_count[char] = letter_count[char] + 1\\r\\n else:\\r\\n letter_count[char] = 1\\r\\n\\r\\n for char in sorted(keys):\\r\\n letter_count[char] = (letter_count[char] / s_length) * 100\\r\\n print(char, \\\"{:.1f}%\\\".format(letter_count[char]))\",\n \"def percentageCompletion(url, workflow, dataset):\\n inputEvents = reqMgrClient.getInputEvents(url, workflow)\\n outputEvents = reqMgrClient.getOutputEvents(url, workflow, dataset)\\n if inputEvents == 0:\\n return 0\\n if not outputEvents:\\n return 0\\n percentage = outputEvents/float(inputEvents)\\n return percentage\",\n \"def calculate_progress_percentage(d):\\n successcounter = 0\\n for test in d:\\n if d[test][\\\"status\\\"] != \\\"not yet run\\\":\\n successcounter += 1\\n totalcounter = 0\\n for test in d:\\n totalcounter += 1\\n return int(successcounter / totalcounter * 100)\",\n \"def p(party, vote_count, s):\\n return t(party, vote_count) / d(s)\",\n \"def percentage(x, y):\\n try:\\n return 100 * (float(x) / y)\\n except ZeroDivisionError:\\n return \\\"undefined\\\"\",\n \"def percentage(my_list, item):\\n return 100.0 * frequency(my_list, item)\",\n \"def update_stats(home_player: Player, away_player: Player,\\n home_score: int, away_score: int) -> None:\\n home_player.goals_for += home_score\\n home_player.goals_against += away_score\\n away_player.goals_for += away_score\\n away_player.goals_against += home_score\\n\\n # home won\\n if (home_score > away_score):\\n home_player.wins += 1\\n away_player.losses += 1\\n # away won\\n elif (home_score < away_score):\\n home_player.losses += 1\\n away_player.wins += 1\\n # draw\\n else:\\n home_player.draws += 1\\n away_player.draws += 1\",\n \"def occurance(row):\\r\\n # divide the row's highest counted cause by the row's total number of deaths\\r\\n percentage = row['max_count'] / row['all_count']\\r\\n percentage *= 100\\r\\n # round the percentage up so it's two digits\\r\\n return round(percentage)\",\n \"def as_percentages(self):\\n if self.e_pct is None:\\n self.calculate_percentages()\\n\\n score_str = 'E/I: ' + str(self.e_pct) + '%/' + str(self.i_pct) + '%; '\\n score_str += 'N/S: ' + str(self.n_pct) + '%/' + str(self.s_pct) + '%; '\\n score_str += 'F/T: ' + str(self.f_pct) + '%/' + str(self.t_pct) + '%; '\\n score_str += 'J/P: ' + str(self.j_pct) + '%/' + str(self.p_pct) + '%'\\n return score_str\",\n \"def calc_stats(hits, misses):\\n try:\\n result = (float(misses) / float(hits)) * 100.0\\n except ZeroDivisionError:\\n if misses == 0:\\n result = 0.0\\n else:\\n result = 100.0\\n return result\",\n \"def calculatePercentChange(self, oldValue, newValue):\\n return (((newValue - oldValue)/oldValue)*100)\",\n \"def as_counts_and_pcts(self):\\n if self.e_pct is None:\\n self.calculate_percentages()\\n\\n score_str = 'E: ' + str(self.e_score) + '(' + str(self.e_pct) + '%)/'\\n score_str += 'I: ' + str(self.i_score) + '(' + str(self.i_pct) + '%) - '\\n score_str += 'N: ' + str(self.n_score) + '(' + str(self.n_pct) + '%)/'\\n score_str += 'S: ' + str(self.s_score) + '(' + str(self.s_pct) + '%) - '\\n score_str += 'F: ' + str(self.f_score) + '(' + str(self.f_pct) + '%)/'\\n score_str += 'T: ' + str(self.t_score) + '(' + str(self.t_pct) + '%) - '\\n score_str += 'J: ' + str(self.j_score) + '(' + str(self.j_pct) + '%)/'\\n score_str += 'P: ' + str(self.p_score) + '(' + str(self.p_pct) + '%)'\\n return score_str\",\n \"def get_attendance(self):\\n\\n if len(self.attendance_list):\\n attendance_sum = 0\\n for attendance in self.attendance_list:\\n attendance_sum += attendance.attendance_state\\n return attendance_sum/len(self.attendance_list) * 100\\n\\n else:\\n return 100.0\",\n \"async def get_rob_percentage(level):\\n chance = int(6 + (level // 10)) # first 10 levels is 6 for 30% chance\\n if chance > 16:\\n chance = 16\\n return chance\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player) / 8\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n\\n # Calculate centerness_score\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n if completeness < 0.5:\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n own_centerness = centerness(game, player) / centerness_max\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def percent_frequencies(self):\\n word_count = 0\\n local = self.frequencies()\\n for key in local.keys():\\n i = local[key]\\n word_count += int(i)\\n for key in local.keys():\\n i = local[key]\\n percentage = float(i) / float(word_count)\\n local[key] = percentage\\n return local\",\n \"def percent_rating(value):\\n value = Decimal(value)\\n value = round(value / 3, 2) * 100\\n return value\",\n \"def get_proficiency_percentage(self):\\n choice_values = [choice[0] for choice in self.PROFICIENCY_CHOICES]\\n if '' in choice_values:\\n choice_values.remove('') # Remove the empty proficiency choice\\n choice_values.sort() # Ensure values are in the correct order\\n\\n value = choice_values.index(self.proficiency) + 1\\n factor = 100 / len(choice_values)\\n percentage = round(value * factor)\\n\\n return percentage\",\n \"def percent_raised(self):\\n total_cost = self.total_cost()\\n if total_cost:\\n return round(self.total_raised() * 100 / total_cost, 2)\\n else:\\n return 0\",\n \"def value_to_percent(value):\\n return ...\",\n \"def percent_community(self):\\n total_cost = self.total_cost()\\n if total_cost:\\n return round(self.community_contribution * 100 / total_cost, 2)\\n else:\\n return 0\",\n \"def get_total_health(self,obs):\\n total_health = 0\\n for unit in obs.observation.raw_units:\\n if(unit.alliance == PlayerRelative.SELF):\\n total_health += unit[FeatureUnit.health]\\n return total_health\",\n \"def percentage(context, num, total_num):\\n\\n p = float(num)/float(total_num) * 100\\n percent = str(p) + \\\"%\\\"\\n return percent\",\n \"def response_count_percentage(this_count):\\n num_targets = db.session.query(ColourTargetColBG.id).count()\\n return (this_count / num_targets) * 100.0\",\n \"def represent_total_percent(self, length):\\n numpkgs = self.totals['numpkgs']\\n dlpkgs = self.totals['dlpkgs']\\n return self.represent_percent(dlpkgs, numpkgs, length)\",\n \"def percent_updated(self):\\n return self.percent_complete - self.previous_percent_complete\",\n \"def percent(num):\\n return round(num * 100, 1)\",\n \"def calculate_probability(self):\\n return 0\",\n \"def percentage_complete(self) -> float:\\n return self.__percentage_complete\",\n \"def availability(self, up_time=100, down_time=0, dec_point=3):\\n self.up_time = up_time\\n self.down_time = down_time\\n self.dec_point = dec_point\\n avail_percentage = round(float((up_time/(up_time+down_time))*100),dec_point) \\n return avail_percentage\",\n \"def find_percentage(urls):\\n # n is the number of pages that lead to philosophy\\n n = 0\\n for url in urls:\\n if find_philosophy(url, [], 0) != -1:\\n n += 1\\n percentage = n * 100 / len(urls)\\n return percentage\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7001746","0.68421483","0.6813","0.67631215","0.67387015","0.6656908","0.6627645","0.6627645","0.6618226","0.6604493","0.66013306","0.6542234","0.6510403","0.64416814","0.64405453","0.64405453","0.64318055","0.64273596","0.63814425","0.63652843","0.6354084","0.6325873","0.6309475","0.6297875","0.6286082","0.6275193","0.62622076","0.62381136","0.62343794","0.62315017","0.62289983","0.62277","0.62006307","0.61964226","0.61886334","0.6177423","0.6177423","0.6175648","0.61690426","0.61596674","0.61416525","0.6138142","0.6120936","0.60969883","0.60961986","0.6091701","0.6087901","0.60828185","0.60672575","0.60376185","0.6017559","0.60148805","0.60108364","0.6005199","0.6003304","0.6003304","0.59943","0.5990661","0.5978797","0.59784144","0.59780824","0.5977875","0.596515","0.5952","0.5937085","0.59344935","0.59332335","0.593103","0.59262705","0.5916972","0.5906936","0.5906773","0.5893445","0.58924633","0.58739084","0.5867139","0.58595276","0.58591443","0.5854312","0.58542645","0.5851259","0.58385366","0.5837661","0.58244866","0.5823833","0.5818401","0.5812386","0.5807664","0.5786824","0.5781525","0.5780029","0.57776797","0.57698756","0.57646286","0.57612747","0.5758602","0.5756928","0.5751051","0.5739429","0.5738761"],"string":"[\n \"0.7001746\",\n \"0.68421483\",\n \"0.6813\",\n \"0.67631215\",\n \"0.67387015\",\n \"0.6656908\",\n \"0.6627645\",\n \"0.6627645\",\n \"0.6618226\",\n \"0.6604493\",\n \"0.66013306\",\n \"0.6542234\",\n \"0.6510403\",\n \"0.64416814\",\n \"0.64405453\",\n \"0.64405453\",\n \"0.64318055\",\n \"0.64273596\",\n \"0.63814425\",\n \"0.63652843\",\n \"0.6354084\",\n \"0.6325873\",\n \"0.6309475\",\n \"0.6297875\",\n \"0.6286082\",\n \"0.6275193\",\n \"0.62622076\",\n \"0.62381136\",\n \"0.62343794\",\n \"0.62315017\",\n \"0.62289983\",\n \"0.62277\",\n \"0.62006307\",\n \"0.61964226\",\n \"0.61886334\",\n \"0.6177423\",\n \"0.6177423\",\n \"0.6175648\",\n \"0.61690426\",\n \"0.61596674\",\n \"0.61416525\",\n \"0.6138142\",\n \"0.6120936\",\n \"0.60969883\",\n \"0.60961986\",\n \"0.6091701\",\n \"0.6087901\",\n \"0.60828185\",\n \"0.60672575\",\n \"0.60376185\",\n \"0.6017559\",\n \"0.60148805\",\n \"0.60108364\",\n \"0.6005199\",\n \"0.6003304\",\n \"0.6003304\",\n \"0.59943\",\n \"0.5990661\",\n \"0.5978797\",\n \"0.59784144\",\n \"0.59780824\",\n \"0.5977875\",\n \"0.596515\",\n \"0.5952\",\n \"0.5937085\",\n \"0.59344935\",\n \"0.59332335\",\n \"0.593103\",\n \"0.59262705\",\n \"0.5916972\",\n \"0.5906936\",\n \"0.5906773\",\n \"0.5893445\",\n \"0.58924633\",\n \"0.58739084\",\n \"0.5867139\",\n \"0.58595276\",\n \"0.58591443\",\n \"0.5854312\",\n \"0.58542645\",\n \"0.5851259\",\n \"0.58385366\",\n \"0.5837661\",\n \"0.58244866\",\n \"0.5823833\",\n \"0.5818401\",\n \"0.5812386\",\n \"0.5807664\",\n \"0.5786824\",\n \"0.5781525\",\n \"0.5780029\",\n \"0.57776797\",\n \"0.57698756\",\n \"0.57646286\",\n \"0.57612747\",\n \"0.5758602\",\n \"0.5756928\",\n \"0.5751051\",\n \"0.5739429\",\n \"0.5738761\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.767859"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3097,"cells":{"query":{"kind":"string","value":"Method which calculate Ratio Assists Per Turnover of a player"},"document":{"kind":"string","value":"def set_assists_per_turnover(self):\n bx = self.get_standard_stats()\n ratio = bx[\"assists\"]\n if bx[\"turnovers\"] > 0:\n ratio = bx[\"assists\"] / bx[\"turnovers\"]\n self.assists_per_turnover = \"%.2f\" % round(ratio, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def set_assists_ratio(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n denominador = tcInt + (0.44 * float(bx[\"tl_int\"])) + float(bx[\"assists\"]) +float(bx[\"turnovers\"])\n numerador = float(bx[\"assists\"])\n result = 0.00\n if denominador > 0:\n result = (numerador / denominador) * 100\n self.assists_ratio = \"%.2f\" % round(result, 2)","def winrate(matches):\n if not matches:\n print('no matches')\n return None\n\n win_loss = [match['result'] for match in matches]\n return sum(win_loss)/len(win_loss)","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def score(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= SQUARE_WEIGHTS[i]\r\n else:\r\n numOpp+=SQUARE_WEIGHTS[i]\r\n return numPlayer-numOpp","def mc_update_scores(scores, board, player):\n dim = board.get_dim()\n winner = board.check_win()\n other_player = provided.switch_player(player)\n \n if winner == provided.DRAW:\n ratio = {player: 0, other_player: 0, 1: 0}\n elif winner == player:\n ratio = {player: 0 + SCORE_CURRENT, other_player: 0 - SCORE_OTHER, provided.EMPTY: 0}\n elif winner == other_player:\n ratio = {player: 0 - SCORE_CURRENT, other_player: 0 + SCORE_OTHER, provided.EMPTY: 0}\t\n \n for valx in range(dim):\n for valy in range(dim): \n scores[valx][valy] += ratio[board.square(valx, valy)] \n return scores","def custom_score_2(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # shortcut to definite state:\n # 1. my agent win -> return very high score\n if opp_moves == 0:\n return float(\"inf\")\n # 2. opponenent's agent win -> return very low score\n elif own_moves == 0:\n return float(\"-inf\")\n\n # score: avaliable moves ratio\n return float(own_moves/opp_moves)","def calculateWinRate():\n times = 10\n winRate = 0.0\n for i in range(times):\n game = Game('user', 6, 6)\n winRate += game.play(5, False, True, False, False)\n winRate = winRate/times\n print \"Winrate:\", winRate","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def get_win_percentage(self) -> float:\n if self.wins == 0:\n return 0.0\n else:\n return round((self.wins / (self.wins + self.losses)) * 100, 2)","def set_assists_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n team_tc_conv = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n player_tc_conv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0:\n result = (bx[\"assists\"] / (((bx[\"minutes\"] / (team[\"minutes\"] / 5)) * team_tc_conv) - player_tc_conv))*100\n result = result if result <= 100 and result >= 0 else 0\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.assists_percentage = \"%.2f\" % round(result, 2)","def calc_match_points(self, match):\n if match.winner == match.TIE:\n match.home.tournament_score += 1\n match.away.tournament_score += 1\n else:\n match.winner.tournament_score += 3\n match.loser.tournament_score += 0","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n #Between 1-8\n return own_moves / opp_moves","def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def custom_score(game, player):\n if game.is_loser(player):\n return -math.inf\n\n if game.is_winner(player):\n return math.inf\n\n opp_moves = game.get_legal_moves(game.get_opponent(player))\n own_moves = game.get_legal_moves(player)\n\n return len(own_moves) / max(len(opp_moves), 1e-6)","def cal_hit_ratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n score = 0.0\n # golden items hit in the top_K items\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\n score = score_1 - score_2\n return score/full['user'].nunique()","def custom_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player) / 8\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n\n # Calculate centerness_score\n completeness = completeness_of_game(game)\n centerness_score = 0\n if completeness < 0.5:\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n own_centerness = centerness(game, player) / centerness_max\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def win_ratio_avg(self):\n win_ratio = 0\n # Adds all the win ratios of team in this conference which will be\n # used to compute the win ratio average.\n for team_obj in self._conf_teams:\n ### INVARIANT: team_obj is a Team class object and\n ### self._conf_teams is a list of Team class objects.\n win_ratio += team_obj._win_ratio\n return win_ratio/len(self._conf_teams)","def winRate(DF):\r\n df = DF[\"return\"]\r\n pos = df[df>1]\r\n neg = df[df<1]\r\n return (len(pos) / len(pos + neg)) * 100","def custom_score_6(game, player):\n \"\"\"custom_score_6 heuristic function aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)","def average_win_rate(strategy, baseline=always_roll(4)):\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\n\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2","def average_win_rate(strategy, baseline=always_roll(4)):\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\n\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2","def average_win_rate(strategy, baseline=always_roll(4)):\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\n\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2","def rate_board(board, player):\n approx_player_moves = sum(\n len(_get_empty_neighbors((i, j), board))\n for i in range(5)\n for j in range(5)\n if board[i][j] == player\n )\n approx_opponent_moves = sum(\n len(_get_empty_neighbors((i, j), board))\n for i in range(5)\n for j in range(5)\n if board[i][j] == -player\n )\n return approx_player_moves - approx_opponent_moves","def weighted_score(player, board):\n opp = Othello.opponent(player)\n total = 0\n for sq in Othello.squares():\n if board[sq] == player:\n total += SQUARE_WEIGHTS[sq]\n elif board[sq] == opp:\n total -= SQUARE_WEIGHTS[sq]\n return total","def eval(self):\n\n ratio_player_win = self.player_wins / self.num_test\n ratio_opponent_win = self.opponent_wins / self.num_test\n ratio_tie = 1.0 - ratio_player_win - ratio_opponent_win\n\n print(\"\\nPlayer Test Results:\")\n print(\"\\tWins {0:.2f}%\".format(100.0 * ratio_player_win))\n print(\"\\tLosses {0:.2f}%\".format(100.0 * ratio_opponent_win))\n print(\"\\tTie {0:.2f}%\".format(100.0 * ratio_tie))\n\n ratio_optimal_win = self.optimal_wins / self.num_test\n ratio_optimal_loose = self.optimal_losses / self.num_test\n ratio_optimal_tie = 1.0 - ratio_optimal_win - ratio_optimal_loose\n\n print(\"\\nOptimal Results:\")\n print(\"\\tPlayer {0:.2f}%\".format(100.0 * ratio_optimal_win))\n print(\"\\tOpponent {0:.2f}%\".format(100.0 * ratio_optimal_loose))\n print(\"\\tTie {0:.2f}%\".format(100.0 * ratio_optimal_tie))\n\n # Ratio of win, loss diff between player and optimal\n # positive if the player beats opponent\n relative_result = ((ratio_player_win - ratio_opponent_win) /\n (ratio_optimal_win - ratio_optimal_loose))\n\n print(\"\\nResults Player Relative Optimal:\")\n print(\"\\tWins {0:.2f}%\".format(100.0 * ratio_player_win / ratio_optimal_win))\n print(\"\\tLosses {0:.2f}%\".format(100.0 * ratio_opponent_win / ratio_optimal_loose))\n print(\"\\tScore {0:.2f}%\".format(100.0 * relative_result))\n\n if self.last_test is not None:\n print(\"Diff from last test score is {0:.2f}%\".format(100.0 * (relative_result - self.last_test)))\n self.last_test = relative_result","def compute_score(window, computer_piece):\n score = 0\n if window.count(computer_piece) == 4:\n score += 100\n elif window.count(computer_piece) == 3 and window.count(0) == 1:\n score += 5\n elif window.count(computer_piece) == 2 and window.count(0) == 2:\n score += 2\n if window.count(PLAYER_PIECE) == 2 and window.count(0) == 2:\n score -= 1\n if window.count(PLAYER_PIECE) == 3 and window.count(0) == 1:\n score -= 100\n return score","def custom_score_3(game, player):\n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # shortcut to definite state:\n # 1. my agent win -> return very high score\n if opp_moves == 0:\n return float(\"inf\")\n # 2. opponenent's agent win -> return very low score\n elif own_moves == 0:\n return float(\"-inf\")\n\n # score: log of avaliable moves ratio\n return float(log(own_moves/opp_moves))","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = own_moves / opp_moves\n\n completeness = completeness_of_game(game)\n centerness_score = 0\n\n if completeness < 0.5:\n own_centerness = centerness(game, player)\n opp_centerness = centerness(game, game.get_opponent(player))\n centerness_ratio = own_centerness / opp_centerness + 0.1\n\n center_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def calculate_my_win_strength(self):\n self.winStrength = self.strategy(deepcopy(self.currentBoardState))","def set_offensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0 and (bx[\"t2p_int\"] + bx[\"t3p_int\"]) > 0:\n fgm = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n fga = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n team_fgm = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n team_fga = team[\"t2p_int\"] + team[\"t3p_int\"]\n team_points = team[\"t2p_conv\"]*2 + team[\"t3p_conv\"]*3 + team[\"tl_conv\"]\n points = bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"]\n\n try:\n qAST = (Decimal(bx[\"minutes\"] / (team[\"minutes\"] / 5)) * (Decimal('1.14') * Decimal((team[\"assists\"] - bx[\"assists\"]) / team_fgm))) + \\\n Decimal((((team[\"assists\"] / team[\"minutes\"]) * bx[\"minutes\"] * 5 - bx[\"assists\"]) / ((team_fgm / team[\"minutes\"]) * bx[\"minutes\"] * 5 - fgm)) * (1 - (bx[\"minutes\"] / (team[\"minutes\"] / 5))))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n qAST = 1\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n qAST = 1\n\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2*(team_fga - fga))) * bx[\"assists\"]\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n ast_part = 0\n\n if bx[\"tl_int\"] > 0:\n ft_part = Decimal(1 - (1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_part = 0\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\"tl_conv\"] / team[\"tl_int\"]))**2) * team[\"tl_int\"] * Decimal('0.4'))\n try:\n team_orb_percentage = Decimal(team[\"reb_of\"] / (team[\"reb_of\"] + ((opp_team[\"reb_def\"] + opp_team[\"reb_of\"]) - opp_team[\"reb_of\"])))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\"tl_int\"] * Decimal('0.4') + team[\"turnovers\"]))\n try:\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_weight = 0\n\n orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage\n\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\n if bx[\"tl_conv\"] > 0:\n ft_x_poss = Decimal((1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_x_poss = Decimal(1 - (bx[\"tl_conv\"] / 1)**2) * Decimal('0.4') * bx[\"tl_int\"]\n try:\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n sc_poss =0\n\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\"turnovers\"]\n\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\"t3p_conv\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\"t3p_conv\"] - bx[\"t3p_conv\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2 * (team_fga - fga))) * bx[\"assists\"]\n except:\n pprod_ast_part = 0\n\n pprod_orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\"tl_conv\"] / team[\"tl_int\"])**2) * Decimal('0.4') * team[\"tl_int\"]))\n try:\n pprod = (pprod_fg_part + pprod_ast_part + bx[\"tl_conv\"]) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n pprod = 0\n\n try:\n result = 100 * (pprod / tot_poss)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n result = 0\n\n # print(\"fgm: \" + str(fgm))\n # print(\"fga: \" + str(fga))\n # print(\"team_fgm: \" + str(team_fgm))\n # print(\"team_fga: \" + str(team_fga))\n # print(\"team_points: \" + str(team_points))\n # print(\"points: \" + str(points))\n # print(\"qAST: \" + str(qAST))\n # print(\"fg_part: \" + str(fg_part))\n # print(\"ast_part: \" + str(ast_part))\n # print(\"ft_part: \" + str(ft_part))\n # print(\"team_scoring_poss: \" + str(team_scoring_poss))\n # print(\"team_orb_percentage: \" + str(team_orb_percentage))\n # print(\"team_play_percentage: \" + str(team_play_percentage))\n # print(\"team_orb_weight: \" + str(team_orb_weight))\n # print(\"orb_part: \" + str(orb_part))\n # print(\"fg_x_poss: \" + str(fg_x_poss))\n # print(\"ft_x_poss: \" + str(ft_x_poss))\n # print(\"sc_poss: \" + str(sc_poss))\n # print(\"tot_poss: \" + str(tot_poss))\n # print(\"pprod_fg_part: \" + str(pprod_fg_part))\n # print(\"pprod_ast_part: \" + str(pprod_ast_part))\n # print(\"pprod_orb_part: \" + str(pprod_orb_part))\n # print(\"pprod: \" + str(pprod))\n # print(\"result: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n\n self.ortg = \"%.2f\" % round(result, 2)\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\n \"\"\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \n using team's formula\"\"\"\n print(BCOLORS.OKBLUE + \"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\" + BCOLORS.ENDC)\n bx = self.get_standard_stats()\n result = round((bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])/self.get_team_possessions(), 2)\n self.ortg = \"%.2f\" % result","def custom_score_5(game, player):\n \"\"\"custom_score_5 heuristic function defines chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def custom_score_3(game, player):\n if game.is_loser(player):\n return -math.inf\n\n if game.is_winner(player):\n return math.inf\n\n opponent = game.get_opponent(player)\n\n opp_moves = game.get_legal_moves(opponent)\n own_moves = game.get_legal_moves(player)\n\n # Calculate the normalized distance if both players are on the board.\n player_loc = game.get_player_location(player)\n opp_loc = game.get_player_location(opponent)\n norm_dis = 0\n if opp_loc and player_loc:\n norm_dis = distance(player_loc, opp_loc) / 8.46 # 8.46 is distance((0, 0), (6, 6))\n\n return len(own_moves) / max(len(opp_moves), 1e-6) - norm_dis","def evaluate(self, state):\n\t\ttranspose = state.board.transpose()\t\t# columns in state.board = rows in transpose\n\t\tcount = []\n\t\topponentcount = []\n\t\tfor row, column in zip(state.board, transpose):\n\t\t\trowcounter = collections.Counter(row)\n\t\t\tcolumncounter = collections.Counter(column)\n\t\t\tcount.append(rowcounter.get(state.current_player, 0))\n\t\t\tcount.append(columncounter.get(state.current_player, 0))\n\t\t\topponentcount.append(rowcounter.get(state.current_player * - 1, 0))\n\t\t\topponentcount.append(columncounter.get(state.current_player * -1 , 0))\n\n\t\tY = state.board[:, ::-1]\n\t\tdiagonals = [np.diagonal(state.board), np.diagonal(Y)]\n\t\tmain_diagonal_count = collections.Counter(diagonals[0])\n\t\tsecond_diagonal_count = collections.Counter(diagonals[1])\n\t\tcount.append(main_diagonal_count.get(state.current_player, 0))\n\t\tcount.append(second_diagonal_count.get(state.current_player, 0))\n\t\topponentcount.append(main_diagonal_count.get(state.current_player * - 1, 0))\n\t\topponentcount.append(second_diagonal_count.get(state.current_player * -1, 0))\n\n\t\t# max(count): maximum number of player's tiles in a row, column, or a diagonal (the highest value is 5)\n\t\t# max(opponentcount): maximum number of opponent's tiles in a row, column, or a diagonal (the highest value is 5)\n\t\tscoremax = 5 ** max(count)\n\t\tscoremin = 5 ** max(opponentcount)\n\n\t\treturn scoremax - scoremin","def _estimate_strength_from_results(\n number_of_games: int, number_of_wins: int, opponent_rating: float\n) -> Tuple[float, Tuple[float, float]]:\n n, p = number_of_games, number_of_wins / number_of_games\n q = 1 - p\n\n if n * p * q < 9: # Cannot apply normal approximation of binomial distribution\n raise ValueError(\n \"The results obtained in evaluate_player are too extreme to obtain an \"\n \"accurate player evaluation. You can try to solve this issue by increasing\"\n \" the total number of battles. Obtained results: %d victories out of %d\"\n \" games.\" % (p * n, n)\n )\n\n estimate = opponent_rating * p / q\n error = (\n math.sqrt(n * p * q) / n * 1.96\n ) # 95% confidence interval for normal distribution\n\n lower_bound = max(0, p - error)\n lower_bound = opponent_rating * lower_bound / (1 - lower_bound)\n\n higher_bound = min(1, p + error)\n\n if higher_bound == 1:\n higher_bound = math.inf\n else:\n higher_bound = opponent_rating * higher_bound / (1 - higher_bound)\n\n return estimate, (lower_bound, higher_bound)","def custom_score_3(game, player):\n \"\"\"custom_score_3 heuristic function aims at maximizing win chances of my agent\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = 1.0 * len(game.get_legal_moves(player))#Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves with oppositePlayer\n\n if length_my_player_moves == 0:\n return float(\"-inf\")\n\n if length_opp_payer_moves == 0:\n return float(\"inf\")\n\n return float(length_my_player_moves/length_opp_payer_moves)","def custom_score_4(game, player):\n \"\"\"custom_score_4 heuristic function aims at minimizing loosing chances of myPlayer\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = 1.0 * len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n\n if length_my_player_moves == 0:\n return float(\"-inf\")\n\n if length_opp_payer_moves == 0:\n return float(\"inf\")\n\n return float(-length_opp_payer_moves/length_my_player_moves)","def gameOver(self, myScore, oppScore):\r\n self.gamePlayed += 1\r\n self.averageNumTurns = (self.averageNumTurns * self.gamePlayed + self.thisNumTurns) / self.gamePlayed\r\n self.thisNumTurns = 0.0","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n if game.is_winner(player):\n return float(\"inf\")\n\n # Aim to maximise your own available moves vs the opponent (Factor 2)\n\n opponent = game.get_opponent(player)\n return float(len(game.get_legal_moves(player)))-2.0*float(len(game.get_legal_moves(opponent)))","def calc_winner(self):\n pass","def score2(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= 1\r\n else:\r\n numOpp+=1\r\n return numPlayer-numOpp","def opponents_score(self):\n if self.opponent_wickets == 10:\n var1 = \"All Out\"\n return str('{0} {1}').format(self.opponent_runs, var1)\n else:\n var1 = self.opponent_wickets\n return str('{0}-{1}').format(self.opponent_runs, var1)","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def get_win_rate_regular_season_for_each_coach(self):\n self.games_won_for_coaches = (\n self.raw_data_regularseason\n [['Season','DayNum','WTeamID']]\n # merge for winning team\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\n how='left',left_on=['Season','WTeamID'],right_on=['Season','TeamID'])\n .rename(columns={\"FirstDayNum\":\"FirstDayNum_win\",\"LastDayNum\":\"LastDayNum_win\",\"CoachName\":\"CoachName_win\",\"TeamID\":\"TeamID_win\"})\n .pipe(lambda x:x.assign(which_coach_for_win = np.where((x.FirstDayNum_win <= x.DayNum) & (x.LastDayNum_win >= x.DayNum),1,0)))\n .query(\"which_coach_for_win != 0\")\n .groupby(['Season','CoachName_win','WTeamID'])\n .agg({\"which_coach_for_win\":\"sum\"})\n .reset_index()\n )\n\n self.games_lose_for_coaches = (\n self.raw_data_regularseason\n [['Season','DayNum','LTeamID']]\n # merge for losing team\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\n how='left',left_on=['Season','LTeamID'],right_on=['Season','TeamID'])\n .rename(columns={\"FirstDayNum\":\"FirstDayNum_lose\",\"LastDayNum\":\"LastDayNum_lose\",\"CoachName\":\"CoachName_lose\",\"TeamID\":\"TeamID_lose\"})\n .pipe(lambda x:x.assign(which_coach_for_lose = np.where((x.FirstDayNum_lose <= x.DayNum) & (x.LastDayNum_lose >= x.DayNum),1,0)))\n .query(\"which_coach_for_lose != 0\")\n .groupby(['Season','CoachName_lose','LTeamID'])\n .agg({\"which_coach_for_lose\":\"sum\"})\n .reset_index()\n )\n\n # combine games won and lost df\n self.combine_regular_games_won_lose = (\n self.games_lose_for_coaches\n .merge(self.games_won_for_coaches,how='left',left_on=['Season','LTeamID','CoachName_lose'],right_on=['Season','WTeamID','CoachName_win'])\n .pipe(lambda x:x.assign(win_rate_regular = x.which_coach_for_win/(x.which_coach_for_win + x.which_coach_for_lose)))\n .drop(['CoachName_win','WTeamID'],1)\n .rename(columns={\"CoachName_lose\":\"CoachName\",\"LTeamID\":\"TeamID\",\"which_coach_for_lose\":\"games_lost\",\"which_coach_for_win\":\"games_won\"})\n )","def calculate_score(self):\n\n correct_award = 150\n turns_total = self.turns.count()\n turns_correct = self.turns.filter(is_match=True).count()\n seconds_left = (60.0 - (self.turns.last().created - self.turns.first().created).total_seconds()) or 0\n maxpoints = turns_correct * correct_award\n deduction_for_errors = correct_award * 0.11123\n\n maxpoints -= ((turns_total - turns_correct) * 2 * deduction_for_errors)\n maxpoints += seconds_left * 5.123214\n\n return Decimal(maxpoints)","def get_game_score(self):\n if self.game_is_tied():\n return 0\n elif self.is_game_won():\n my_available_steps = self.steps_available(self.loc)\n opp_available_steps = self.steps_available(self.opponent_loc)\n my_score = self.my_score - self.penalty_score if my_available_steps == 0 else self.my_score\n opp_score = self.opponent_score - self.penalty_score if opp_available_steps == 0 else self.opponent_score\n return (my_score - opp_score) / (abs(my_score) + abs(opp_score))\n else:\n if abs(self.my_score) + abs(self.opponent_score) == 0:\n return 0\n return (self.my_score - self.opponent_score) / (abs(self.my_score) + abs(self.opponent_score))","def calculate_score_pairs(hand_value,*args):\n # ratios=[1,10,100,1000,10000]\n ratios = CONST.RATIOS[:]\n return sum(map(lambda a,b:a/b, args, ratios))+hand_value","def improved_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)","def GetResult(self, playerjm):\n return self.score / len(self.scores)","def update_stats(home_player: Player, away_player: Player,\n home_score: int, away_score: int) -> None:\n home_player.goals_for += home_score\n home_player.goals_against += away_score\n away_player.goals_for += away_score\n away_player.goals_against += home_score\n\n # home won\n if (home_score > away_score):\n home_player.wins += 1\n away_player.losses += 1\n # away won\n elif (home_score < away_score):\n home_player.losses += 1\n away_player.wins += 1\n # draw\n else:\n home_player.draws += 1\n away_player.draws += 1","def evaluate(self, state):\n total_rewards = np.array([0.0] * state.num_players)\n for _ in range(self.width): # for each of width simulations\n total_rewards += self.run_rollout(state)\n\n return total_rewards / self.width","def score(player, board):\n mine, theirs = 0, 0\n opp = Othello.opponent(player)\n for sq in Othello.squares():\n piece = board[sq]\n if piece == player: mine += 1\n elif piece == opp: theirs += 1\n return mine - theirs","def custom_score_7(game, player):\n \"\"\"custom_score_7 heuristic function also aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def expected_value(held_dice, num_die_sides, num_free_dice):\n result = 0\n outcomes = range(1, num_die_sides + 1)\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\n for hand in possible:\n result += score(held_dice + hand)\n return float(result)/len(possible)","def get_fool_ratio(self, test_acc, attack_accs):\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]","def get_new_ratings(players, teams):\n nb_players_team0 = len(teams[0])\n nb_players_team1 = len(teams[1])\n winner = players[teams[0][0]]\n loser = players[teams[1][0]]\n if nb_players_team0 == 1 and nb_players_team1 == 1:\n new_r1, new_r3 = rate_1vs1(winner,loser)\n elif nb_players_team0 == 1 and nb_players_team1 > 1:\n team_loser = [loser, players[teams[1][1]]]\n (new_r1), (new_r3, new_r4) = rate([winner, team_loser], ranks=[0, 1]) \n elif nb_players_team0 > 1 and nb_players_team1 == 1:\n team_winner = [winner, players[teams[0][1]]]\n (new_r1, new_r2), (new_r3) = rate([team_winner, loser], ranks=[0, 1]) \n else:\n team_loser = [loser, players[teams[1][1]]]\n team_winner = [winner, players[teams[0][1]]]\n (new_r1, new_r2), (new_r3, new_r4) = rate([team_winner, team_loser], ranks=[0, 1]) \n player1 = {'name': teams[0][0], 'mu': new_r1.mu, 'sigma': new_r1.sigma}\n player3 = {'name': teams[1][0], 'mu': new_r3.mu, 'sigma': new_r3.sigma}\n if nb_players_team0 > 1:\n player2 = {'name': teams[0][1], 'mu': new_r2.mu, 'sigma': new_r2.sigma}\n if nb_players_team1 > 1:\n player4 = {'name': teams[1][1], 'mu': new_r4.mu, 'sigma': new_r4.sigma}\n if nb_players_team0 > 1:\n return [player1, player2, player3, player4]\n return [player1, player2, player4]\n return [player1, player3]","def expected_value(held_dice, num_die_sides, num_free_dice):\n outcomes = get_outcomes(num_die_sides)\n print \"outcomes:\", outcomes\n\n # generate all possible sequences of rolls\n all_rolls = list(gen_all_sequences(outcomes, num_free_dice))\n results = [max_repeats(roll) for roll in all_rolls]\n value = 0.0 \n\n\n for result in all_rolls:\n curr_hand = tuple(list(held_dice) + list(result))\n value += score(curr_hand)\n\n return value / len(all_rolls)","def _calculate_score(self):\n mul = self._check_board()\n if mul > 0:\n inc = 100 * mul + ((mul - 1) * 25)\n self.score += inc","def calculate_scores(players):\n scores = {}\n for player in players.tuple_:\n scores[player.id_] = player.score()\n return scores","def get_score(self, player: int) -> int:\n score = 0\n i = 0\n while i < len(self.leylines):\n score += 1 if self.leylines[i].player == player else 0\n score += 1 if self.rights[i].player == player else 0\n score += 1 if self.lefts[i].player == player else 0\n i += 1\n return score","def horizontal_ratio(self):\n if self.pupils_located:\n pupil_left = self.eye_left.pupil.x / (self.eye_left.center[0] * 2 - 10)\n pupil_right = self.eye_right.pupil.x / (self.eye_right.center[0] * 2 - 10)\n return (pupil_left + pupil_right) / 2","def get_average_distance_to_opponents(obs, player_x, player_y):\n distances_sum = 0\n distances_amount = 0\n for i in range(1, len(obs[\"right_team\"])):\n # if opponent is ahead of player\n if obs[\"right_team\"][i][0] > (player_x - 0.02):\n distance_to_opponent = get_distance(player_x, player_y, obs[\"right_team\"][i][0], obs[\"right_team\"][i][1])\n if distance_to_opponent < 0.03:\n distances_sum += distance_to_opponent\n distances_amount += 1\n # if there is no opponents close around\n if distances_amount == 0:\n return 2, distances_amount\n return distances_sum / distances_amount, distances_amount","def host_result_value(winner: Winner) -> float:\n if winner == Winner.HOME:\n return 1\n if winner == Winner.AWAY:\n return 0\n return 0.5","def calculate_score(player_cards):\n score = sum(player_cards)\n return score","def rough_outcome(self) -> float:\n # HUYNH YOU PRICK WHY THE FUCK DO YOU MAKE US WRITE THIS SHIT EVEN IT'S NOT USED ANYWHERE\n # pick move based on this may not be optimal but better than random\n # return 1 if win immediately\n # return -1 if all states reachable will result the other player win\n # return 0 if otherwise ??? what the fuck does this mean\n # look two states forward\n pass","def calculateRatio(levelDims):\n highestReso = np.asarray(levelDims[0])\n lowestReso = np.asarray(levelDims[-1])\n Xratio, Yratio = highestReso/lowestReso\n return (Xratio, Yratio)","def calc_win_lose_ratio(self):\n total = len(self.train_y)\n survived = 0\n for i in self.train_y:\n if i > 0:\n survived += 1\n\n self.survival_sum = [survived, total-survived]","def getWinProbability(team1, team2, r, year=2019):\n\tR1_PROBS = R1_PROBS_2019 if year == 2019 else R1_PROBS_2020\n\tALPHA_VALS = ALPHA_VALS_2019 if year == 2019 else ALPHA_VALS_2020\n\n\t# Currently using Power Model\n\ts1 = team1['seed']\n\ts2 = team2['seed']\n\n\t# Use R1_PROBS for round 1\n\tif r == 1:\n\t\tif not (s1 + s2 == 17):\n\t\t\texit('Invalid round 1 matchup: seeds {0} vs. {1}.'.format(s1, s2))\n\t\treturn R1_PROBS[s1] if s1 < s2 else R1_PROBS[s2]\n\t\n\t# Use ALPHA_VALS for other rounds (unless seeds are same)\n\tif s1 == s2:\n\t\treturn 0.5\n\n\talpha = ALPHA_VALS[r]\n\ts1a = (s1 * 1.0) ** alpha\n\ts2a = (s2 * 1.0) ** alpha\n\treturn s2a / (s1a + s2a)","def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\n ratio_x = 0\n ratio_y = 0\n ratio_z = 0\n # helm_B = [0,0,0]\n divideby = 0\n for shot in range(shot_range[0], shot_range[1]+1):\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\n ratio_x = ratio_x + x\n ratio_y = ratio_y + y\n ratio_z = ratio_z + z\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\n divideby = divideby + 1 #averaging over the number of shots\n ratio_Bx = ratio_x/divideby\n ratio_By = ratio_y/divideby\n ratio_Bz = ratio_z/divideby\n # helmB = [helm_B]/divideby\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\n # print(\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\n Bx_sqr =ratio_x**2\n By_sqr =ratio_y**2\n Bz_sqr =ratio_z**2\n B = Bx_sqr + By_sqr+ Bz_sqr\n norm_factor = np.sqrt(B)\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\n\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)","def _compute_winrates(synergy, counter, heroes_released):\n for i in range(heroes_released):\n for j in range(heroes_released):\n if i != j and i != 23 and j != 23:\n if synergy['games'][i, j] != 0:\n synergy['winrate'][i, j] = synergy['wins'][i, j] / \\\n float(synergy['games'][i, j])\n\n if counter['games'][i, j] != 0:\n counter['winrate'][i, j] = counter['wins'][i, j] / \\\n float(counter['games'][i, j])","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n if game.is_winner(player):\n return float(\"inf\")\n game_phase = len(game.get_blank_spaces()) # high if early, low if late\n\n # Heuristic tries to take advantage of the center and shadowing if possible, otherwise stick to the centre and maximise number of moves \n\n # (*0) Calculate the (theoretical) centre\n center = (game.width / 2., game.height / 2.)\n opponent = game.get_opponent(player)\n loc_player = game.get_player_location(player)\n loc_opponent = game.get_player_location(opponent)\n if game.width % 2 != 0 and game.height % 2 != 0:\n trueCentre = True\n loc_mirror = tuple(abs(x-(game.width-1)) for x in loc_player) # the mirrored location of the player across the axes\n else:\n trueCentre = False\n # (1) Always take the centre!\n if loc_player == center:\n return float(\"inf\")\n # (2) If opponent has the centre, avoid a position within knight's movement at all costs to avoid shadowing\n if loc_opponent == center:\n r, c = center\n directions = [(-2, -1), (-2, 1), (-1, -2), (-1, 2),(1, -2), (1, 2), (2, -1), (2, 1)]\n avoidable_positions = [(r + dr, c + dc) for dr, dc in directions]\n if loc_player in avoidable_positions:\n return float(\"-inf\")\n # (3) If we can shadow the opponent, we should!\n if trueCentre:\n if center not in game.get_blank_spaces() and loc_opponent == loc_mirror and len(game.get_legal_moves(player)) == len(game.get_legal_moves(opponent)):\n return float(\"inf\")\n # (4) Finally, we simply return number of moves active player can make minus number of moves opponent can make minus the distance from the centre, weighted by the game phase\n w, h = center\n y, x = loc_player\n dist = float((h - y)**2 + (w - x)**2)\n return (float(len(game.get_legal_moves(player)))-2.0*float(len(game.get_legal_moves(opponent)))-dist)*game_phase","def custom_score(game, player):\n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the improved score\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n improved = len(player_legal_moves) - len(opponent_legal_moves)\n if improved != 0:\n return float(improved)\n \n # Second get differences from center\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n player_coordinates = game.get_player_location(player)\n opponent_coordinates = game.get_player_location(opponent)\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\n center_dist_diff = player_center_dist - opponent_center_dist\n \n # Third obtain next_moves\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \n improved_next = len(player_next_moves) - len(opponent_next_moves)\n \n # Put player and opponent feature differences in a tuple/vector surrogoate\n feature_diff_vector = (improved, center_dist_diff, improved_next)\n \n # Provide a weighting vector for the features of each player-participant\n weight_vector = (1.5,0.1,1.0)\n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(feature_diff_vector, weight_vector))\n \n return float(weighted_difference_dot_product)","def p(party, vote_count, s):\n return t(party, vote_count) / d(s)","def custom_score(game, player):\n \"\"\" custom_score heuristic function idea is to implement aggressive heuristic function \n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) # Calculate length of myPlayer moves\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player))) # Calculate length of opposite player moves same as custom score 2\n return float(length_my_player_moves - 1.5*length_opp_payer_moves)","def custom_score(game, player):\n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n if game.move_count < 15:\n return center_modified_score(game, player)\n\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = len(game.get_legal_moves(player))\n\n if game.move_count < 15:\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)\n\n delta = 0\n\n moves = game.get_legal_moves()\n initial_moves_count = len(moves)\n indexes = np.random.permutation(initial_moves_count)\n\n for i in range(0, min(4, initial_moves_count)):\n first_level = True\n simulation = game.copy()\n\n while True:\n moves = simulation.get_legal_moves()\n moves_count = len(moves)\n if moves_count == 0:\n if simulation.is_winner(player):\n delta = delta + 1\n else:\n delta = delta - 1\n break\n if first_level:\n selected_move = indexes[i]\n first_level = False\n else:\n selected_move = random.randint(0, moves_count - 1)\n\n simulation.apply_move(moves[selected_move])\n\n return float(own_moves + delta) #float(own_moves - opp_moves + 5 * delta)\n\n #return float(own_moves - opp_moves + free_area_score(game, player) - free_area_score(game, game.get_opponent(player)))","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the base information to calculate player & opponent\n # feature values\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n if len(player_legal_moves) != len(opponent_legal_moves):\n return float(len(player_legal_moves) - len(opponent_legal_moves))\n \n # Get_center_coordinates and opponent. Then set the list of participants\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n participants = [player, opponent]\n \n # Then, for each participant obtain his/her feature values \n for participant in participants:\n if participant == player:\n p_legal_moves = player_legal_moves\n player_either = player\n participant_coordinates = p_y, p_x = \\\n game.get_player_location(participant)\n player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, \\\n player_path_count, player_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either,participant_coordinates, p_legal_moves)\n else:\n p_legal_moves = opponent_legal_moves\n player_either = opponent\n participant_coordinates = p_y, p_x \\\n = game.get_player_location(participant)\n opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, opponent_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either, participant_coordinates, p_legal_moves)\n \n # Place each participant's feature values in a tuple/vector surrogate \n pro_player_vector = \\\n (player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, player_path_count, \\\n opponent_min_center_diff)\n pro_opponent_vector = \\\n (opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, player_min_center_diff)\n \n # Provide a weighting vector for the features \n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\n \n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\n \n return float(weighted_difference_dot_product)","def calculate_overall_rating(player_dict):\r\n if player_dict[\"position\"].upper() == \"QB\":\r\n throw_power = int(max(min(int(player_dict[\"throw_power\"]), 99), 70))\r\n throw_accuracy = int(max(min(math.ceil(\r\n ((2 * (\r\n int(player_dict[\"throw_accuracy_short\"]) + \r\n int(player_dict[\"throw_accuracy_mid\"]) + \r\n int(player_dict[\"throw_accuracy_deep\"]) + \r\n int(player_dict[\"throw_on_the_run\"]) + \r\n int(player_dict[\"playaction\"])\r\n )) - (2 * min(\r\n int(player_dict[\"throw_accuracy_short\"]), \r\n int(player_dict[\"throw_accuracy_mid\"]), \r\n int(player_dict[\"throw_accuracy_deep\"]), \r\n int(player_dict[\"throw_on_the_run\"]), \r\n int(player_dict[\"playaction\"])\r\n ))\r\n ) / 8\r\n ), 99), 60))\r\n break_tackles = int(max(min(\r\n math.ceil(((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 7), \r\n 90), 20))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 98), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 55))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((throw_power - 50.0) / 10.0) * 4.9\r\n overall_rating += ((throw_accuracy - 50.0) / 10.0) * 5.8\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.0\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"HB\":\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 70), 25))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 99), 50))\r\n carrying = int(max(min(int(player_dict[\"carrying\"]), 99), 60))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 45))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 50))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 0.33\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((carrying - 50.0) / 10.0) * 2.0\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.8\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.0\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.6\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 1.4\r\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"FB\":\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 75), 40))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 85), 45))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 99), 55))\r\n carrying = int(max(min(int(player_dict[\"carrying\"]), 99), 60))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 55))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 95), 60))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 60))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.0\r\n overall_rating += ((run_block - 50.0) / 10.0) * 7.2\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.8\r\n overall_rating += ((carrying - 50.0) / 10.0) * 1.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.0\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 1.8\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\r\n overall_rating += ((catching - 50.0) / 10.0) * 5.2\r\n overall_rating = int(max(min((round(overall_rating) + 39), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"WR\":\r\n break_tackles = int(max(min(\r\n math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2), \r\n 80), 35))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 75))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 75))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 35))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 99), 65))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.3\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.3\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.3\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.8\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 4.75\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.4\r\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"TE\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 55))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 55))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 55))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 60))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 99), 45))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 95), 20))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 80), 35))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 85), 35))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.65\r\n overall_rating += ((strength - 50.0) / 10.0) * 2.65\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.65\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.25\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.25\r\n overall_rating += ((catching - 50.0) / 10.0) * 5.4\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.2\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.2\r\n overall_rating += ((run_block - 50.0) / 10.0) * 5.4\r\n overall_rating = int(max(min((round(overall_rating) + 35), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LT\" or player_dict[\"position\"].upper() == \"RT\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 85), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 85), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 90), 60))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 99), 60))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 0.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.3\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.3\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 0.8\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 4.75\r\n overall_rating += ((run_block - 50.0) / 10.0) * 3.75\r\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\r\n return overall_rating\r\n \r\n if (player_dict[\"position\"].upper() == \"LG\" or player_dict[\"position\"].upper() == \"RG\" or \r\n player_dict[\"position\"].upper() == \"C\"):\r\n speed = int(max(min(int(player_dict[\"speed\"]), 85), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 85), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 90), 60))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 99), 65))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.7\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.25\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.25\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 3.25\r\n overall_rating += ((run_block - 50.0) / 10.0) * 4.8\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LE\" or player_dict[\"position\"].upper() == \"RE\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 90), 55))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 90), 45))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.75\r\n overall_rating += ((awareness - 50.0) / 10.0) * 1.75\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.75\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 3.8\r\n overall_rating += ((tackle - 50.0) / 10.0) * 5.5\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"DT\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 90), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 90), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 5.5\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 1\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.8\r\n overall_rating += ((tackle - 50.0) / 10.0) * 4.55\r\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LOLB\" or player_dict[\"position\"].upper() == \"ROLB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 70))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 65))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 75))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 90), 20))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 2.4\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.6\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.4\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 1.3\r\n overall_rating += ((tackle - 50.0) / 10.0) * 4.8\r\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"MLB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 65))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 65))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 75))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 0.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.4\r\n overall_rating += ((awareness - 50.0) / 10.0) * 5.2\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.65\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.75\r\n overall_rating += ((tackle - 50.0) / 10.0) * 5.2\r\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"CB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 40))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 75))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 40))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 85), 30))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.85\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.85\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.55\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.35\r\n overall_rating += ((catching - 50.0) / 10.0) * 3\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.55\r\n overall_rating += ((tackle - 50.0) / 10.0) * 1.55\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"FS\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 75))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 35))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 90), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.0\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.85\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.5\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.5\r\n overall_rating += ((catching - 50.0) / 10.0) * 3.0\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.5\r\n overall_rating += ((tackle - 50.0) / 10.0) * 2.5\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"SS\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 75))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 35))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 90), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.2\r\n overall_rating += ((strength - 50.0) / 10.0) * 1.7\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.75\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.7\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\r\n overall_rating += ((catching - 50.0) / 10.0) * 3.2\r\n overall_rating += ((jumping - 50.0) / 10.0) * 0.9\r\n overall_rating += ((tackle - 50.0) / 10.0) * 3.2\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"K\":\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 85), 35))\r\n kick_power = int(max(min(int(player_dict[\"kick_power\"]), 99), 80))\r\n kick_accuracy = int(max(min(int(player_dict[\"kick_accuracy\"]), 99), 70))\r\n \r\n overall_rating = (-177 + (0.218 * awareness) + (1.28 * kick_power) + (1.47 * kick_accuracy))\r\n overall_rating = int(max(min(round(overall_rating), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"P\":\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 85), 40))\r\n kick_power = int(max(min(int(player_dict[\"kick_power\"]), 99), 80))\r\n kick_accuracy = int(max(min(int(player_dict[\"kick_accuracy\"]), 99), 70))\r\n \r\n overall_rating = (-183 + (0.218 * awareness) + (1.5 * kick_power) + (1.33 * kick_accuracy))\r\n overall_rating = int(max(min(round(overall_rating), 99), 40))\r\n return overall_rating","def get_improved_score_factor(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)","def custom_score_3(game, player):\n \n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n player_legal_move_count, opponent_legal_move_count = \\\n len(player_legal_moves), len(opponent_legal_moves)\n move_count_difference = player_legal_move_count - opponent_legal_move_count\n # Find coordinates of center box\n h, w = get_center_coordinates(game)\n # Retrieve player's coordinates\n y, x = game.get_player_location(player)\n # Obtain coordinate further, closest to origin\n furthest_coord, closest_coord = max(h - y, w -x), min(h - y, w - x)\n # Return weighted, vector-valued length from origin / sum of weights\n weighted_distance_from_center = \\\n math.sqrt((closest_coord**2 + 2*(furthest_coord**2)))/3\n feature_vector = (move_count_difference, weighted_distance_from_center)\n \n weight_vector = (1.0,0.1)\n \n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(weight_vector, feature_vector)) \n \n return float(weighted_difference_dot_product)","def evaluate_board(self, board):\n \n win_score = 100\n win_or_loss_score = 50\n lose_score = 0\n \n if board.win_for(self.opponent()):\n return lose_score\n if board.win_for(self.side):\n return win_score\n if not board.win_for(self.side) or not board.win_for(self.opponent()):\n return win_or_loss_score","def compute_drift_score(ref_col_prob, col_prob):\n\n return sum(abs(np.asarray(ref_col_prob) - np.array(col_prob)) * 100)","def quick_ratio(self):\n return (\n self.current_assets - self.inventory_net) / self.current_liabilities","def evaluate(game, player):\n weights = [2, 200, 2000, 20000]\n reward = 0\n opponent = get_opponent(player)\n for length in range(2, 6):\n reward += weights[length - 2] * get_num_series(game, player, length)\n reward -= weights[length - 2] * get_num_series(game, opponent, length)\n return reward","def ucbScore(self,totalPlayedTimes):\n winRate = self.winRate()\n #print totalPlayedTimes\n #print self.playedTimes\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\n \n return winRate + confidenceInterval","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def evaluate(self):\n # if player has no move, then player lost, -inf or inf depend on who the player is\n # if player has moves, use heuristics.\n \n #checkColorMoves = self.getAvailableMoves(self.colorIndex)\n #otherColorMoves = self.getAvailableMoves(1-self.colorIndex)\n \n checkColorMoves = self.getAvailableMovesPreferLonger(self.colorIndex)\n otherColorMoves = self.getAvailableMovesPreferLonger(1-self.colorIndex)\n\n checkColorPieces = self.getPieceCount(self.colorIndex)\n otherColorPieces = self.getPieceCount(1-self.colorIndex)\n\n #checkColorEdgePieces = self.getEgdePieceCount(self.colorIndex)\n #otherColorEdgePieces = self.getEgdePieceCount(1-self.colorIndex)\n\n if self.player == 'computer':\n if checkColorMoves == 0: #computer doesn't have moves\n return float('-inf')\n elif otherColorMoves == 0: #user doesn't have moves\n return float('inf')\n else:\n #return checkColorPieces - otherColorPieces\n return checkColorMoves - otherColorMoves\n else:\n if checkColorMoves == 0: #user doesn't have moves\n return float('inf')\n elif otherColorMoves == 0: #computer doesn't have moves\n return float('-inf')\n else:\n #return otherColorPieces - checkColorPieces\n return otherColorMoves - checkColorMoves","def compute_utility(self, board, move, player):\n r_alive = 0\n b_alive = 0\n rk_alive = 0\n bk_alive = 0\n for line in range(8):\n for col in range(8):\n if board[line][col] == \"R\":\n r_alive += 1\n elif board[line][col] == \"B\":\n b_alive += 1\n elif board[line][col] == \"RK\":\n rk_alive += 1\n elif board[line][col] == \"BK\":\n bk_alive += 1\n # if r_Alive > b_Alive:\n # if b_Alive == 0:\n # return 1\n # else: return 0\n # elif r_Alive == 0:\n # return -1\n powkings = 1.2\n result = 0\n if player == 'B':\n result = rk_alive*powkings + r_alive - bk_alive*powkings - b_alive\n else:\n result = bk_alive*powkings + b_alive - rk_alive*powkings - r_alive\n return result","def rate_club(user, club):\n if not user.is_authenticated():\n return None\n if not club.posel_set.exists():\n return None\n return sum(x[1] for x in rank_in_club(user, club)) / club.posel_set.count()","def custom_score_general(game, player, constants=[]):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n v = []\n\n if constants[0] != 0 or constants[2] != 0:\n own_moves = number_moves(game, player) / 8\n\n if own_moves == 0:\n return float(\"-inf\")\n\n v.append(own_moves)\n\n if constants[1] != 0 or constants[2] != 0:\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n\n if opp_moves == 0:\n return float(\"inf\")\n\n v.append(opp_moves)\n\n if constants[2] != 0:\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n v.append(move_ratio)\n\n if constants[3] != 0 or constants[5] != 0:\n own_openness = nearby_openness(game, player) / 80\n v.append(own_openness)\n\n if constants[4] != 0 or constants[5] != 0:\n opp_openness = nearby_openness(game, game.get_opponent(player)) / 80\n v.append(opp_openness)\n\n if constants[5] != 0:\n openness_ratio = (own_openness * 80) / (opp_openness + 0.0001 * 80) /80\n v.append(openness_ratio)\n\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n if constants[6] != 0 or constants[8] != 0:\n own_centerness = centerness(game, player) / centerness_max\n v.append(own_centerness)\n\n if constants[7] != 0 or constants[8] != 0:\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n v.append(opp_centerness)\n\n if constants[8] != 0:\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n return sum([x * y for x, y in zip(constants, v)])","def expected_value(held_dice, num_die_sides, num_free_dice):\r\n \r\n scores = []\r\n \r\n die_sides = [(die + 1) for die in range(num_die_sides)]\r\n \r\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\r\n\r\n for outcome in pos_outcomes:\r\n scores.append(score(held_dice + outcome))\r\n \r\n expected_result = float(sum(scores))/len(scores)\r\n \r\n return expected_result","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n #own_moves = len(game.get_legal_moves(player))\n\n #if game.move_count < 23:\n # opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n # return float(own_moves - opp_moves)\n\n return float(free_area_score(game, player) - free_area_score(game, game.get_opponent(player)))","def get_win_rate_post_season_for_each_coach(self):\n # get winning games for coaches\n self.post_games_won_for_coaches = (\n self.raw_data_postseason\n [['Season','DayNum','WTeamID']]\n # merge for winning team\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\n how='left',left_on=['Season','WTeamID'],right_on=['Season','TeamID'])\n .rename(columns={\"FirstDayNum\":\"FirstDayNum_win\",\"LastDayNum\":\"LastDayNum_win\",\"CoachName\":\"CoachName_win\",\"TeamID\":\"TeamID_win\"})\n .pipe(lambda x:x.assign(which_coach_for_win = np.where((x.FirstDayNum_win <= x.DayNum) & (x.LastDayNum_win >= x.DayNum),1,0)))\n .query(\"which_coach_for_win != 0\")\n .groupby(['Season','CoachName_win','WTeamID'])\n .agg({\"which_coach_for_win\":\"sum\"})\n .reset_index()\n )\n\n # get losing games for coaches\n self.post_games_lose_for_coaches = (\n self.raw_data_postseason\n [['Season','DayNum','LTeamID']]\n # merge for losing team\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\n how='left',left_on=['Season','LTeamID'],right_on=['Season','TeamID'])\n .rename(columns={\"FirstDayNum\":\"FirstDayNum_lose\",\"LastDayNum\":\"LastDayNum_lose\",\"CoachName\":\"CoachName_lose\",\"TeamID\":\"TeamID_lose\"})\n .pipe(lambda x:x.assign(which_coach_for_lose = np.where((x.FirstDayNum_lose <= x.DayNum) & (x.LastDayNum_lose >= x.DayNum),1,0)))\n .query(\"which_coach_for_lose != 0\")\n .groupby(['Season','CoachName_lose','LTeamID'])\n .agg({\"which_coach_for_lose\":\"sum\"})\n .reset_index()\n )\n\n # combine games won and lost df for post season\n self.combine_post_games_won_lose = (\n self.post_games_lose_for_coaches\n .merge(self.post_games_won_for_coaches,how='left',left_on=['Season','LTeamID','CoachName_lose'],right_on=['Season','WTeamID','CoachName_win'])\n .pipe(lambda x:x.assign(win_rate_post = x.which_coach_for_win/(x.which_coach_for_win + x.which_coach_for_lose)))\n .drop(['CoachName_win','WTeamID'],1)\n .rename(columns={\"CoachName_lose\":\"CoachName\",\"LTeamID\":\"TeamID\",\"which_coach_for_lose\":\"post_games_lost\",\"which_coach_for_win\":\"post_games_won\"})\n .fillna(0)\n )","def Winner(self, whichPlayer, tResult, score, gameCount):\n\n if whichPlayer == 0:\n tResult[0] = tResult[0] + score[0]\n else:\n tResult[1] = tResult[1] + score[1]\n print(data['tResult'],\"player1 \", tResult[0],\"player2 \",tResult[1])\n if gameCount == 3:\n if tResult[0] > tResult[1]:\n print(data['mplayer1'],tResult[0] - tResult[1])\n else:\n print(data['mplayer2'],tResult[1] - tResult[0])\n return whichPlayer, score, gameCount, tResult","def state_score_naive(self, game_state, player, weights):\n # walls score\n other_players = [p for p in game_state.players if p != player]\n my_walls = player.num_walls\n their_walls = max([p.num_walls for p in other_players])\n walls_diff = (my_walls - their_walls)\n # path length score\n my_path = len(game_state.get_shortest_path_player(player))\n their_path = min([len(game_state.get_shortest_path_player(p)) for p in other_players])\n paths_diff = their_path - my_path\n \n return weights[0]*walls_diff + weights[1]*paths_diff","def _evaluate_num_pieces(self, player):\n evaluation = 0\n if player is Player.black:\n evaluation += self.num_black_pieces * 10\n evaluation -= self.num_white_pieces * 10\n evaluation += self.num_black_kings * 10\n evaluation -= self.num_white_kings * 10\n elif player is Player.white:\n evaluation -= self.num_black_pieces * 10\n evaluation += self.num_white_pieces * 10\n evaluation -= self.num_black_kings * 10\n evaluation += self.num_white_kings * 10\n\n return evaluation","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)"],"string":"[\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def set_assists_ratio(self):\\n bx = self.get_standard_stats()\\n tcInt = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n denominador = tcInt + (0.44 * float(bx[\\\"tl_int\\\"])) + float(bx[\\\"assists\\\"]) +float(bx[\\\"turnovers\\\"])\\n numerador = float(bx[\\\"assists\\\"])\\n result = 0.00\\n if denominador > 0:\\n result = (numerador / denominador) * 100\\n self.assists_ratio = \\\"%.2f\\\" % round(result, 2)\",\n \"def winrate(matches):\\n if not matches:\\n print('no matches')\\n return None\\n\\n win_loss = [match['result'] for match in matches]\\n return sum(win_loss)/len(win_loss)\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def score(self,player, board):\\r\\n numPlayer = 0\\r\\n numOpp = 0\\r\\n for i in self.squares():\\r\\n if board[i] == player:\\r\\n numPlayer+= SQUARE_WEIGHTS[i]\\r\\n else:\\r\\n numOpp+=SQUARE_WEIGHTS[i]\\r\\n return numPlayer-numOpp\",\n \"def mc_update_scores(scores, board, player):\\n dim = board.get_dim()\\n winner = board.check_win()\\n other_player = provided.switch_player(player)\\n \\n if winner == provided.DRAW:\\n ratio = {player: 0, other_player: 0, 1: 0}\\n elif winner == player:\\n ratio = {player: 0 + SCORE_CURRENT, other_player: 0 - SCORE_OTHER, provided.EMPTY: 0}\\n elif winner == other_player:\\n ratio = {player: 0 - SCORE_CURRENT, other_player: 0 + SCORE_OTHER, provided.EMPTY: 0}\\t\\n \\n for valx in range(dim):\\n for valy in range(dim): \\n scores[valx][valy] += ratio[board.square(valx, valy)] \\n return scores\",\n \"def custom_score_2(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # shortcut to definite state:\\n # 1. my agent win -> return very high score\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n # 2. opponenent's agent win -> return very low score\\n elif own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n # score: avaliable moves ratio\\n return float(own_moves/opp_moves)\",\n \"def calculateWinRate():\\n times = 10\\n winRate = 0.0\\n for i in range(times):\\n game = Game('user', 6, 6)\\n winRate += game.play(5, False, True, False, False)\\n winRate = winRate/times\\n print \\\"Winrate:\\\", winRate\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def get_win_percentage(self) -> float:\\n if self.wins == 0:\\n return 0.0\\n else:\\n return round((self.wins / (self.wins + self.losses)) * 100, 2)\",\n \"def set_assists_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n team_tc_conv = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n player_tc_conv = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0:\\n result = (bx[\\\"assists\\\"] / (((bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * team_tc_conv) - player_tc_conv))*100\\n result = result if result <= 100 and result >= 0 else 0\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.assists_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def calc_match_points(self, match):\\n if match.winner == match.TIE:\\n match.home.tournament_score += 1\\n match.away.tournament_score += 1\\n else:\\n match.winner.tournament_score += 3\\n match.loser.tournament_score += 0\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n #Between 1-8\\n return own_moves / opp_moves\",\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return -math.inf\\n\\n if game.is_winner(player):\\n return math.inf\\n\\n opp_moves = game.get_legal_moves(game.get_opponent(player))\\n own_moves = game.get_legal_moves(player)\\n\\n return len(own_moves) / max(len(opp_moves), 1e-6)\",\n \"def cal_hit_ratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\\n score = score_1 - score_2\\n return score/full['user'].nunique()\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player) / 8\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n\\n # Calculate centerness_score\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n if completeness < 0.5:\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n own_centerness = centerness(game, player) / centerness_max\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def win_ratio_avg(self):\\n win_ratio = 0\\n # Adds all the win ratios of team in this conference which will be\\n # used to compute the win ratio average.\\n for team_obj in self._conf_teams:\\n ### INVARIANT: team_obj is a Team class object and\\n ### self._conf_teams is a list of Team class objects.\\n win_ratio += team_obj._win_ratio\\n return win_ratio/len(self._conf_teams)\",\n \"def winRate(DF):\\r\\n df = DF[\\\"return\\\"]\\r\\n pos = df[df>1]\\r\\n neg = df[df<1]\\r\\n return (len(pos) / len(pos + neg)) * 100\",\n \"def custom_score_6(game, player):\\n \\\"\\\"\\\"custom_score_6 heuristic function aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)\",\n \"def average_win_rate(strategy, baseline=always_roll(4)):\\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\\n\\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2\",\n \"def average_win_rate(strategy, baseline=always_roll(4)):\\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\\n\\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2\",\n \"def average_win_rate(strategy, baseline=always_roll(4)):\\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\\n\\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2\",\n \"def rate_board(board, player):\\n approx_player_moves = sum(\\n len(_get_empty_neighbors((i, j), board))\\n for i in range(5)\\n for j in range(5)\\n if board[i][j] == player\\n )\\n approx_opponent_moves = sum(\\n len(_get_empty_neighbors((i, j), board))\\n for i in range(5)\\n for j in range(5)\\n if board[i][j] == -player\\n )\\n return approx_player_moves - approx_opponent_moves\",\n \"def weighted_score(player, board):\\n opp = Othello.opponent(player)\\n total = 0\\n for sq in Othello.squares():\\n if board[sq] == player:\\n total += SQUARE_WEIGHTS[sq]\\n elif board[sq] == opp:\\n total -= SQUARE_WEIGHTS[sq]\\n return total\",\n \"def eval(self):\\n\\n ratio_player_win = self.player_wins / self.num_test\\n ratio_opponent_win = self.opponent_wins / self.num_test\\n ratio_tie = 1.0 - ratio_player_win - ratio_opponent_win\\n\\n print(\\\"\\\\nPlayer Test Results:\\\")\\n print(\\\"\\\\tWins {0:.2f}%\\\".format(100.0 * ratio_player_win))\\n print(\\\"\\\\tLosses {0:.2f}%\\\".format(100.0 * ratio_opponent_win))\\n print(\\\"\\\\tTie {0:.2f}%\\\".format(100.0 * ratio_tie))\\n\\n ratio_optimal_win = self.optimal_wins / self.num_test\\n ratio_optimal_loose = self.optimal_losses / self.num_test\\n ratio_optimal_tie = 1.0 - ratio_optimal_win - ratio_optimal_loose\\n\\n print(\\\"\\\\nOptimal Results:\\\")\\n print(\\\"\\\\tPlayer {0:.2f}%\\\".format(100.0 * ratio_optimal_win))\\n print(\\\"\\\\tOpponent {0:.2f}%\\\".format(100.0 * ratio_optimal_loose))\\n print(\\\"\\\\tTie {0:.2f}%\\\".format(100.0 * ratio_optimal_tie))\\n\\n # Ratio of win, loss diff between player and optimal\\n # positive if the player beats opponent\\n relative_result = ((ratio_player_win - ratio_opponent_win) /\\n (ratio_optimal_win - ratio_optimal_loose))\\n\\n print(\\\"\\\\nResults Player Relative Optimal:\\\")\\n print(\\\"\\\\tWins {0:.2f}%\\\".format(100.0 * ratio_player_win / ratio_optimal_win))\\n print(\\\"\\\\tLosses {0:.2f}%\\\".format(100.0 * ratio_opponent_win / ratio_optimal_loose))\\n print(\\\"\\\\tScore {0:.2f}%\\\".format(100.0 * relative_result))\\n\\n if self.last_test is not None:\\n print(\\\"Diff from last test score is {0:.2f}%\\\".format(100.0 * (relative_result - self.last_test)))\\n self.last_test = relative_result\",\n \"def compute_score(window, computer_piece):\\n score = 0\\n if window.count(computer_piece) == 4:\\n score += 100\\n elif window.count(computer_piece) == 3 and window.count(0) == 1:\\n score += 5\\n elif window.count(computer_piece) == 2 and window.count(0) == 2:\\n score += 2\\n if window.count(PLAYER_PIECE) == 2 and window.count(0) == 2:\\n score -= 1\\n if window.count(PLAYER_PIECE) == 3 and window.count(0) == 1:\\n score -= 100\\n return score\",\n \"def custom_score_3(game, player):\\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # shortcut to definite state:\\n # 1. my agent win -> return very high score\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n # 2. opponenent's agent win -> return very low score\\n elif own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n # score: log of avaliable moves ratio\\n return float(log(own_moves/opp_moves))\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = own_moves / opp_moves\\n\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n\\n if completeness < 0.5:\\n own_centerness = centerness(game, player)\\n opp_centerness = centerness(game, game.get_opponent(player))\\n centerness_ratio = own_centerness / opp_centerness + 0.1\\n\\n center_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def calculate_my_win_strength(self):\\n self.winStrength = self.strategy(deepcopy(self.currentBoardState))\",\n \"def set_offensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0 and (bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]) > 0:\\n fgm = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n fga = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n team_fgm = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n team_fga = team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]\\n team_points = team[\\\"t2p_conv\\\"]*2 + team[\\\"t3p_conv\\\"]*3 + team[\\\"tl_conv\\\"]\\n points = bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"]\\n\\n try:\\n qAST = (Decimal(bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * (Decimal('1.14') * Decimal((team[\\\"assists\\\"] - bx[\\\"assists\\\"]) / team_fgm))) + \\\\\\n Decimal((((team[\\\"assists\\\"] / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - bx[\\\"assists\\\"]) / ((team_fgm / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - fgm)) * (1 - (bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5))))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n qAST = 1\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n qAST = 1\\n\\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2*(team_fga - fga))) * bx[\\\"assists\\\"]\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n ast_part = 0\\n\\n if bx[\\\"tl_int\\\"] > 0:\\n ft_part = Decimal(1 - (1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_part = 0\\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"]))**2) * team[\\\"tl_int\\\"] * Decimal('0.4'))\\n try:\\n team_orb_percentage = Decimal(team[\\\"reb_of\\\"] / (team[\\\"reb_of\\\"] + ((opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]) - opp_team[\\\"reb_of\\\"])))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n\\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\\\"tl_int\\\"] * Decimal('0.4') + team[\\\"turnovers\\\"]))\\n try:\\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_weight = 0\\n\\n orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage\\n\\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\\n if bx[\\\"tl_conv\\\"] > 0:\\n ft_x_poss = Decimal((1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_x_poss = Decimal(1 - (bx[\\\"tl_conv\\\"] / 1)**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n try:\\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n sc_poss =0\\n\\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\\\"turnovers\\\"]\\n\\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\\\"t3p_conv\\\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\\\"t3p_conv\\\"] - bx[\\\"t3p_conv\\\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2 * (team_fga - fga))) * bx[\\\"assists\\\"]\\n except:\\n pprod_ast_part = 0\\n\\n pprod_orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"])**2) * Decimal('0.4') * team[\\\"tl_int\\\"]))\\n try:\\n pprod = (pprod_fg_part + pprod_ast_part + bx[\\\"tl_conv\\\"]) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n pprod = 0\\n\\n try:\\n result = 100 * (pprod / tot_poss)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n result = 0\\n\\n # print(\\\"fgm: \\\" + str(fgm))\\n # print(\\\"fga: \\\" + str(fga))\\n # print(\\\"team_fgm: \\\" + str(team_fgm))\\n # print(\\\"team_fga: \\\" + str(team_fga))\\n # print(\\\"team_points: \\\" + str(team_points))\\n # print(\\\"points: \\\" + str(points))\\n # print(\\\"qAST: \\\" + str(qAST))\\n # print(\\\"fg_part: \\\" + str(fg_part))\\n # print(\\\"ast_part: \\\" + str(ast_part))\\n # print(\\\"ft_part: \\\" + str(ft_part))\\n # print(\\\"team_scoring_poss: \\\" + str(team_scoring_poss))\\n # print(\\\"team_orb_percentage: \\\" + str(team_orb_percentage))\\n # print(\\\"team_play_percentage: \\\" + str(team_play_percentage))\\n # print(\\\"team_orb_weight: \\\" + str(team_orb_weight))\\n # print(\\\"orb_part: \\\" + str(orb_part))\\n # print(\\\"fg_x_poss: \\\" + str(fg_x_poss))\\n # print(\\\"ft_x_poss: \\\" + str(ft_x_poss))\\n # print(\\\"sc_poss: \\\" + str(sc_poss))\\n # print(\\\"tot_poss: \\\" + str(tot_poss))\\n # print(\\\"pprod_fg_part: \\\" + str(pprod_fg_part))\\n # print(\\\"pprod_ast_part: \\\" + str(pprod_ast_part))\\n # print(\\\"pprod_orb_part: \\\" + str(pprod_orb_part))\\n # print(\\\"pprod: \\\" + str(pprod))\\n # print(\\\"result: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n\\n self.ortg = \\\"%.2f\\\" % round(result, 2)\\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\\n \\\"\\\"\\\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \\n using team's formula\\\"\\\"\\\"\\n print(BCOLORS.OKBLUE + \\\"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\\\" + BCOLORS.ENDC)\\n bx = self.get_standard_stats()\\n result = round((bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])/self.get_team_possessions(), 2)\\n self.ortg = \\\"%.2f\\\" % result\",\n \"def custom_score_5(game, player):\\n \\\"\\\"\\\"custom_score_5 heuristic function defines chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return -math.inf\\n\\n if game.is_winner(player):\\n return math.inf\\n\\n opponent = game.get_opponent(player)\\n\\n opp_moves = game.get_legal_moves(opponent)\\n own_moves = game.get_legal_moves(player)\\n\\n # Calculate the normalized distance if both players are on the board.\\n player_loc = game.get_player_location(player)\\n opp_loc = game.get_player_location(opponent)\\n norm_dis = 0\\n if opp_loc and player_loc:\\n norm_dis = distance(player_loc, opp_loc) / 8.46 # 8.46 is distance((0, 0), (6, 6))\\n\\n return len(own_moves) / max(len(opp_moves), 1e-6) - norm_dis\",\n \"def evaluate(self, state):\\n\\t\\ttranspose = state.board.transpose()\\t\\t# columns in state.board = rows in transpose\\n\\t\\tcount = []\\n\\t\\topponentcount = []\\n\\t\\tfor row, column in zip(state.board, transpose):\\n\\t\\t\\trowcounter = collections.Counter(row)\\n\\t\\t\\tcolumncounter = collections.Counter(column)\\n\\t\\t\\tcount.append(rowcounter.get(state.current_player, 0))\\n\\t\\t\\tcount.append(columncounter.get(state.current_player, 0))\\n\\t\\t\\topponentcount.append(rowcounter.get(state.current_player * - 1, 0))\\n\\t\\t\\topponentcount.append(columncounter.get(state.current_player * -1 , 0))\\n\\n\\t\\tY = state.board[:, ::-1]\\n\\t\\tdiagonals = [np.diagonal(state.board), np.diagonal(Y)]\\n\\t\\tmain_diagonal_count = collections.Counter(diagonals[0])\\n\\t\\tsecond_diagonal_count = collections.Counter(diagonals[1])\\n\\t\\tcount.append(main_diagonal_count.get(state.current_player, 0))\\n\\t\\tcount.append(second_diagonal_count.get(state.current_player, 0))\\n\\t\\topponentcount.append(main_diagonal_count.get(state.current_player * - 1, 0))\\n\\t\\topponentcount.append(second_diagonal_count.get(state.current_player * -1, 0))\\n\\n\\t\\t# max(count): maximum number of player's tiles in a row, column, or a diagonal (the highest value is 5)\\n\\t\\t# max(opponentcount): maximum number of opponent's tiles in a row, column, or a diagonal (the highest value is 5)\\n\\t\\tscoremax = 5 ** max(count)\\n\\t\\tscoremin = 5 ** max(opponentcount)\\n\\n\\t\\treturn scoremax - scoremin\",\n \"def _estimate_strength_from_results(\\n number_of_games: int, number_of_wins: int, opponent_rating: float\\n) -> Tuple[float, Tuple[float, float]]:\\n n, p = number_of_games, number_of_wins / number_of_games\\n q = 1 - p\\n\\n if n * p * q < 9: # Cannot apply normal approximation of binomial distribution\\n raise ValueError(\\n \\\"The results obtained in evaluate_player are too extreme to obtain an \\\"\\n \\\"accurate player evaluation. You can try to solve this issue by increasing\\\"\\n \\\" the total number of battles. Obtained results: %d victories out of %d\\\"\\n \\\" games.\\\" % (p * n, n)\\n )\\n\\n estimate = opponent_rating * p / q\\n error = (\\n math.sqrt(n * p * q) / n * 1.96\\n ) # 95% confidence interval for normal distribution\\n\\n lower_bound = max(0, p - error)\\n lower_bound = opponent_rating * lower_bound / (1 - lower_bound)\\n\\n higher_bound = min(1, p + error)\\n\\n if higher_bound == 1:\\n higher_bound = math.inf\\n else:\\n higher_bound = opponent_rating * higher_bound / (1 - higher_bound)\\n\\n return estimate, (lower_bound, higher_bound)\",\n \"def custom_score_3(game, player):\\n \\\"\\\"\\\"custom_score_3 heuristic function aims at maximizing win chances of my agent\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = 1.0 * len(game.get_legal_moves(player))#Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves with oppositePlayer\\n\\n if length_my_player_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n if length_opp_payer_moves == 0:\\n return float(\\\"inf\\\")\\n\\n return float(length_my_player_moves/length_opp_payer_moves)\",\n \"def custom_score_4(game, player):\\n \\\"\\\"\\\"custom_score_4 heuristic function aims at minimizing loosing chances of myPlayer\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = 1.0 * len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n\\n if length_my_player_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n if length_opp_payer_moves == 0:\\n return float(\\\"inf\\\")\\n\\n return float(-length_opp_payer_moves/length_my_player_moves)\",\n \"def gameOver(self, myScore, oppScore):\\r\\n self.gamePlayed += 1\\r\\n self.averageNumTurns = (self.averageNumTurns * self.gamePlayed + self.thisNumTurns) / self.gamePlayed\\r\\n self.thisNumTurns = 0.0\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n # Aim to maximise your own available moves vs the opponent (Factor 2)\\n\\n opponent = game.get_opponent(player)\\n return float(len(game.get_legal_moves(player)))-2.0*float(len(game.get_legal_moves(opponent)))\",\n \"def calc_winner(self):\\n pass\",\n \"def score2(self,player, board):\\r\\n numPlayer = 0\\r\\n numOpp = 0\\r\\n for i in self.squares():\\r\\n if board[i] == player:\\r\\n numPlayer+= 1\\r\\n else:\\r\\n numOpp+=1\\r\\n return numPlayer-numOpp\",\n \"def opponents_score(self):\\n if self.opponent_wickets == 10:\\n var1 = \\\"All Out\\\"\\n return str('{0} {1}').format(self.opponent_runs, var1)\\n else:\\n var1 = self.opponent_wickets\\n return str('{0}-{1}').format(self.opponent_runs, var1)\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def get_win_rate_regular_season_for_each_coach(self):\\n self.games_won_for_coaches = (\\n self.raw_data_regularseason\\n [['Season','DayNum','WTeamID']]\\n # merge for winning team\\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\\n how='left',left_on=['Season','WTeamID'],right_on=['Season','TeamID'])\\n .rename(columns={\\\"FirstDayNum\\\":\\\"FirstDayNum_win\\\",\\\"LastDayNum\\\":\\\"LastDayNum_win\\\",\\\"CoachName\\\":\\\"CoachName_win\\\",\\\"TeamID\\\":\\\"TeamID_win\\\"})\\n .pipe(lambda x:x.assign(which_coach_for_win = np.where((x.FirstDayNum_win <= x.DayNum) & (x.LastDayNum_win >= x.DayNum),1,0)))\\n .query(\\\"which_coach_for_win != 0\\\")\\n .groupby(['Season','CoachName_win','WTeamID'])\\n .agg({\\\"which_coach_for_win\\\":\\\"sum\\\"})\\n .reset_index()\\n )\\n\\n self.games_lose_for_coaches = (\\n self.raw_data_regularseason\\n [['Season','DayNum','LTeamID']]\\n # merge for losing team\\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\\n how='left',left_on=['Season','LTeamID'],right_on=['Season','TeamID'])\\n .rename(columns={\\\"FirstDayNum\\\":\\\"FirstDayNum_lose\\\",\\\"LastDayNum\\\":\\\"LastDayNum_lose\\\",\\\"CoachName\\\":\\\"CoachName_lose\\\",\\\"TeamID\\\":\\\"TeamID_lose\\\"})\\n .pipe(lambda x:x.assign(which_coach_for_lose = np.where((x.FirstDayNum_lose <= x.DayNum) & (x.LastDayNum_lose >= x.DayNum),1,0)))\\n .query(\\\"which_coach_for_lose != 0\\\")\\n .groupby(['Season','CoachName_lose','LTeamID'])\\n .agg({\\\"which_coach_for_lose\\\":\\\"sum\\\"})\\n .reset_index()\\n )\\n\\n # combine games won and lost df\\n self.combine_regular_games_won_lose = (\\n self.games_lose_for_coaches\\n .merge(self.games_won_for_coaches,how='left',left_on=['Season','LTeamID','CoachName_lose'],right_on=['Season','WTeamID','CoachName_win'])\\n .pipe(lambda x:x.assign(win_rate_regular = x.which_coach_for_win/(x.which_coach_for_win + x.which_coach_for_lose)))\\n .drop(['CoachName_win','WTeamID'],1)\\n .rename(columns={\\\"CoachName_lose\\\":\\\"CoachName\\\",\\\"LTeamID\\\":\\\"TeamID\\\",\\\"which_coach_for_lose\\\":\\\"games_lost\\\",\\\"which_coach_for_win\\\":\\\"games_won\\\"})\\n )\",\n \"def calculate_score(self):\\n\\n correct_award = 150\\n turns_total = self.turns.count()\\n turns_correct = self.turns.filter(is_match=True).count()\\n seconds_left = (60.0 - (self.turns.last().created - self.turns.first().created).total_seconds()) or 0\\n maxpoints = turns_correct * correct_award\\n deduction_for_errors = correct_award * 0.11123\\n\\n maxpoints -= ((turns_total - turns_correct) * 2 * deduction_for_errors)\\n maxpoints += seconds_left * 5.123214\\n\\n return Decimal(maxpoints)\",\n \"def get_game_score(self):\\n if self.game_is_tied():\\n return 0\\n elif self.is_game_won():\\n my_available_steps = self.steps_available(self.loc)\\n opp_available_steps = self.steps_available(self.opponent_loc)\\n my_score = self.my_score - self.penalty_score if my_available_steps == 0 else self.my_score\\n opp_score = self.opponent_score - self.penalty_score if opp_available_steps == 0 else self.opponent_score\\n return (my_score - opp_score) / (abs(my_score) + abs(opp_score))\\n else:\\n if abs(self.my_score) + abs(self.opponent_score) == 0:\\n return 0\\n return (self.my_score - self.opponent_score) / (abs(self.my_score) + abs(self.opponent_score))\",\n \"def calculate_score_pairs(hand_value,*args):\\n # ratios=[1,10,100,1000,10000]\\n ratios = CONST.RATIOS[:]\\n return sum(map(lambda a,b:a/b, args, ratios))+hand_value\",\n \"def improved_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\",\n \"def GetResult(self, playerjm):\\n return self.score / len(self.scores)\",\n \"def update_stats(home_player: Player, away_player: Player,\\n home_score: int, away_score: int) -> None:\\n home_player.goals_for += home_score\\n home_player.goals_against += away_score\\n away_player.goals_for += away_score\\n away_player.goals_against += home_score\\n\\n # home won\\n if (home_score > away_score):\\n home_player.wins += 1\\n away_player.losses += 1\\n # away won\\n elif (home_score < away_score):\\n home_player.losses += 1\\n away_player.wins += 1\\n # draw\\n else:\\n home_player.draws += 1\\n away_player.draws += 1\",\n \"def evaluate(self, state):\\n total_rewards = np.array([0.0] * state.num_players)\\n for _ in range(self.width): # for each of width simulations\\n total_rewards += self.run_rollout(state)\\n\\n return total_rewards / self.width\",\n \"def score(player, board):\\n mine, theirs = 0, 0\\n opp = Othello.opponent(player)\\n for sq in Othello.squares():\\n piece = board[sq]\\n if piece == player: mine += 1\\n elif piece == opp: theirs += 1\\n return mine - theirs\",\n \"def custom_score_7(game, player):\\n \\\"\\\"\\\"custom_score_7 heuristic function also aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n result = 0\\n outcomes = range(1, num_die_sides + 1)\\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\\n for hand in possible:\\n result += score(held_dice + hand)\\n return float(result)/len(possible)\",\n \"def get_fool_ratio(self, test_acc, attack_accs):\\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]\",\n \"def get_new_ratings(players, teams):\\n nb_players_team0 = len(teams[0])\\n nb_players_team1 = len(teams[1])\\n winner = players[teams[0][0]]\\n loser = players[teams[1][0]]\\n if nb_players_team0 == 1 and nb_players_team1 == 1:\\n new_r1, new_r3 = rate_1vs1(winner,loser)\\n elif nb_players_team0 == 1 and nb_players_team1 > 1:\\n team_loser = [loser, players[teams[1][1]]]\\n (new_r1), (new_r3, new_r4) = rate([winner, team_loser], ranks=[0, 1]) \\n elif nb_players_team0 > 1 and nb_players_team1 == 1:\\n team_winner = [winner, players[teams[0][1]]]\\n (new_r1, new_r2), (new_r3) = rate([team_winner, loser], ranks=[0, 1]) \\n else:\\n team_loser = [loser, players[teams[1][1]]]\\n team_winner = [winner, players[teams[0][1]]]\\n (new_r1, new_r2), (new_r3, new_r4) = rate([team_winner, team_loser], ranks=[0, 1]) \\n player1 = {'name': teams[0][0], 'mu': new_r1.mu, 'sigma': new_r1.sigma}\\n player3 = {'name': teams[1][0], 'mu': new_r3.mu, 'sigma': new_r3.sigma}\\n if nb_players_team0 > 1:\\n player2 = {'name': teams[0][1], 'mu': new_r2.mu, 'sigma': new_r2.sigma}\\n if nb_players_team1 > 1:\\n player4 = {'name': teams[1][1], 'mu': new_r4.mu, 'sigma': new_r4.sigma}\\n if nb_players_team0 > 1:\\n return [player1, player2, player3, player4]\\n return [player1, player2, player4]\\n return [player1, player3]\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n outcomes = get_outcomes(num_die_sides)\\n print \\\"outcomes:\\\", outcomes\\n\\n # generate all possible sequences of rolls\\n all_rolls = list(gen_all_sequences(outcomes, num_free_dice))\\n results = [max_repeats(roll) for roll in all_rolls]\\n value = 0.0 \\n\\n\\n for result in all_rolls:\\n curr_hand = tuple(list(held_dice) + list(result))\\n value += score(curr_hand)\\n\\n return value / len(all_rolls)\",\n \"def _calculate_score(self):\\n mul = self._check_board()\\n if mul > 0:\\n inc = 100 * mul + ((mul - 1) * 25)\\n self.score += inc\",\n \"def calculate_scores(players):\\n scores = {}\\n for player in players.tuple_:\\n scores[player.id_] = player.score()\\n return scores\",\n \"def get_score(self, player: int) -> int:\\n score = 0\\n i = 0\\n while i < len(self.leylines):\\n score += 1 if self.leylines[i].player == player else 0\\n score += 1 if self.rights[i].player == player else 0\\n score += 1 if self.lefts[i].player == player else 0\\n i += 1\\n return score\",\n \"def horizontal_ratio(self):\\n if self.pupils_located:\\n pupil_left = self.eye_left.pupil.x / (self.eye_left.center[0] * 2 - 10)\\n pupil_right = self.eye_right.pupil.x / (self.eye_right.center[0] * 2 - 10)\\n return (pupil_left + pupil_right) / 2\",\n \"def get_average_distance_to_opponents(obs, player_x, player_y):\\n distances_sum = 0\\n distances_amount = 0\\n for i in range(1, len(obs[\\\"right_team\\\"])):\\n # if opponent is ahead of player\\n if obs[\\\"right_team\\\"][i][0] > (player_x - 0.02):\\n distance_to_opponent = get_distance(player_x, player_y, obs[\\\"right_team\\\"][i][0], obs[\\\"right_team\\\"][i][1])\\n if distance_to_opponent < 0.03:\\n distances_sum += distance_to_opponent\\n distances_amount += 1\\n # if there is no opponents close around\\n if distances_amount == 0:\\n return 2, distances_amount\\n return distances_sum / distances_amount, distances_amount\",\n \"def host_result_value(winner: Winner) -> float:\\n if winner == Winner.HOME:\\n return 1\\n if winner == Winner.AWAY:\\n return 0\\n return 0.5\",\n \"def calculate_score(player_cards):\\n score = sum(player_cards)\\n return score\",\n \"def rough_outcome(self) -> float:\\n # HUYNH YOU PRICK WHY THE FUCK DO YOU MAKE US WRITE THIS SHIT EVEN IT'S NOT USED ANYWHERE\\n # pick move based on this may not be optimal but better than random\\n # return 1 if win immediately\\n # return -1 if all states reachable will result the other player win\\n # return 0 if otherwise ??? what the fuck does this mean\\n # look two states forward\\n pass\",\n \"def calculateRatio(levelDims):\\n highestReso = np.asarray(levelDims[0])\\n lowestReso = np.asarray(levelDims[-1])\\n Xratio, Yratio = highestReso/lowestReso\\n return (Xratio, Yratio)\",\n \"def calc_win_lose_ratio(self):\\n total = len(self.train_y)\\n survived = 0\\n for i in self.train_y:\\n if i > 0:\\n survived += 1\\n\\n self.survival_sum = [survived, total-survived]\",\n \"def getWinProbability(team1, team2, r, year=2019):\\n\\tR1_PROBS = R1_PROBS_2019 if year == 2019 else R1_PROBS_2020\\n\\tALPHA_VALS = ALPHA_VALS_2019 if year == 2019 else ALPHA_VALS_2020\\n\\n\\t# Currently using Power Model\\n\\ts1 = team1['seed']\\n\\ts2 = team2['seed']\\n\\n\\t# Use R1_PROBS for round 1\\n\\tif r == 1:\\n\\t\\tif not (s1 + s2 == 17):\\n\\t\\t\\texit('Invalid round 1 matchup: seeds {0} vs. {1}.'.format(s1, s2))\\n\\t\\treturn R1_PROBS[s1] if s1 < s2 else R1_PROBS[s2]\\n\\t\\n\\t# Use ALPHA_VALS for other rounds (unless seeds are same)\\n\\tif s1 == s2:\\n\\t\\treturn 0.5\\n\\n\\talpha = ALPHA_VALS[r]\\n\\ts1a = (s1 * 1.0) ** alpha\\n\\ts2a = (s2 * 1.0) ** alpha\\n\\treturn s2a / (s1a + s2a)\",\n \"def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\\n ratio_x = 0\\n ratio_y = 0\\n ratio_z = 0\\n # helm_B = [0,0,0]\\n divideby = 0\\n for shot in range(shot_range[0], shot_range[1]+1):\\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\\n ratio_x = ratio_x + x\\n ratio_y = ratio_y + y\\n ratio_z = ratio_z + z\\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\\n divideby = divideby + 1 #averaging over the number of shots\\n ratio_Bx = ratio_x/divideby\\n ratio_By = ratio_y/divideby\\n ratio_Bz = ratio_z/divideby\\n # helmB = [helm_B]/divideby\\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\\n # print(\\\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\\\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\\n Bx_sqr =ratio_x**2\\n By_sqr =ratio_y**2\\n Bz_sqr =ratio_z**2\\n B = Bx_sqr + By_sqr+ Bz_sqr\\n norm_factor = np.sqrt(B)\\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\\n\\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)\",\n \"def _compute_winrates(synergy, counter, heroes_released):\\n for i in range(heroes_released):\\n for j in range(heroes_released):\\n if i != j and i != 23 and j != 23:\\n if synergy['games'][i, j] != 0:\\n synergy['winrate'][i, j] = synergy['wins'][i, j] / \\\\\\n float(synergy['games'][i, j])\\n\\n if counter['games'][i, j] != 0:\\n counter['winrate'][i, j] = counter['wins'][i, j] / \\\\\\n float(counter['games'][i, j])\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n game_phase = len(game.get_blank_spaces()) # high if early, low if late\\n\\n # Heuristic tries to take advantage of the center and shadowing if possible, otherwise stick to the centre and maximise number of moves \\n\\n # (*0) Calculate the (theoretical) centre\\n center = (game.width / 2., game.height / 2.)\\n opponent = game.get_opponent(player)\\n loc_player = game.get_player_location(player)\\n loc_opponent = game.get_player_location(opponent)\\n if game.width % 2 != 0 and game.height % 2 != 0:\\n trueCentre = True\\n loc_mirror = tuple(abs(x-(game.width-1)) for x in loc_player) # the mirrored location of the player across the axes\\n else:\\n trueCentre = False\\n # (1) Always take the centre!\\n if loc_player == center:\\n return float(\\\"inf\\\")\\n # (2) If opponent has the centre, avoid a position within knight's movement at all costs to avoid shadowing\\n if loc_opponent == center:\\n r, c = center\\n directions = [(-2, -1), (-2, 1), (-1, -2), (-1, 2),(1, -2), (1, 2), (2, -1), (2, 1)]\\n avoidable_positions = [(r + dr, c + dc) for dr, dc in directions]\\n if loc_player in avoidable_positions:\\n return float(\\\"-inf\\\")\\n # (3) If we can shadow the opponent, we should!\\n if trueCentre:\\n if center not in game.get_blank_spaces() and loc_opponent == loc_mirror and len(game.get_legal_moves(player)) == len(game.get_legal_moves(opponent)):\\n return float(\\\"inf\\\")\\n # (4) Finally, we simply return number of moves active player can make minus number of moves opponent can make minus the distance from the centre, weighted by the game phase\\n w, h = center\\n y, x = loc_player\\n dist = float((h - y)**2 + (w - x)**2)\\n return (float(len(game.get_legal_moves(player)))-2.0*float(len(game.get_legal_moves(opponent)))-dist)*game_phase\",\n \"def custom_score(game, player):\\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the improved score\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n improved = len(player_legal_moves) - len(opponent_legal_moves)\\n if improved != 0:\\n return float(improved)\\n \\n # Second get differences from center\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n player_coordinates = game.get_player_location(player)\\n opponent_coordinates = game.get_player_location(opponent)\\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\\n center_dist_diff = player_center_dist - opponent_center_dist\\n \\n # Third obtain next_moves\\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \\n improved_next = len(player_next_moves) - len(opponent_next_moves)\\n \\n # Put player and opponent feature differences in a tuple/vector surrogoate\\n feature_diff_vector = (improved, center_dist_diff, improved_next)\\n \\n # Provide a weighting vector for the features of each player-participant\\n weight_vector = (1.5,0.1,1.0)\\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(feature_diff_vector, weight_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def p(party, vote_count, s):\\n return t(party, vote_count) / d(s)\",\n \"def custom_score(game, player):\\n \\\"\\\"\\\" custom_score heuristic function idea is to implement aggressive heuristic function \\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) # Calculate length of myPlayer moves\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player))) # Calculate length of opposite player moves same as custom score 2\\n return float(length_my_player_moves - 1.5*length_opp_payer_moves)\",\n \"def custom_score(game, player):\\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n if game.move_count < 15:\\n return center_modified_score(game, player)\\n\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = len(game.get_legal_moves(player))\\n\\n if game.move_count < 15:\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\\n\\n delta = 0\\n\\n moves = game.get_legal_moves()\\n initial_moves_count = len(moves)\\n indexes = np.random.permutation(initial_moves_count)\\n\\n for i in range(0, min(4, initial_moves_count)):\\n first_level = True\\n simulation = game.copy()\\n\\n while True:\\n moves = simulation.get_legal_moves()\\n moves_count = len(moves)\\n if moves_count == 0:\\n if simulation.is_winner(player):\\n delta = delta + 1\\n else:\\n delta = delta - 1\\n break\\n if first_level:\\n selected_move = indexes[i]\\n first_level = False\\n else:\\n selected_move = random.randint(0, moves_count - 1)\\n\\n simulation.apply_move(moves[selected_move])\\n\\n return float(own_moves + delta) #float(own_moves - opp_moves + 5 * delta)\\n\\n #return float(own_moves - opp_moves + free_area_score(game, player) - free_area_score(game, game.get_opponent(player)))\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the base information to calculate player & opponent\\n # feature values\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n if len(player_legal_moves) != len(opponent_legal_moves):\\n return float(len(player_legal_moves) - len(opponent_legal_moves))\\n \\n # Get_center_coordinates and opponent. Then set the list of participants\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n participants = [player, opponent]\\n \\n # Then, for each participant obtain his/her feature values \\n for participant in participants:\\n if participant == player:\\n p_legal_moves = player_legal_moves\\n player_either = player\\n participant_coordinates = p_y, p_x = \\\\\\n game.get_player_location(participant)\\n player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, \\\\\\n player_path_count, player_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either,participant_coordinates, p_legal_moves)\\n else:\\n p_legal_moves = opponent_legal_moves\\n player_either = opponent\\n participant_coordinates = p_y, p_x \\\\\\n = game.get_player_location(participant)\\n opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, opponent_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either, participant_coordinates, p_legal_moves)\\n \\n # Place each participant's feature values in a tuple/vector surrogate \\n pro_player_vector = \\\\\\n (player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, player_path_count, \\\\\\n opponent_min_center_diff)\\n pro_opponent_vector = \\\\\\n (opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, player_min_center_diff)\\n \\n # Provide a weighting vector for the features \\n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\\n \\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\\\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def calculate_overall_rating(player_dict):\\r\\n if player_dict[\\\"position\\\"].upper() == \\\"QB\\\":\\r\\n throw_power = int(max(min(int(player_dict[\\\"throw_power\\\"]), 99), 70))\\r\\n throw_accuracy = int(max(min(math.ceil(\\r\\n ((2 * (\\r\\n int(player_dict[\\\"throw_accuracy_short\\\"]) + \\r\\n int(player_dict[\\\"throw_accuracy_mid\\\"]) + \\r\\n int(player_dict[\\\"throw_accuracy_deep\\\"]) + \\r\\n int(player_dict[\\\"throw_on_the_run\\\"]) + \\r\\n int(player_dict[\\\"playaction\\\"])\\r\\n )) - (2 * min(\\r\\n int(player_dict[\\\"throw_accuracy_short\\\"]), \\r\\n int(player_dict[\\\"throw_accuracy_mid\\\"]), \\r\\n int(player_dict[\\\"throw_accuracy_deep\\\"]), \\r\\n int(player_dict[\\\"throw_on_the_run\\\"]), \\r\\n int(player_dict[\\\"playaction\\\"])\\r\\n ))\\r\\n ) / 8\\r\\n ), 99), 60))\\r\\n break_tackles = int(max(min(\\r\\n math.ceil(((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 7), \\r\\n 90), 20))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 98), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 55))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((throw_power - 50.0) / 10.0) * 4.9\\r\\n overall_rating += ((throw_accuracy - 50.0) / 10.0) * 5.8\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.0\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"HB\\\":\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 70), 25))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 99), 50))\\r\\n carrying = int(max(min(int(player_dict[\\\"carrying\\\"]), 99), 60))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 45))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 50))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 0.33\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((carrying - 50.0) / 10.0) * 2.0\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.0\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.6\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 1.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"FB\\\":\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 75), 40))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 85), 45))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 99), 55))\\r\\n carrying = int(max(min(int(player_dict[\\\"carrying\\\"]), 99), 60))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 55))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 95), 60))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 60))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.0\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 7.2\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((carrying - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.0\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 5.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 39), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"WR\\\":\\r\\n break_tackles = int(max(min(\\r\\n math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2), \\r\\n 80), 35))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 75))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 75))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 35))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 99), 65))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"TE\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 55))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 55))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 55))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 60))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 99), 45))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 95), 20))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 80), 35))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 85), 35))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.25\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.25\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 5.4\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.2\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.2\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 5.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 35), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LT\\\" or player_dict[\\\"position\\\"].upper() == \\\"RT\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 85), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 85), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 90), 60))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 60))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 3.75\\r\\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if (player_dict[\\\"position\\\"].upper() == \\\"LG\\\" or player_dict[\\\"position\\\"].upper() == \\\"RG\\\" or \\r\\n player_dict[\\\"position\\\"].upper() == \\\"C\\\"):\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 85), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 85), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 90), 60))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 65))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 4.8\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LE\\\" or player_dict[\\\"position\\\"].upper() == \\\"RE\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 90), 55))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 90), 45))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 3.8\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 5.5\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"DT\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 90), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 90), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 5.5\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 4.55\\r\\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LOLB\\\" or player_dict[\\\"position\\\"].upper() == \\\"ROLB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 70))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 65))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 75))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 90), 20))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 2.4\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.6\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.4\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 1.3\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 4.8\\r\\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"MLB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 65))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 65))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 75))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 0.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.4\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 5.2\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.65\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 5.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"CB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 40))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 75))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 40))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 85), 30))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.85\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.85\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.55\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.35\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.55\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 1.55\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"FS\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 75))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 35))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 90), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.0\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.85\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.5\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.5\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3.0\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.5\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 2.5\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"SS\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 75))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 35))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 90), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.2\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3.2\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 3.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"K\\\":\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 85), 35))\\r\\n kick_power = int(max(min(int(player_dict[\\\"kick_power\\\"]), 99), 80))\\r\\n kick_accuracy = int(max(min(int(player_dict[\\\"kick_accuracy\\\"]), 99), 70))\\r\\n \\r\\n overall_rating = (-177 + (0.218 * awareness) + (1.28 * kick_power) + (1.47 * kick_accuracy))\\r\\n overall_rating = int(max(min(round(overall_rating), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"P\\\":\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 85), 40))\\r\\n kick_power = int(max(min(int(player_dict[\\\"kick_power\\\"]), 99), 80))\\r\\n kick_accuracy = int(max(min(int(player_dict[\\\"kick_accuracy\\\"]), 99), 70))\\r\\n \\r\\n overall_rating = (-183 + (0.218 * awareness) + (1.5 * kick_power) + (1.33 * kick_accuracy))\\r\\n overall_rating = int(max(min(round(overall_rating), 99), 40))\\r\\n return overall_rating\",\n \"def get_improved_score_factor(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\",\n \"def custom_score_3(game, player):\\n \\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n player_legal_move_count, opponent_legal_move_count = \\\\\\n len(player_legal_moves), len(opponent_legal_moves)\\n move_count_difference = player_legal_move_count - opponent_legal_move_count\\n # Find coordinates of center box\\n h, w = get_center_coordinates(game)\\n # Retrieve player's coordinates\\n y, x = game.get_player_location(player)\\n # Obtain coordinate further, closest to origin\\n furthest_coord, closest_coord = max(h - y, w -x), min(h - y, w - x)\\n # Return weighted, vector-valued length from origin / sum of weights\\n weighted_distance_from_center = \\\\\\n math.sqrt((closest_coord**2 + 2*(furthest_coord**2)))/3\\n feature_vector = (move_count_difference, weighted_distance_from_center)\\n \\n weight_vector = (1.0,0.1)\\n \\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(weight_vector, feature_vector)) \\n \\n return float(weighted_difference_dot_product)\",\n \"def evaluate_board(self, board):\\n \\n win_score = 100\\n win_or_loss_score = 50\\n lose_score = 0\\n \\n if board.win_for(self.opponent()):\\n return lose_score\\n if board.win_for(self.side):\\n return win_score\\n if not board.win_for(self.side) or not board.win_for(self.opponent()):\\n return win_or_loss_score\",\n \"def compute_drift_score(ref_col_prob, col_prob):\\n\\n return sum(abs(np.asarray(ref_col_prob) - np.array(col_prob)) * 100)\",\n \"def quick_ratio(self):\\n return (\\n self.current_assets - self.inventory_net) / self.current_liabilities\",\n \"def evaluate(game, player):\\n weights = [2, 200, 2000, 20000]\\n reward = 0\\n opponent = get_opponent(player)\\n for length in range(2, 6):\\n reward += weights[length - 2] * get_num_series(game, player, length)\\n reward -= weights[length - 2] * get_num_series(game, opponent, length)\\n return reward\",\n \"def ucbScore(self,totalPlayedTimes):\\n winRate = self.winRate()\\n #print totalPlayedTimes\\n #print self.playedTimes\\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\\n \\n return winRate + confidenceInterval\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def evaluate(self):\\n # if player has no move, then player lost, -inf or inf depend on who the player is\\n # if player has moves, use heuristics.\\n \\n #checkColorMoves = self.getAvailableMoves(self.colorIndex)\\n #otherColorMoves = self.getAvailableMoves(1-self.colorIndex)\\n \\n checkColorMoves = self.getAvailableMovesPreferLonger(self.colorIndex)\\n otherColorMoves = self.getAvailableMovesPreferLonger(1-self.colorIndex)\\n\\n checkColorPieces = self.getPieceCount(self.colorIndex)\\n otherColorPieces = self.getPieceCount(1-self.colorIndex)\\n\\n #checkColorEdgePieces = self.getEgdePieceCount(self.colorIndex)\\n #otherColorEdgePieces = self.getEgdePieceCount(1-self.colorIndex)\\n\\n if self.player == 'computer':\\n if checkColorMoves == 0: #computer doesn't have moves\\n return float('-inf')\\n elif otherColorMoves == 0: #user doesn't have moves\\n return float('inf')\\n else:\\n #return checkColorPieces - otherColorPieces\\n return checkColorMoves - otherColorMoves\\n else:\\n if checkColorMoves == 0: #user doesn't have moves\\n return float('inf')\\n elif otherColorMoves == 0: #computer doesn't have moves\\n return float('-inf')\\n else:\\n #return otherColorPieces - checkColorPieces\\n return otherColorMoves - checkColorMoves\",\n \"def compute_utility(self, board, move, player):\\n r_alive = 0\\n b_alive = 0\\n rk_alive = 0\\n bk_alive = 0\\n for line in range(8):\\n for col in range(8):\\n if board[line][col] == \\\"R\\\":\\n r_alive += 1\\n elif board[line][col] == \\\"B\\\":\\n b_alive += 1\\n elif board[line][col] == \\\"RK\\\":\\n rk_alive += 1\\n elif board[line][col] == \\\"BK\\\":\\n bk_alive += 1\\n # if r_Alive > b_Alive:\\n # if b_Alive == 0:\\n # return 1\\n # else: return 0\\n # elif r_Alive == 0:\\n # return -1\\n powkings = 1.2\\n result = 0\\n if player == 'B':\\n result = rk_alive*powkings + r_alive - bk_alive*powkings - b_alive\\n else:\\n result = bk_alive*powkings + b_alive - rk_alive*powkings - r_alive\\n return result\",\n \"def rate_club(user, club):\\n if not user.is_authenticated():\\n return None\\n if not club.posel_set.exists():\\n return None\\n return sum(x[1] for x in rank_in_club(user, club)) / club.posel_set.count()\",\n \"def custom_score_general(game, player, constants=[]):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n v = []\\n\\n if constants[0] != 0 or constants[2] != 0:\\n own_moves = number_moves(game, player) / 8\\n\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n v.append(own_moves)\\n\\n if constants[1] != 0 or constants[2] != 0:\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n v.append(opp_moves)\\n\\n if constants[2] != 0:\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n v.append(move_ratio)\\n\\n if constants[3] != 0 or constants[5] != 0:\\n own_openness = nearby_openness(game, player) / 80\\n v.append(own_openness)\\n\\n if constants[4] != 0 or constants[5] != 0:\\n opp_openness = nearby_openness(game, game.get_opponent(player)) / 80\\n v.append(opp_openness)\\n\\n if constants[5] != 0:\\n openness_ratio = (own_openness * 80) / (opp_openness + 0.0001 * 80) /80\\n v.append(openness_ratio)\\n\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n if constants[6] != 0 or constants[8] != 0:\\n own_centerness = centerness(game, player) / centerness_max\\n v.append(own_centerness)\\n\\n if constants[7] != 0 or constants[8] != 0:\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n v.append(opp_centerness)\\n\\n if constants[8] != 0:\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n return sum([x * y for x, y in zip(constants, v)])\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\r\\n \\r\\n scores = []\\r\\n \\r\\n die_sides = [(die + 1) for die in range(num_die_sides)]\\r\\n \\r\\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\\r\\n\\r\\n for outcome in pos_outcomes:\\r\\n scores.append(score(held_dice + outcome))\\r\\n \\r\\n expected_result = float(sum(scores))/len(scores)\\r\\n \\r\\n return expected_result\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n #own_moves = len(game.get_legal_moves(player))\\n\\n #if game.move_count < 23:\\n # opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n # return float(own_moves - opp_moves)\\n\\n return float(free_area_score(game, player) - free_area_score(game, game.get_opponent(player)))\",\n \"def get_win_rate_post_season_for_each_coach(self):\\n # get winning games for coaches\\n self.post_games_won_for_coaches = (\\n self.raw_data_postseason\\n [['Season','DayNum','WTeamID']]\\n # merge for winning team\\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\\n how='left',left_on=['Season','WTeamID'],right_on=['Season','TeamID'])\\n .rename(columns={\\\"FirstDayNum\\\":\\\"FirstDayNum_win\\\",\\\"LastDayNum\\\":\\\"LastDayNum_win\\\",\\\"CoachName\\\":\\\"CoachName_win\\\",\\\"TeamID\\\":\\\"TeamID_win\\\"})\\n .pipe(lambda x:x.assign(which_coach_for_win = np.where((x.FirstDayNum_win <= x.DayNum) & (x.LastDayNum_win >= x.DayNum),1,0)))\\n .query(\\\"which_coach_for_win != 0\\\")\\n .groupby(['Season','CoachName_win','WTeamID'])\\n .agg({\\\"which_coach_for_win\\\":\\\"sum\\\"})\\n .reset_index()\\n )\\n\\n # get losing games for coaches\\n self.post_games_lose_for_coaches = (\\n self.raw_data_postseason\\n [['Season','DayNum','LTeamID']]\\n # merge for losing team\\n .merge(self.num_days_coach_for_season[['Season','TeamID','FirstDayNum','LastDayNum','CoachName']],\\n how='left',left_on=['Season','LTeamID'],right_on=['Season','TeamID'])\\n .rename(columns={\\\"FirstDayNum\\\":\\\"FirstDayNum_lose\\\",\\\"LastDayNum\\\":\\\"LastDayNum_lose\\\",\\\"CoachName\\\":\\\"CoachName_lose\\\",\\\"TeamID\\\":\\\"TeamID_lose\\\"})\\n .pipe(lambda x:x.assign(which_coach_for_lose = np.where((x.FirstDayNum_lose <= x.DayNum) & (x.LastDayNum_lose >= x.DayNum),1,0)))\\n .query(\\\"which_coach_for_lose != 0\\\")\\n .groupby(['Season','CoachName_lose','LTeamID'])\\n .agg({\\\"which_coach_for_lose\\\":\\\"sum\\\"})\\n .reset_index()\\n )\\n\\n # combine games won and lost df for post season\\n self.combine_post_games_won_lose = (\\n self.post_games_lose_for_coaches\\n .merge(self.post_games_won_for_coaches,how='left',left_on=['Season','LTeamID','CoachName_lose'],right_on=['Season','WTeamID','CoachName_win'])\\n .pipe(lambda x:x.assign(win_rate_post = x.which_coach_for_win/(x.which_coach_for_win + x.which_coach_for_lose)))\\n .drop(['CoachName_win','WTeamID'],1)\\n .rename(columns={\\\"CoachName_lose\\\":\\\"CoachName\\\",\\\"LTeamID\\\":\\\"TeamID\\\",\\\"which_coach_for_lose\\\":\\\"post_games_lost\\\",\\\"which_coach_for_win\\\":\\\"post_games_won\\\"})\\n .fillna(0)\\n )\",\n \"def Winner(self, whichPlayer, tResult, score, gameCount):\\n\\n if whichPlayer == 0:\\n tResult[0] = tResult[0] + score[0]\\n else:\\n tResult[1] = tResult[1] + score[1]\\n print(data['tResult'],\\\"player1 \\\", tResult[0],\\\"player2 \\\",tResult[1])\\n if gameCount == 3:\\n if tResult[0] > tResult[1]:\\n print(data['mplayer1'],tResult[0] - tResult[1])\\n else:\\n print(data['mplayer2'],tResult[1] - tResult[0])\\n return whichPlayer, score, gameCount, tResult\",\n \"def state_score_naive(self, game_state, player, weights):\\n # walls score\\n other_players = [p for p in game_state.players if p != player]\\n my_walls = player.num_walls\\n their_walls = max([p.num_walls for p in other_players])\\n walls_diff = (my_walls - their_walls)\\n # path length score\\n my_path = len(game_state.get_shortest_path_player(player))\\n their_path = min([len(game_state.get_shortest_path_player(p)) for p in other_players])\\n paths_diff = their_path - my_path\\n \\n return weights[0]*walls_diff + weights[1]*paths_diff\",\n \"def _evaluate_num_pieces(self, player):\\n evaluation = 0\\n if player is Player.black:\\n evaluation += self.num_black_pieces * 10\\n evaluation -= self.num_white_pieces * 10\\n evaluation += self.num_black_kings * 10\\n evaluation -= self.num_white_kings * 10\\n elif player is Player.white:\\n evaluation -= self.num_black_pieces * 10\\n evaluation += self.num_white_pieces * 10\\n evaluation -= self.num_black_kings * 10\\n evaluation += self.num_white_kings * 10\\n\\n return evaluation\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69899476","0.66916925","0.66868806","0.661133","0.64811707","0.63243896","0.62888366","0.62563837","0.623092","0.6226826","0.6220208","0.62145406","0.6178597","0.6162016","0.6135676","0.6127374","0.6116254","0.60962725","0.60838556","0.6064083","0.6043542","0.6043173","0.6042079","0.6042079","0.6042079","0.6026387","0.6002399","0.5992365","0.5990092","0.59802413","0.5967639","0.59604764","0.59492433","0.59385693","0.5927311","0.59258217","0.5918204","0.5917469","0.59118843","0.59021616","0.5895061","0.586048","0.5857438","0.5847476","0.5843569","0.5818513","0.581446","0.58100194","0.5809828","0.5805471","0.5791007","0.57758796","0.57748663","0.57715964","0.57664126","0.5762934","0.5756343","0.57510525","0.5750859","0.5748141","0.57460785","0.573172","0.57231414","0.5720724","0.5710389","0.5708359","0.5706943","0.5700107","0.56961644","0.5692747","0.5692365","0.56806344","0.5679775","0.5676199","0.5667093","0.56641805","0.5642257","0.56381065","0.56303304","0.5626978","0.5623134","0.56222534","0.5609644","0.5605706","0.5601818","0.5601246","0.5594787","0.55937177","0.55928826","0.5592473","0.55915415","0.55890733","0.55888695","0.55878115","0.5586946","0.5583674","0.558046","0.5577753","0.55760235","0.5575941"],"string":"[\n \"0.69899476\",\n \"0.66916925\",\n \"0.66868806\",\n \"0.661133\",\n \"0.64811707\",\n \"0.63243896\",\n \"0.62888366\",\n \"0.62563837\",\n \"0.623092\",\n \"0.6226826\",\n \"0.6220208\",\n \"0.62145406\",\n \"0.6178597\",\n \"0.6162016\",\n \"0.6135676\",\n \"0.6127374\",\n \"0.6116254\",\n \"0.60962725\",\n \"0.60838556\",\n \"0.6064083\",\n \"0.6043542\",\n \"0.6043173\",\n \"0.6042079\",\n \"0.6042079\",\n \"0.6042079\",\n \"0.6026387\",\n \"0.6002399\",\n \"0.5992365\",\n \"0.5990092\",\n \"0.59802413\",\n \"0.5967639\",\n \"0.59604764\",\n \"0.59492433\",\n \"0.59385693\",\n \"0.5927311\",\n \"0.59258217\",\n \"0.5918204\",\n \"0.5917469\",\n \"0.59118843\",\n \"0.59021616\",\n \"0.5895061\",\n \"0.586048\",\n \"0.5857438\",\n \"0.5847476\",\n \"0.5843569\",\n \"0.5818513\",\n \"0.581446\",\n \"0.58100194\",\n \"0.5809828\",\n \"0.5805471\",\n \"0.5791007\",\n \"0.57758796\",\n \"0.57748663\",\n \"0.57715964\",\n \"0.57664126\",\n \"0.5762934\",\n \"0.5756343\",\n \"0.57510525\",\n \"0.5750859\",\n \"0.5748141\",\n \"0.57460785\",\n \"0.573172\",\n \"0.57231414\",\n \"0.5720724\",\n \"0.5710389\",\n \"0.5708359\",\n \"0.5706943\",\n \"0.5700107\",\n \"0.56961644\",\n \"0.5692747\",\n \"0.5692365\",\n \"0.56806344\",\n \"0.5679775\",\n \"0.5676199\",\n \"0.5667093\",\n \"0.56641805\",\n \"0.5642257\",\n \"0.56381065\",\n \"0.56303304\",\n \"0.5626978\",\n \"0.5623134\",\n \"0.56222534\",\n \"0.5609644\",\n \"0.5605706\",\n \"0.5601818\",\n \"0.5601246\",\n \"0.5594787\",\n \"0.55937177\",\n \"0.55928826\",\n \"0.5592473\",\n \"0.55915415\",\n \"0.55890733\",\n \"0.55888695\",\n \"0.55878115\",\n \"0.5586946\",\n \"0.5583674\",\n \"0.558046\",\n \"0.5577753\",\n \"0.55760235\",\n \"0.5575941\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7008181"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":3098,"cells":{"query":{"kind":"string","value":"Method which calculate Assists Ratio of a player"},"document":{"kind":"string","value":"def set_assists_ratio(self):\n bx = self.get_standard_stats()\n tcInt = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n denominador = tcInt + (0.44 * float(bx[\"tl_int\"])) + float(bx[\"assists\"]) +float(bx[\"turnovers\"])\n numerador = float(bx[\"assists\"])\n result = 0.00\n if denominador > 0:\n result = (numerador / denominador) * 100\n self.assists_ratio = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def set_assists_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n team_tc_conv = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n player_tc_conv = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0:\n result = (bx[\"assists\"] / (((bx[\"minutes\"] / (team[\"minutes\"] / 5)) * team_tc_conv) - player_tc_conv))*100\n result = result if result <= 100 and result >= 0 else 0\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.assists_percentage = \"%.2f\" % round(result, 2)","def cal_hit_ratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n score = 0.0\n # golden items hit in the top_K items\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\n score = score_1 - score_2\n return score/full['user'].nunique()","def set_assists_per_turnover(self):\n bx = self.get_standard_stats()\n ratio = bx[\"assists\"]\n if bx[\"turnovers\"] > 0:\n ratio = bx[\"assists\"] / bx[\"turnovers\"]\n self.assists_per_turnover = \"%.2f\" % round(ratio, 2)","def quick_ratio(self):\n return (\n self.current_assets - self.inventory_net) / self.current_liabilities","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def current_ratio(self):\n return self.current_assets / self.current_liabilities","def calculateRatio(levelDims):\n highestReso = np.asarray(levelDims[0])\n lowestReso = np.asarray(levelDims[-1])\n Xratio, Yratio = highestReso/lowestReso\n return (Xratio, Yratio)","def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def winrate(matches):\n if not matches:\n print('no matches')\n return None\n\n win_loss = [match['result'] for match in matches]\n return sum(win_loss)/len(win_loss)","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\n ratio_x = 0\n ratio_y = 0\n ratio_z = 0\n # helm_B = [0,0,0]\n divideby = 0\n for shot in range(shot_range[0], shot_range[1]+1):\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\n ratio_x = ratio_x + x\n ratio_y = ratio_y + y\n ratio_z = ratio_z + z\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\n divideby = divideby + 1 #averaging over the number of shots\n ratio_Bx = ratio_x/divideby\n ratio_By = ratio_y/divideby\n ratio_Bz = ratio_z/divideby\n # helmB = [helm_B]/divideby\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\n # print(\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\n Bx_sqr =ratio_x**2\n By_sqr =ratio_y**2\n Bz_sqr =ratio_z**2\n B = Bx_sqr + By_sqr+ Bz_sqr\n norm_factor = np.sqrt(B)\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\n\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)","def horizontal_ratio(self):\n if self.pupils_located:\n pupil_left = self.eye_left.pupil.x / (self.eye_left.center[0] * 2 - 10)\n pupil_right = self.eye_right.pupil.x / (self.eye_right.center[0] * 2 - 10)\n return (pupil_left + pupil_right) / 2","def set_offensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0 and (bx[\"t2p_int\"] + bx[\"t3p_int\"]) > 0:\n fgm = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n fga = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n team_fgm = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n team_fga = team[\"t2p_int\"] + team[\"t3p_int\"]\n team_points = team[\"t2p_conv\"]*2 + team[\"t3p_conv\"]*3 + team[\"tl_conv\"]\n points = bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"]\n\n try:\n qAST = (Decimal(bx[\"minutes\"] / (team[\"minutes\"] / 5)) * (Decimal('1.14') * Decimal((team[\"assists\"] - bx[\"assists\"]) / team_fgm))) + \\\n Decimal((((team[\"assists\"] / team[\"minutes\"]) * bx[\"minutes\"] * 5 - bx[\"assists\"]) / ((team_fgm / team[\"minutes\"]) * bx[\"minutes\"] * 5 - fgm)) * (1 - (bx[\"minutes\"] / (team[\"minutes\"] / 5))))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n qAST = 1\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n qAST = 1\n\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2*(team_fga - fga))) * bx[\"assists\"]\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n ast_part = 0\n\n if bx[\"tl_int\"] > 0:\n ft_part = Decimal(1 - (1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_part = 0\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\"tl_conv\"] / team[\"tl_int\"]))**2) * team[\"tl_int\"] * Decimal('0.4'))\n try:\n team_orb_percentage = Decimal(team[\"reb_of\"] / (team[\"reb_of\"] + ((opp_team[\"reb_def\"] + opp_team[\"reb_of\"]) - opp_team[\"reb_of\"])))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\"tl_int\"] * Decimal('0.4') + team[\"turnovers\"]))\n try:\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_weight = 0\n\n orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage\n\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\n if bx[\"tl_conv\"] > 0:\n ft_x_poss = Decimal((1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_x_poss = Decimal(1 - (bx[\"tl_conv\"] / 1)**2) * Decimal('0.4') * bx[\"tl_int\"]\n try:\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n sc_poss =0\n\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\"turnovers\"]\n\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\"t3p_conv\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\"t3p_conv\"] - bx[\"t3p_conv\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2 * (team_fga - fga))) * bx[\"assists\"]\n except:\n pprod_ast_part = 0\n\n pprod_orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\"tl_conv\"] / team[\"tl_int\"])**2) * Decimal('0.4') * team[\"tl_int\"]))\n try:\n pprod = (pprod_fg_part + pprod_ast_part + bx[\"tl_conv\"]) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n pprod = 0\n\n try:\n result = 100 * (pprod / tot_poss)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n result = 0\n\n # print(\"fgm: \" + str(fgm))\n # print(\"fga: \" + str(fga))\n # print(\"team_fgm: \" + str(team_fgm))\n # print(\"team_fga: \" + str(team_fga))\n # print(\"team_points: \" + str(team_points))\n # print(\"points: \" + str(points))\n # print(\"qAST: \" + str(qAST))\n # print(\"fg_part: \" + str(fg_part))\n # print(\"ast_part: \" + str(ast_part))\n # print(\"ft_part: \" + str(ft_part))\n # print(\"team_scoring_poss: \" + str(team_scoring_poss))\n # print(\"team_orb_percentage: \" + str(team_orb_percentage))\n # print(\"team_play_percentage: \" + str(team_play_percentage))\n # print(\"team_orb_weight: \" + str(team_orb_weight))\n # print(\"orb_part: \" + str(orb_part))\n # print(\"fg_x_poss: \" + str(fg_x_poss))\n # print(\"ft_x_poss: \" + str(ft_x_poss))\n # print(\"sc_poss: \" + str(sc_poss))\n # print(\"tot_poss: \" + str(tot_poss))\n # print(\"pprod_fg_part: \" + str(pprod_fg_part))\n # print(\"pprod_ast_part: \" + str(pprod_ast_part))\n # print(\"pprod_orb_part: \" + str(pprod_orb_part))\n # print(\"pprod: \" + str(pprod))\n # print(\"result: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n\n self.ortg = \"%.2f\" % round(result, 2)\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\n \"\"\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \n using team's formula\"\"\"\n print(BCOLORS.OKBLUE + \"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\" + BCOLORS.ENDC)\n bx = self.get_standard_stats()\n result = round((bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])/self.get_team_possessions(), 2)\n self.ortg = \"%.2f\" % result","def golden_ratio():\n print((1+math.sqrt(5))/2)","def exceeded_ratio(self) -> float:\n return self.amount_spent / self.total_amount","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def GetResult(self, playerjm):\n return self.score / len(self.scores)","def win_ratio_avg(self):\n win_ratio = 0\n # Adds all the win ratios of team in this conference which will be\n # used to compute the win ratio average.\n for team_obj in self._conf_teams:\n ### INVARIANT: team_obj is a Team class object and\n ### self._conf_teams is a list of Team class objects.\n win_ratio += team_obj._win_ratio\n return win_ratio/len(self._conf_teams)","def administer(self):\n\n score = 0.0\n for question in self.questions:\n if question.ask_and_evaluate() is True:\n score += 1\n return (score / len(self.questions)) * 100","def get_real_rating(self):\n if not (self.votes and self.score):\n return 0\n return float(self.score)/self.votes","def _ratio(a1, a2):\n abs_residues = np.abs(a1 - a2).sum()\n avg_abs_sum = 0.5 * np.abs(a1).sum() + 0.5 * np.abs(a2).sum()\n return abs_residues / avg_abs_sum","def calculate_score_pairs(hand_value,*args):\n # ratios=[1,10,100,1000,10000]\n ratios = CONST.RATIOS[:]\n return sum(map(lambda a,b:a/b, args, ratios))+hand_value","def custom_score_3(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n #Between 1-8\n return own_moves / opp_moves","def custom_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player) / 8\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n\n # Calculate centerness_score\n completeness = completeness_of_game(game)\n centerness_score = 0\n if completeness < 0.5:\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n own_centerness = centerness(game, player) / centerness_max\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def expected_value(held_dice, num_die_sides, num_free_dice):\n result = 0\n outcomes = range(1, num_die_sides + 1)\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\n for hand in possible:\n result += score(held_dice + hand)\n return float(result)/len(possible)","def p(party, vote_count, s):\n return t(party, vote_count) / d(s)","def calculate_scores(self):\n words = self.walk_board()\n player_scores = {}\n for word in words:\n player = word.get_owning_player()\n if player not in player_scores:\n player_scores[player] = 0\n player_scores[player] += word.get_score()\n return player_scores","def mc_update_scores(scores, board, player):\n dim = board.get_dim()\n winner = board.check_win()\n other_player = provided.switch_player(player)\n \n if winner == provided.DRAW:\n ratio = {player: 0, other_player: 0, 1: 0}\n elif winner == player:\n ratio = {player: 0 + SCORE_CURRENT, other_player: 0 - SCORE_OTHER, provided.EMPTY: 0}\n elif winner == other_player:\n ratio = {player: 0 - SCORE_CURRENT, other_player: 0 + SCORE_OTHER, provided.EMPTY: 0}\t\n \n for valx in range(dim):\n for valy in range(dim): \n scores[valx][valy] += ratio[board.square(valx, valy)] \n return scores","def calculate_overall_rating(player_dict):\r\n if player_dict[\"position\"].upper() == \"QB\":\r\n throw_power = int(max(min(int(player_dict[\"throw_power\"]), 99), 70))\r\n throw_accuracy = int(max(min(math.ceil(\r\n ((2 * (\r\n int(player_dict[\"throw_accuracy_short\"]) + \r\n int(player_dict[\"throw_accuracy_mid\"]) + \r\n int(player_dict[\"throw_accuracy_deep\"]) + \r\n int(player_dict[\"throw_on_the_run\"]) + \r\n int(player_dict[\"playaction\"])\r\n )) - (2 * min(\r\n int(player_dict[\"throw_accuracy_short\"]), \r\n int(player_dict[\"throw_accuracy_mid\"]), \r\n int(player_dict[\"throw_accuracy_deep\"]), \r\n int(player_dict[\"throw_on_the_run\"]), \r\n int(player_dict[\"playaction\"])\r\n ))\r\n ) / 8\r\n ), 99), 60))\r\n break_tackles = int(max(min(\r\n math.ceil(((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 7), \r\n 90), 20))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 98), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 55))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((throw_power - 50.0) / 10.0) * 4.9\r\n overall_rating += ((throw_accuracy - 50.0) / 10.0) * 5.8\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.0\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"HB\":\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 70), 25))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 99), 50))\r\n carrying = int(max(min(int(player_dict[\"carrying\"]), 99), 60))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 45))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 50))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 0.33\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((carrying - 50.0) / 10.0) * 2.0\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.8\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.0\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.6\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 1.4\r\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"FB\":\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 75), 40))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 85), 45))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 99), 55))\r\n carrying = int(max(min(int(player_dict[\"carrying\"]), 99), 60))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 55))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 95), 60))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 60))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.0\r\n overall_rating += ((run_block - 50.0) / 10.0) * 7.2\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.8\r\n overall_rating += ((carrying - 50.0) / 10.0) * 1.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.0\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 1.8\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\r\n overall_rating += ((catching - 50.0) / 10.0) * 5.2\r\n overall_rating = int(max(min((round(overall_rating) + 39), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"WR\":\r\n break_tackles = int(max(min(\r\n math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2), \r\n 80), 35))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 75))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 75))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 35))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 99), 65))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.3\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.3\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.3\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.8\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 4.75\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.4\r\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"TE\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 55))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 55))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 55))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 60))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 99), 45))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 95), 20))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 80), 35))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 85), 35))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.65\r\n overall_rating += ((strength - 50.0) / 10.0) * 2.65\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.65\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.25\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.25\r\n overall_rating += ((catching - 50.0) / 10.0) * 5.4\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.2\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.2\r\n overall_rating += ((run_block - 50.0) / 10.0) * 5.4\r\n overall_rating = int(max(min((round(overall_rating) + 35), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LT\" or player_dict[\"position\"].upper() == \"RT\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 85), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 85), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 90), 60))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 99), 60))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 0.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.3\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.3\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 0.8\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 4.75\r\n overall_rating += ((run_block - 50.0) / 10.0) * 3.75\r\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\r\n return overall_rating\r\n \r\n if (player_dict[\"position\"].upper() == \"LG\" or player_dict[\"position\"].upper() == \"RG\" or \r\n player_dict[\"position\"].upper() == \"C\"):\r\n speed = int(max(min(int(player_dict[\"speed\"]), 85), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 85), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 90), 60))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 99), 65))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.7\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.25\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.25\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 3.25\r\n overall_rating += ((run_block - 50.0) / 10.0) * 4.8\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LE\" or player_dict[\"position\"].upper() == \"RE\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 90), 55))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 90), 45))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.75\r\n overall_rating += ((awareness - 50.0) / 10.0) * 1.75\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.75\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 3.8\r\n overall_rating += ((tackle - 50.0) / 10.0) * 5.5\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"DT\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 90), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 90), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 5.5\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 1\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.8\r\n overall_rating += ((tackle - 50.0) / 10.0) * 4.55\r\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LOLB\" or player_dict[\"position\"].upper() == \"ROLB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 70))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 65))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 75))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 90), 20))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 2.4\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.6\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.4\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 1.3\r\n overall_rating += ((tackle - 50.0) / 10.0) * 4.8\r\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"MLB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 65))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 65))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 75))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 0.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.4\r\n overall_rating += ((awareness - 50.0) / 10.0) * 5.2\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.65\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.75\r\n overall_rating += ((tackle - 50.0) / 10.0) * 5.2\r\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"CB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 40))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 75))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 40))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 85), 30))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.85\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.85\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.55\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.35\r\n overall_rating += ((catching - 50.0) / 10.0) * 3\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.55\r\n overall_rating += ((tackle - 50.0) / 10.0) * 1.55\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"FS\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 75))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 35))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 90), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.0\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.85\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.5\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.5\r\n overall_rating += ((catching - 50.0) / 10.0) * 3.0\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.5\r\n overall_rating += ((tackle - 50.0) / 10.0) * 2.5\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"SS\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 75))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 35))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 90), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.2\r\n overall_rating += ((strength - 50.0) / 10.0) * 1.7\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.75\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.7\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\r\n overall_rating += ((catching - 50.0) / 10.0) * 3.2\r\n overall_rating += ((jumping - 50.0) / 10.0) * 0.9\r\n overall_rating += ((tackle - 50.0) / 10.0) * 3.2\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"K\":\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 85), 35))\r\n kick_power = int(max(min(int(player_dict[\"kick_power\"]), 99), 80))\r\n kick_accuracy = int(max(min(int(player_dict[\"kick_accuracy\"]), 99), 70))\r\n \r\n overall_rating = (-177 + (0.218 * awareness) + (1.28 * kick_power) + (1.47 * kick_accuracy))\r\n overall_rating = int(max(min(round(overall_rating), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"P\":\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 85), 40))\r\n kick_power = int(max(min(int(player_dict[\"kick_power\"]), 99), 80))\r\n kick_accuracy = int(max(min(int(player_dict[\"kick_accuracy\"]), 99), 70))\r\n \r\n overall_rating = (-183 + (0.218 * awareness) + (1.5 * kick_power) + (1.33 * kick_accuracy))\r\n overall_rating = int(max(min(round(overall_rating), 99), 40))\r\n return overall_rating","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def ret_vol_ratio(self) -> float:\n return self.geo_ret / self.vol","def ratio_func(a, b):\n return a / b","def custom_score_6(game, player):\n \"\"\"custom_score_6 heuristic function aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)","def calc_album_match(song: Song, result: Result) -> float:\n\n if not result.album:\n return 0.0\n\n return ratio(slugify(song.album_name), slugify(result.album))","def cash_ratio(self):\n return self.cash / self.current_liabilities","def state_score_naive(self, game_state, player, weights):\n # walls score\n other_players = [p for p in game_state.players if p != player]\n my_walls = player.num_walls\n their_walls = max([p.num_walls for p in other_players])\n walls_diff = (my_walls - their_walls)\n # path length score\n my_path = len(game_state.get_shortest_path_player(player))\n their_path = min([len(game_state.get_shortest_path_player(p)) for p in other_players])\n paths_diff = their_path - my_path\n \n return weights[0]*walls_diff + weights[1]*paths_diff","def get_win_percentage(self) -> float:\n if self.wins == 0:\n return 0.0\n else:\n return round((self.wins / (self.wins + self.losses)) * 100, 2)","def average_win_rate(strategy, baseline=always_roll(4)):\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\n\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2","def average_win_rate(strategy, baseline=always_roll(4)):\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\n\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2","def average_win_rate(strategy, baseline=always_roll(4)):\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\n\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2","def score(self,player, board):\r\n numPlayer = 0\r\n numOpp = 0\r\n for i in self.squares():\r\n if board[i] == player:\r\n numPlayer+= SQUARE_WEIGHTS[i]\r\n else:\r\n numOpp+=SQUARE_WEIGHTS[i]\r\n return numPlayer-numOpp","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player)\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player))\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = own_moves / opp_moves\n\n completeness = completeness_of_game(game)\n centerness_score = 0\n\n if completeness < 0.5:\n own_centerness = centerness(game, player)\n opp_centerness = centerness(game, game.get_opponent(player))\n centerness_ratio = own_centerness / opp_centerness + 0.1\n\n center_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def _ratio(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray:\n out = sim / ref\n out.attrs[\"units\"] = \"\"\n return out","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def get_rating(self):\n if not (self.votes and self.score):\n return 0\n return float(self.score)/(self.votes+self.field.weight)","def mutual_info_score(self):\n _, _, I_CK = self._entropies()\n return I_CK / self.grand_total","def odds_ratio(target_pct, peer_pct):\n odds_ratio = 0.0\n if peer_pct == 0.0:\n return None\n elif target_pct == 0.0:\n odds_ratio = 0.0\n elif target_pct == peer_pct:\n odds_ratio = 1.0\n elif peer_pct > 0.0 and target_pct < 1.0 and peer_pct < 1.0:\n odds_ratio = (target_pct/(1-target_pct))/(peer_pct/(1-peer_pct))\n return round(odds_ratio, 3)","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)","def custom_score_4(game, player):\n \"\"\"custom_score_4 heuristic function aims at minimizing loosing chances of myPlayer\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = 1.0 * len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n\n if length_my_player_moves == 0:\n return float(\"-inf\")\n\n if length_opp_payer_moves == 0:\n return float(\"inf\")\n\n return float(-length_opp_payer_moves/length_my_player_moves)","def calc_match_points(self, match):\n if match.winner == match.TIE:\n match.home.tournament_score += 1\n match.away.tournament_score += 1\n else:\n match.winner.tournament_score += 3\n match.loser.tournament_score += 0","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def calculateWinRate():\n times = 10\n winRate = 0.0\n for i in range(times):\n game = Game('user', 6, 6)\n winRate += game.play(5, False, True, False, False)\n winRate = winRate/times\n print \"Winrate:\", winRate","def expected_value(held_dice, num_die_sides, num_free_dice):\r\n die_outcomes = set(range(1, num_die_sides + 1))\r\n \r\n possible_sequences = gen_all_sequences(die_outcomes, num_free_dice)\r\n \r\n total_score = 0.0\r\n for sequence in possible_sequences:\r\n total_score += score(held_dice + sequence)\r\n \r\n return float(total_score / len(possible_sequences))","def golden_ratio():\n return 1.61803398875","def ratio(self):\n try:\n return self.fields['uploadedEver'] / float(self.fields['downloadedEver'])\n except ZeroDivisionError:\n return 0.0","def get_fool_ratio(self, test_acc, attack_accs):\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]","def calculate_score(player_cards):\n score = sum(player_cards)\n return score","def winRate(DF):\r\n df = DF[\"return\"]\r\n pos = df[df>1]\r\n neg = df[df<1]\r\n return (len(pos) / len(pos + neg)) * 100","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def totaled_ratio_calculator(numerator, denominator):\n if denominator != 0:\n ratio = round(float(numerator) / denominator, 3)\n else:\n ratio = 0\n return ratio","def get_sharpe_ratio(allocs, prices):\n\tport_val = get_portfolio_value(prices, allocs, start_val=1.0)\n\tsharpe_ratio = get_portfolio_stats(port_val, daily_rf=0.0, samples_per_year=252)[3]\n\treturn -sharpe_ratio","def expected_value(held_dice, num_die_sides, num_free_dice):\n list_scores = []\n die_sides = [die for die in range(1, num_die_sides + 1)]\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\n for item in possible_seq:\n list_scores.append(score(held_dice + item))\n \n return float(sum(list_scores)) / len(list_scores)","def custom_score_2(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # shortcut to definite state:\n # 1. my agent win -> return very high score\n if opp_moves == 0:\n return float(\"inf\")\n # 2. opponenent's agent win -> return very low score\n elif own_moves == 0:\n return float(\"-inf\")\n\n # score: avaliable moves ratio\n return float(own_moves/opp_moves)","def _blinking_ratio(self, landmarks, points):\n left = (landmarks.part(points[0]).x, landmarks.part(points[0]).y)\n right = (landmarks.part(points[3]).x, landmarks.part(points[3]).y)\n top = self._middle_point(landmarks.part(points[1]), landmarks.part(points[2]))\n bottom = self._middle_point(landmarks.part(points[5]), landmarks.part(points[4]))\n eye_width = math.hypot((left[0] - right[0]), (left[1] - right[1]))\n eye_height = math.hypot((top[0] - bottom[0]), (top[1] - bottom[1]))\n\n try:\n ratio = eye_width / eye_height\n except ZeroDivisionError:\n ratio = None\n\n return ratio","def calculate_scores(players):\n scores = {}\n for player in players.tuple_:\n scores[player.id_] = player.score()\n return scores","def eval(self):\n\n ratio_player_win = self.player_wins / self.num_test\n ratio_opponent_win = self.opponent_wins / self.num_test\n ratio_tie = 1.0 - ratio_player_win - ratio_opponent_win\n\n print(\"\\nPlayer Test Results:\")\n print(\"\\tWins {0:.2f}%\".format(100.0 * ratio_player_win))\n print(\"\\tLosses {0:.2f}%\".format(100.0 * ratio_opponent_win))\n print(\"\\tTie {0:.2f}%\".format(100.0 * ratio_tie))\n\n ratio_optimal_win = self.optimal_wins / self.num_test\n ratio_optimal_loose = self.optimal_losses / self.num_test\n ratio_optimal_tie = 1.0 - ratio_optimal_win - ratio_optimal_loose\n\n print(\"\\nOptimal Results:\")\n print(\"\\tPlayer {0:.2f}%\".format(100.0 * ratio_optimal_win))\n print(\"\\tOpponent {0:.2f}%\".format(100.0 * ratio_optimal_loose))\n print(\"\\tTie {0:.2f}%\".format(100.0 * ratio_optimal_tie))\n\n # Ratio of win, loss diff between player and optimal\n # positive if the player beats opponent\n relative_result = ((ratio_player_win - ratio_opponent_win) /\n (ratio_optimal_win - ratio_optimal_loose))\n\n print(\"\\nResults Player Relative Optimal:\")\n print(\"\\tWins {0:.2f}%\".format(100.0 * ratio_player_win / ratio_optimal_win))\n print(\"\\tLosses {0:.2f}%\".format(100.0 * ratio_opponent_win / ratio_optimal_loose))\n print(\"\\tScore {0:.2f}%\".format(100.0 * relative_result))\n\n if self.last_test is not None:\n print(\"Diff from last test score is {0:.2f}%\".format(100.0 * (relative_result - self.last_test)))\n self.last_test = relative_result","def vratio(self):\n return self.run_command('vratio')[0]","def get_verified_ratio(self):\n if len(self.pages) == 0: # There are no pages in this journal \n return 0, 0, 0\n verified = (1, 2, 4) \n numVerified = 0 \n numSeen = 0 \n for page in self.pages: \n numSeen += len(page.names) # page.names is a list of Name objects \n for name in page.names: \n if name.match in verified: \n numVerified += 1\n if numSeen == 0: # No names in any of the pages of the journal \n return 0, 0, 0\n return numVerified, numSeen, numVerified / numSeen","def information_ratio(returns, factor_returns):\n active_return = returns - factor_returns\n tracking_error = np.std(active_return, ddof=1)\n if np.isnan(tracking_error):\n return 0.0\n return np.mean(active_return) / tracking_error","def calculate_vote_fractions():\n return _calculate_vote_fractions(models.get_candidate_to_vote_count())","def custom_score_3(game, player):\n \"\"\"custom_score_3 heuristic function aims at maximizing win chances of my agent\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = 1.0 * len(game.get_legal_moves(player))#Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves with oppositePlayer\n\n if length_my_player_moves == 0:\n return float(\"-inf\")\n\n if length_opp_payer_moves == 0:\n return float(\"inf\")\n\n return float(length_my_player_moves/length_opp_payer_moves)","def heuristic_1_center(game, player) -> float:\n center_available_factor = get_center_available_factor(game, player)\n\n # Heuristic score output\n return float(center_available_factor)","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def infected_ratio(self):\n if self.max_pop != 0:\n return int(self.infected_pop) / self.max_pop\n else:\n return 1","def expected_value(held_dice, num_die_sides, num_free_dice):\n outcomes = get_outcomes(num_die_sides)\n print \"outcomes:\", outcomes\n\n # generate all possible sequences of rolls\n all_rolls = list(gen_all_sequences(outcomes, num_free_dice))\n results = [max_repeats(roll) for roll in all_rolls]\n value = 0.0 \n\n\n for result in all_rolls:\n curr_hand = tuple(list(held_dice) + list(result))\n value += score(curr_hand)\n\n return value / len(all_rolls)","def custom_score_5(game, player):\n \"\"\"custom_score_5 heuristic function defines chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def weighted_score(player, board):\n opp = Othello.opponent(player)\n total = 0\n for sq in Othello.squares():\n if board[sq] == player:\n total += SQUARE_WEIGHTS[sq]\n elif board[sq] == opp:\n total -= SQUARE_WEIGHTS[sq]\n return total","def custom_score(game, player):\n if game.is_loser(player):\n return -math.inf\n\n if game.is_winner(player):\n return math.inf\n\n opp_moves = game.get_legal_moves(game.get_opponent(player))\n own_moves = game.get_legal_moves(player)\n\n return len(own_moves) / max(len(opp_moves), 1e-6)","def score(self):\n # loop over aminoacids in protein and calculate how often H and C are surrounded by H and C\n for aminoacid in self.aminoacids:\n if aminoacid.aminoacid_type == \"H\":\n self.stability = self.stability + (-1 * self.surrounded_by(aminoacid.location, \"H\", aminoacid.aminoacid_number)) + (-1 * self.surrounded_by(aminoacid.location, \"C\", aminoacid.aminoacid_number))\n elif aminoacid.aminoacid_type == \"C\":\n self.stability = self.stability + (-5 * self.surrounded_by(aminoacid.location, \"C\", aminoacid.aminoacid_number)) + (-1 * self.surrounded_by(aminoacid.location, \"H\", aminoacid.aminoacid_number))\n self.stability = self.stability/2\n return int(self.stability)","def taper_ratio(self) -> float:\n return self.xsecs[-1].chord / self.xsecs[0].chord","def pe_ratio(self):\n try:\n return self.price / self.dividend_yield\n except ZeroDivisionError:\n return 0.0","def calculate_score(self):\n\n correct_award = 150\n turns_total = self.turns.count()\n turns_correct = self.turns.filter(is_match=True).count()\n seconds_left = (60.0 - (self.turns.last().created - self.turns.first().created).total_seconds()) or 0\n maxpoints = turns_correct * correct_award\n deduction_for_errors = correct_award * 0.11123\n\n maxpoints -= ((turns_total - turns_correct) * 2 * deduction_for_errors)\n maxpoints += seconds_left * 5.123214\n\n return Decimal(maxpoints)","def _estimate_strength_from_results(\n number_of_games: int, number_of_wins: int, opponent_rating: float\n) -> Tuple[float, Tuple[float, float]]:\n n, p = number_of_games, number_of_wins / number_of_games\n q = 1 - p\n\n if n * p * q < 9: # Cannot apply normal approximation of binomial distribution\n raise ValueError(\n \"The results obtained in evaluate_player are too extreme to obtain an \"\n \"accurate player evaluation. You can try to solve this issue by increasing\"\n \" the total number of battles. Obtained results: %d victories out of %d\"\n \" games.\" % (p * n, n)\n )\n\n estimate = opponent_rating * p / q\n error = (\n math.sqrt(n * p * q) / n * 1.96\n ) # 95% confidence interval for normal distribution\n\n lower_bound = max(0, p - error)\n lower_bound = opponent_rating * lower_bound / (1 - lower_bound)\n\n higher_bound = min(1, p + error)\n\n if higher_bound == 1:\n higher_bound = math.inf\n else:\n higher_bound = opponent_rating * higher_bound / (1 - higher_bound)\n\n return estimate, (lower_bound, higher_bound)","def expected_value(held_dice, num_die_sides, num_free_dice):\r\n \r\n scores = []\r\n \r\n die_sides = [(die + 1) for die in range(num_die_sides)]\r\n \r\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\r\n\r\n for outcome in pos_outcomes:\r\n scores.append(score(held_dice + outcome))\r\n \r\n expected_result = float(sum(scores))/len(scores)\r\n \r\n return expected_result","def calculate(self):\n\n rating = 0\n\n props = ['aroma', 'appearance', 'taste', 'palate', 'bottle_style']\n for item in props:\n rating += getattr(self, item, 0)\n\n self.overall = (rating / self.total) / .2","def custom_score_7(game, player):\n \"\"\"custom_score_7 heuristic function also aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def _calculate_score(predictions: np.ndarray, correct: np.ndarray) -> float:\n return np.sqrt(np.sum(np.square(np.log(predictions + 1) - np.log(correct + 1))) / len(correct))","def get_score(self, player: int) -> int:\n score = 0\n i = 0\n while i < len(self.leylines):\n score += 1 if self.leylines[i].player == player else 0\n score += 1 if self.rights[i].player == player else 0\n score += 1 if self.lefts[i].player == player else 0\n i += 1\n return score","def vertical_ratio(self):\n if self.pupils_located:\n pupil_left = self.eye_left.pupil.y / (self.eye_left.center[1] * 2 - 10)\n pupil_right = self.eye_right.pupil.y / (self.eye_right.center[1] * 2 - 10)\n return (pupil_left + pupil_right) / 2","def calc_artists_match(song: Song, result: Result) -> float:\n\n artist_match_number = 0.0\n\n # Result has only one artist, return 0.0\n if len(song.artists) == 1 or not result.artists:\n return artist_match_number\n\n artist1_list, artist2_list = based_sort(\n list(map(slugify, song.artists)), list(map(slugify, result.artists))\n )\n\n artists_match = 0.0\n for artist1, artist2 in zip_longest(artist1_list, artist2_list):\n artist12_match = ratio(artist1, artist2)\n artists_match += artist12_match\n\n artist_match_number = artists_match / len(artist1_list)\n\n debug(song.song_id, result.result_id, f\"Artists match: {artist_match_number}\")\n\n return artist_match_number","def information_ratio(returns, factor_returns):\n if len(returns) < 2:\n return np.nan\n\n active_return = _adjust_returns(returns, factor_returns)\n tracking_error = np.std(active_return, ddof=1)\n if np.isnan(tracking_error):\n return 0.0\n if tracking_error == 0:\n return np.nan\n return np.mean(active_return) / tracking_error","def quality(self, rating_groups, weights=None):\n rating_groups, keys = self.validate_rating_groups(rating_groups)\n weights = self.validate_weights(weights, rating_groups, keys)\n flatten_ratings = sum(map(tuple, rating_groups), ())\n flatten_weights = sum(map(tuple, weights), ())\n length = len(flatten_ratings)\n # a vector of all of the skill means\n mean_matrix = Matrix([[r.mu] for r in flatten_ratings])\n # a matrix whose diagonal values are the variances (sigma ** 2) of each\n # of the players.\n def variance_matrix(height, width):\n variances = (r.sigma ** 2 for r in flatten_ratings)\n for x, variance in enumerate(variances):\n yield (x, x), variance\n variance_matrix = Matrix(variance_matrix, length, length)\n # the player-team assignment and comparison matrix\n def rotated_a_matrix(set_height, set_width):\n t = 0\n for r, (cur, next) in enumerate(zip(rating_groups[:-1],\n rating_groups[1:])):\n for x in range(t, t + len(cur)):\n yield (r, x), flatten_weights[x]\n t += 1\n x += 1\n for x in range(x, x + len(next)):\n yield (r, x), -flatten_weights[x]\n set_height(r + 1)\n set_width(x + 1)\n rotated_a_matrix = Matrix(rotated_a_matrix)\n a_matrix = rotated_a_matrix.transpose()\n # match quality further derivation\n _ata = (self.beta ** 2) * rotated_a_matrix * a_matrix\n _atsa = rotated_a_matrix * variance_matrix * a_matrix\n start = mean_matrix.transpose() * a_matrix\n middle = _ata + _atsa\n end = rotated_a_matrix * mean_matrix\n # make result\n e_arg = (-0.5 * start * middle.inverse() * end).determinant()\n s_arg = _ata.determinant() / middle.determinant()\n return math.exp(e_arg) * math.sqrt(s_arg)","def get_average_distance_to_opponents(obs, player_x, player_y):\n distances_sum = 0\n distances_amount = 0\n for i in range(1, len(obs[\"right_team\"])):\n # if opponent is ahead of player\n if obs[\"right_team\"][i][0] > (player_x - 0.02):\n distance_to_opponent = get_distance(player_x, player_y, obs[\"right_team\"][i][0], obs[\"right_team\"][i][1])\n if distance_to_opponent < 0.03:\n distances_sum += distance_to_opponent\n distances_amount += 1\n # if there is no opponents close around\n if distances_amount == 0:\n return 2, distances_amount\n return distances_sum / distances_amount, distances_amount","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def entropy(self) -> float:\n probabilities = np.array([len(players) for players in self.answers.values()])\n probabilities = probabilities / sum(probabilities)\n return sc.stats.entropy(probabilities)","def calculate_perimeter_ratio(gt_perimeter, perf_perimeter):\n return min(gt_perimeter, perf_perimeter) / max(gt_perimeter, perf_perimeter)","def get_ratio_guarantee_advance(self):\n return (\n self.ratio_guarantee_advance *\n self.get_period_guarantee_advance *\n self.ratio2_guarantee_advance\n )","def sharpe_ratio(factor_returns, annualization_factor):\r\n\r\n return annualization_factor * factor_returns.mean() / factor_returns.std()","def calculate_a(self):\n self.a = float(len(self.neighbors)) / total_connections"],"string":"[\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def set_assists_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n team_tc_conv = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n player_tc_conv = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0:\\n result = (bx[\\\"assists\\\"] / (((bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * team_tc_conv) - player_tc_conv))*100\\n result = result if result <= 100 and result >= 0 else 0\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.assists_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def cal_hit_ratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\\n score = score_1 - score_2\\n return score/full['user'].nunique()\",\n \"def set_assists_per_turnover(self):\\n bx = self.get_standard_stats()\\n ratio = bx[\\\"assists\\\"]\\n if bx[\\\"turnovers\\\"] > 0:\\n ratio = bx[\\\"assists\\\"] / bx[\\\"turnovers\\\"]\\n self.assists_per_turnover = \\\"%.2f\\\" % round(ratio, 2)\",\n \"def quick_ratio(self):\\n return (\\n self.current_assets - self.inventory_net) / self.current_liabilities\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def current_ratio(self):\\n return self.current_assets / self.current_liabilities\",\n \"def calculateRatio(levelDims):\\n highestReso = np.asarray(levelDims[0])\\n lowestReso = np.asarray(levelDims[-1])\\n Xratio, Yratio = highestReso/lowestReso\\n return (Xratio, Yratio)\",\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def winrate(matches):\\n if not matches:\\n print('no matches')\\n return None\\n\\n win_loss = [match['result'] for match in matches]\\n return sum(win_loss)/len(win_loss)\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\\n ratio_x = 0\\n ratio_y = 0\\n ratio_z = 0\\n # helm_B = [0,0,0]\\n divideby = 0\\n for shot in range(shot_range[0], shot_range[1]+1):\\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\\n ratio_x = ratio_x + x\\n ratio_y = ratio_y + y\\n ratio_z = ratio_z + z\\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\\n divideby = divideby + 1 #averaging over the number of shots\\n ratio_Bx = ratio_x/divideby\\n ratio_By = ratio_y/divideby\\n ratio_Bz = ratio_z/divideby\\n # helmB = [helm_B]/divideby\\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\\n # print(\\\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\\\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\\n Bx_sqr =ratio_x**2\\n By_sqr =ratio_y**2\\n Bz_sqr =ratio_z**2\\n B = Bx_sqr + By_sqr+ Bz_sqr\\n norm_factor = np.sqrt(B)\\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\\n\\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)\",\n \"def horizontal_ratio(self):\\n if self.pupils_located:\\n pupil_left = self.eye_left.pupil.x / (self.eye_left.center[0] * 2 - 10)\\n pupil_right = self.eye_right.pupil.x / (self.eye_right.center[0] * 2 - 10)\\n return (pupil_left + pupil_right) / 2\",\n \"def set_offensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0 and (bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]) > 0:\\n fgm = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n fga = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n team_fgm = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n team_fga = team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]\\n team_points = team[\\\"t2p_conv\\\"]*2 + team[\\\"t3p_conv\\\"]*3 + team[\\\"tl_conv\\\"]\\n points = bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"]\\n\\n try:\\n qAST = (Decimal(bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * (Decimal('1.14') * Decimal((team[\\\"assists\\\"] - bx[\\\"assists\\\"]) / team_fgm))) + \\\\\\n Decimal((((team[\\\"assists\\\"] / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - bx[\\\"assists\\\"]) / ((team_fgm / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - fgm)) * (1 - (bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5))))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n qAST = 1\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n qAST = 1\\n\\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2*(team_fga - fga))) * bx[\\\"assists\\\"]\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n ast_part = 0\\n\\n if bx[\\\"tl_int\\\"] > 0:\\n ft_part = Decimal(1 - (1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_part = 0\\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"]))**2) * team[\\\"tl_int\\\"] * Decimal('0.4'))\\n try:\\n team_orb_percentage = Decimal(team[\\\"reb_of\\\"] / (team[\\\"reb_of\\\"] + ((opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]) - opp_team[\\\"reb_of\\\"])))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n\\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\\\"tl_int\\\"] * Decimal('0.4') + team[\\\"turnovers\\\"]))\\n try:\\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_weight = 0\\n\\n orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage\\n\\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\\n if bx[\\\"tl_conv\\\"] > 0:\\n ft_x_poss = Decimal((1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_x_poss = Decimal(1 - (bx[\\\"tl_conv\\\"] / 1)**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n try:\\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n sc_poss =0\\n\\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\\\"turnovers\\\"]\\n\\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\\\"t3p_conv\\\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\\\"t3p_conv\\\"] - bx[\\\"t3p_conv\\\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2 * (team_fga - fga))) * bx[\\\"assists\\\"]\\n except:\\n pprod_ast_part = 0\\n\\n pprod_orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"])**2) * Decimal('0.4') * team[\\\"tl_int\\\"]))\\n try:\\n pprod = (pprod_fg_part + pprod_ast_part + bx[\\\"tl_conv\\\"]) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n pprod = 0\\n\\n try:\\n result = 100 * (pprod / tot_poss)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n result = 0\\n\\n # print(\\\"fgm: \\\" + str(fgm))\\n # print(\\\"fga: \\\" + str(fga))\\n # print(\\\"team_fgm: \\\" + str(team_fgm))\\n # print(\\\"team_fga: \\\" + str(team_fga))\\n # print(\\\"team_points: \\\" + str(team_points))\\n # print(\\\"points: \\\" + str(points))\\n # print(\\\"qAST: \\\" + str(qAST))\\n # print(\\\"fg_part: \\\" + str(fg_part))\\n # print(\\\"ast_part: \\\" + str(ast_part))\\n # print(\\\"ft_part: \\\" + str(ft_part))\\n # print(\\\"team_scoring_poss: \\\" + str(team_scoring_poss))\\n # print(\\\"team_orb_percentage: \\\" + str(team_orb_percentage))\\n # print(\\\"team_play_percentage: \\\" + str(team_play_percentage))\\n # print(\\\"team_orb_weight: \\\" + str(team_orb_weight))\\n # print(\\\"orb_part: \\\" + str(orb_part))\\n # print(\\\"fg_x_poss: \\\" + str(fg_x_poss))\\n # print(\\\"ft_x_poss: \\\" + str(ft_x_poss))\\n # print(\\\"sc_poss: \\\" + str(sc_poss))\\n # print(\\\"tot_poss: \\\" + str(tot_poss))\\n # print(\\\"pprod_fg_part: \\\" + str(pprod_fg_part))\\n # print(\\\"pprod_ast_part: \\\" + str(pprod_ast_part))\\n # print(\\\"pprod_orb_part: \\\" + str(pprod_orb_part))\\n # print(\\\"pprod: \\\" + str(pprod))\\n # print(\\\"result: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n\\n self.ortg = \\\"%.2f\\\" % round(result, 2)\\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\\n \\\"\\\"\\\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \\n using team's formula\\\"\\\"\\\"\\n print(BCOLORS.OKBLUE + \\\"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\\\" + BCOLORS.ENDC)\\n bx = self.get_standard_stats()\\n result = round((bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])/self.get_team_possessions(), 2)\\n self.ortg = \\\"%.2f\\\" % result\",\n \"def golden_ratio():\\n print((1+math.sqrt(5))/2)\",\n \"def exceeded_ratio(self) -> float:\\n return self.amount_spent / self.total_amount\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def GetResult(self, playerjm):\\n return self.score / len(self.scores)\",\n \"def win_ratio_avg(self):\\n win_ratio = 0\\n # Adds all the win ratios of team in this conference which will be\\n # used to compute the win ratio average.\\n for team_obj in self._conf_teams:\\n ### INVARIANT: team_obj is a Team class object and\\n ### self._conf_teams is a list of Team class objects.\\n win_ratio += team_obj._win_ratio\\n return win_ratio/len(self._conf_teams)\",\n \"def administer(self):\\n\\n score = 0.0\\n for question in self.questions:\\n if question.ask_and_evaluate() is True:\\n score += 1\\n return (score / len(self.questions)) * 100\",\n \"def get_real_rating(self):\\n if not (self.votes and self.score):\\n return 0\\n return float(self.score)/self.votes\",\n \"def _ratio(a1, a2):\\n abs_residues = np.abs(a1 - a2).sum()\\n avg_abs_sum = 0.5 * np.abs(a1).sum() + 0.5 * np.abs(a2).sum()\\n return abs_residues / avg_abs_sum\",\n \"def calculate_score_pairs(hand_value,*args):\\n # ratios=[1,10,100,1000,10000]\\n ratios = CONST.RATIOS[:]\\n return sum(map(lambda a,b:a/b, args, ratios))+hand_value\",\n \"def custom_score_3(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n #Between 1-8\\n return own_moves / opp_moves\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player) / 8\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n\\n # Calculate centerness_score\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n if completeness < 0.5:\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n own_centerness = centerness(game, player) / centerness_max\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n result = 0\\n outcomes = range(1, num_die_sides + 1)\\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\\n for hand in possible:\\n result += score(held_dice + hand)\\n return float(result)/len(possible)\",\n \"def p(party, vote_count, s):\\n return t(party, vote_count) / d(s)\",\n \"def calculate_scores(self):\\n words = self.walk_board()\\n player_scores = {}\\n for word in words:\\n player = word.get_owning_player()\\n if player not in player_scores:\\n player_scores[player] = 0\\n player_scores[player] += word.get_score()\\n return player_scores\",\n \"def mc_update_scores(scores, board, player):\\n dim = board.get_dim()\\n winner = board.check_win()\\n other_player = provided.switch_player(player)\\n \\n if winner == provided.DRAW:\\n ratio = {player: 0, other_player: 0, 1: 0}\\n elif winner == player:\\n ratio = {player: 0 + SCORE_CURRENT, other_player: 0 - SCORE_OTHER, provided.EMPTY: 0}\\n elif winner == other_player:\\n ratio = {player: 0 - SCORE_CURRENT, other_player: 0 + SCORE_OTHER, provided.EMPTY: 0}\\t\\n \\n for valx in range(dim):\\n for valy in range(dim): \\n scores[valx][valy] += ratio[board.square(valx, valy)] \\n return scores\",\n \"def calculate_overall_rating(player_dict):\\r\\n if player_dict[\\\"position\\\"].upper() == \\\"QB\\\":\\r\\n throw_power = int(max(min(int(player_dict[\\\"throw_power\\\"]), 99), 70))\\r\\n throw_accuracy = int(max(min(math.ceil(\\r\\n ((2 * (\\r\\n int(player_dict[\\\"throw_accuracy_short\\\"]) + \\r\\n int(player_dict[\\\"throw_accuracy_mid\\\"]) + \\r\\n int(player_dict[\\\"throw_accuracy_deep\\\"]) + \\r\\n int(player_dict[\\\"throw_on_the_run\\\"]) + \\r\\n int(player_dict[\\\"playaction\\\"])\\r\\n )) - (2 * min(\\r\\n int(player_dict[\\\"throw_accuracy_short\\\"]), \\r\\n int(player_dict[\\\"throw_accuracy_mid\\\"]), \\r\\n int(player_dict[\\\"throw_accuracy_deep\\\"]), \\r\\n int(player_dict[\\\"throw_on_the_run\\\"]), \\r\\n int(player_dict[\\\"playaction\\\"])\\r\\n ))\\r\\n ) / 8\\r\\n ), 99), 60))\\r\\n break_tackles = int(max(min(\\r\\n math.ceil(((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 7), \\r\\n 90), 20))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 98), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 55))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((throw_power - 50.0) / 10.0) * 4.9\\r\\n overall_rating += ((throw_accuracy - 50.0) / 10.0) * 5.8\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.0\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"HB\\\":\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 70), 25))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 99), 50))\\r\\n carrying = int(max(min(int(player_dict[\\\"carrying\\\"]), 99), 60))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 45))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 50))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 0.33\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((carrying - 50.0) / 10.0) * 2.0\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.0\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.6\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 1.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"FB\\\":\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 75), 40))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 85), 45))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 99), 55))\\r\\n carrying = int(max(min(int(player_dict[\\\"carrying\\\"]), 99), 60))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 55))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 95), 60))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 60))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.0\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 7.2\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((carrying - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.0\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 5.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 39), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"WR\\\":\\r\\n break_tackles = int(max(min(\\r\\n math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2), \\r\\n 80), 35))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 75))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 75))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 35))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 99), 65))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"TE\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 55))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 55))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 55))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 60))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 99), 45))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 95), 20))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 80), 35))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 85), 35))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.25\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.25\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 5.4\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.2\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.2\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 5.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 35), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LT\\\" or player_dict[\\\"position\\\"].upper() == \\\"RT\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 85), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 85), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 90), 60))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 60))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 3.75\\r\\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if (player_dict[\\\"position\\\"].upper() == \\\"LG\\\" or player_dict[\\\"position\\\"].upper() == \\\"RG\\\" or \\r\\n player_dict[\\\"position\\\"].upper() == \\\"C\\\"):\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 85), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 85), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 90), 60))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 65))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 4.8\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LE\\\" or player_dict[\\\"position\\\"].upper() == \\\"RE\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 90), 55))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 90), 45))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 3.8\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 5.5\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"DT\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 90), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 90), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 5.5\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 4.55\\r\\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LOLB\\\" or player_dict[\\\"position\\\"].upper() == \\\"ROLB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 70))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 65))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 75))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 90), 20))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 2.4\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.6\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.4\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 1.3\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 4.8\\r\\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"MLB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 65))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 65))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 75))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 0.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.4\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 5.2\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.65\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 5.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"CB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 40))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 75))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 40))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 85), 30))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.85\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.85\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.55\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.35\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.55\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 1.55\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"FS\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 75))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 35))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 90), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.0\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.85\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.5\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.5\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3.0\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.5\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 2.5\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"SS\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 75))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 35))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 90), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.2\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3.2\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 3.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"K\\\":\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 85), 35))\\r\\n kick_power = int(max(min(int(player_dict[\\\"kick_power\\\"]), 99), 80))\\r\\n kick_accuracy = int(max(min(int(player_dict[\\\"kick_accuracy\\\"]), 99), 70))\\r\\n \\r\\n overall_rating = (-177 + (0.218 * awareness) + (1.28 * kick_power) + (1.47 * kick_accuracy))\\r\\n overall_rating = int(max(min(round(overall_rating), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"P\\\":\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 85), 40))\\r\\n kick_power = int(max(min(int(player_dict[\\\"kick_power\\\"]), 99), 80))\\r\\n kick_accuracy = int(max(min(int(player_dict[\\\"kick_accuracy\\\"]), 99), 70))\\r\\n \\r\\n overall_rating = (-183 + (0.218 * awareness) + (1.5 * kick_power) + (1.33 * kick_accuracy))\\r\\n overall_rating = int(max(min(round(overall_rating), 99), 40))\\r\\n return overall_rating\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def ret_vol_ratio(self) -> float:\\n return self.geo_ret / self.vol\",\n \"def ratio_func(a, b):\\n return a / b\",\n \"def custom_score_6(game, player):\\n \\\"\\\"\\\"custom_score_6 heuristic function aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)\",\n \"def calc_album_match(song: Song, result: Result) -> float:\\n\\n if not result.album:\\n return 0.0\\n\\n return ratio(slugify(song.album_name), slugify(result.album))\",\n \"def cash_ratio(self):\\n return self.cash / self.current_liabilities\",\n \"def state_score_naive(self, game_state, player, weights):\\n # walls score\\n other_players = [p for p in game_state.players if p != player]\\n my_walls = player.num_walls\\n their_walls = max([p.num_walls for p in other_players])\\n walls_diff = (my_walls - their_walls)\\n # path length score\\n my_path = len(game_state.get_shortest_path_player(player))\\n their_path = min([len(game_state.get_shortest_path_player(p)) for p in other_players])\\n paths_diff = their_path - my_path\\n \\n return weights[0]*walls_diff + weights[1]*paths_diff\",\n \"def get_win_percentage(self) -> float:\\n if self.wins == 0:\\n return 0.0\\n else:\\n return round((self.wins / (self.wins + self.losses)) * 100, 2)\",\n \"def average_win_rate(strategy, baseline=always_roll(4)):\\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\\n\\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2\",\n \"def average_win_rate(strategy, baseline=always_roll(4)):\\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\\n\\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2\",\n \"def average_win_rate(strategy, baseline=always_roll(4)):\\n win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)\\n win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)\\n\\n return (win_rate_as_player_0 + win_rate_as_player_1) / 2\",\n \"def score(self,player, board):\\r\\n numPlayer = 0\\r\\n numOpp = 0\\r\\n for i in self.squares():\\r\\n if board[i] == player:\\r\\n numPlayer+= SQUARE_WEIGHTS[i]\\r\\n else:\\r\\n numOpp+=SQUARE_WEIGHTS[i]\\r\\n return numPlayer-numOpp\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player)\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player))\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = own_moves / opp_moves\\n\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n\\n if completeness < 0.5:\\n own_centerness = centerness(game, player)\\n opp_centerness = centerness(game, game.get_opponent(player))\\n centerness_ratio = own_centerness / opp_centerness + 0.1\\n\\n center_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def _ratio(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray:\\n out = sim / ref\\n out.attrs[\\\"units\\\"] = \\\"\\\"\\n return out\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def get_rating(self):\\n if not (self.votes and self.score):\\n return 0\\n return float(self.score)/(self.votes+self.field.weight)\",\n \"def mutual_info_score(self):\\n _, _, I_CK = self._entropies()\\n return I_CK / self.grand_total\",\n \"def odds_ratio(target_pct, peer_pct):\\n odds_ratio = 0.0\\n if peer_pct == 0.0:\\n return None\\n elif target_pct == 0.0:\\n odds_ratio = 0.0\\n elif target_pct == peer_pct:\\n odds_ratio = 1.0\\n elif peer_pct > 0.0 and target_pct < 1.0 and peer_pct < 1.0:\\n odds_ratio = (target_pct/(1-target_pct))/(peer_pct/(1-peer_pct))\\n return round(odds_ratio, 3)\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\",\n \"def custom_score_4(game, player):\\n \\\"\\\"\\\"custom_score_4 heuristic function aims at minimizing loosing chances of myPlayer\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = 1.0 * len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n\\n if length_my_player_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n if length_opp_payer_moves == 0:\\n return float(\\\"inf\\\")\\n\\n return float(-length_opp_payer_moves/length_my_player_moves)\",\n \"def calc_match_points(self, match):\\n if match.winner == match.TIE:\\n match.home.tournament_score += 1\\n match.away.tournament_score += 1\\n else:\\n match.winner.tournament_score += 3\\n match.loser.tournament_score += 0\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def calculateWinRate():\\n times = 10\\n winRate = 0.0\\n for i in range(times):\\n game = Game('user', 6, 6)\\n winRate += game.play(5, False, True, False, False)\\n winRate = winRate/times\\n print \\\"Winrate:\\\", winRate\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\r\\n die_outcomes = set(range(1, num_die_sides + 1))\\r\\n \\r\\n possible_sequences = gen_all_sequences(die_outcomes, num_free_dice)\\r\\n \\r\\n total_score = 0.0\\r\\n for sequence in possible_sequences:\\r\\n total_score += score(held_dice + sequence)\\r\\n \\r\\n return float(total_score / len(possible_sequences))\",\n \"def golden_ratio():\\n return 1.61803398875\",\n \"def ratio(self):\\n try:\\n return self.fields['uploadedEver'] / float(self.fields['downloadedEver'])\\n except ZeroDivisionError:\\n return 0.0\",\n \"def get_fool_ratio(self, test_acc, attack_accs):\\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]\",\n \"def calculate_score(player_cards):\\n score = sum(player_cards)\\n return score\",\n \"def winRate(DF):\\r\\n df = DF[\\\"return\\\"]\\r\\n pos = df[df>1]\\r\\n neg = df[df<1]\\r\\n return (len(pos) / len(pos + neg)) * 100\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def totaled_ratio_calculator(numerator, denominator):\\n if denominator != 0:\\n ratio = round(float(numerator) / denominator, 3)\\n else:\\n ratio = 0\\n return ratio\",\n \"def get_sharpe_ratio(allocs, prices):\\n\\tport_val = get_portfolio_value(prices, allocs, start_val=1.0)\\n\\tsharpe_ratio = get_portfolio_stats(port_val, daily_rf=0.0, samples_per_year=252)[3]\\n\\treturn -sharpe_ratio\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n list_scores = []\\n die_sides = [die for die in range(1, num_die_sides + 1)]\\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\\n for item in possible_seq:\\n list_scores.append(score(held_dice + item))\\n \\n return float(sum(list_scores)) / len(list_scores)\",\n \"def custom_score_2(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # shortcut to definite state:\\n # 1. my agent win -> return very high score\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n # 2. opponenent's agent win -> return very low score\\n elif own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n # score: avaliable moves ratio\\n return float(own_moves/opp_moves)\",\n \"def _blinking_ratio(self, landmarks, points):\\n left = (landmarks.part(points[0]).x, landmarks.part(points[0]).y)\\n right = (landmarks.part(points[3]).x, landmarks.part(points[3]).y)\\n top = self._middle_point(landmarks.part(points[1]), landmarks.part(points[2]))\\n bottom = self._middle_point(landmarks.part(points[5]), landmarks.part(points[4]))\\n eye_width = math.hypot((left[0] - right[0]), (left[1] - right[1]))\\n eye_height = math.hypot((top[0] - bottom[0]), (top[1] - bottom[1]))\\n\\n try:\\n ratio = eye_width / eye_height\\n except ZeroDivisionError:\\n ratio = None\\n\\n return ratio\",\n \"def calculate_scores(players):\\n scores = {}\\n for player in players.tuple_:\\n scores[player.id_] = player.score()\\n return scores\",\n \"def eval(self):\\n\\n ratio_player_win = self.player_wins / self.num_test\\n ratio_opponent_win = self.opponent_wins / self.num_test\\n ratio_tie = 1.0 - ratio_player_win - ratio_opponent_win\\n\\n print(\\\"\\\\nPlayer Test Results:\\\")\\n print(\\\"\\\\tWins {0:.2f}%\\\".format(100.0 * ratio_player_win))\\n print(\\\"\\\\tLosses {0:.2f}%\\\".format(100.0 * ratio_opponent_win))\\n print(\\\"\\\\tTie {0:.2f}%\\\".format(100.0 * ratio_tie))\\n\\n ratio_optimal_win = self.optimal_wins / self.num_test\\n ratio_optimal_loose = self.optimal_losses / self.num_test\\n ratio_optimal_tie = 1.0 - ratio_optimal_win - ratio_optimal_loose\\n\\n print(\\\"\\\\nOptimal Results:\\\")\\n print(\\\"\\\\tPlayer {0:.2f}%\\\".format(100.0 * ratio_optimal_win))\\n print(\\\"\\\\tOpponent {0:.2f}%\\\".format(100.0 * ratio_optimal_loose))\\n print(\\\"\\\\tTie {0:.2f}%\\\".format(100.0 * ratio_optimal_tie))\\n\\n # Ratio of win, loss diff between player and optimal\\n # positive if the player beats opponent\\n relative_result = ((ratio_player_win - ratio_opponent_win) /\\n (ratio_optimal_win - ratio_optimal_loose))\\n\\n print(\\\"\\\\nResults Player Relative Optimal:\\\")\\n print(\\\"\\\\tWins {0:.2f}%\\\".format(100.0 * ratio_player_win / ratio_optimal_win))\\n print(\\\"\\\\tLosses {0:.2f}%\\\".format(100.0 * ratio_opponent_win / ratio_optimal_loose))\\n print(\\\"\\\\tScore {0:.2f}%\\\".format(100.0 * relative_result))\\n\\n if self.last_test is not None:\\n print(\\\"Diff from last test score is {0:.2f}%\\\".format(100.0 * (relative_result - self.last_test)))\\n self.last_test = relative_result\",\n \"def vratio(self):\\n return self.run_command('vratio')[0]\",\n \"def get_verified_ratio(self):\\n if len(self.pages) == 0: # There are no pages in this journal \\n return 0, 0, 0\\n verified = (1, 2, 4) \\n numVerified = 0 \\n numSeen = 0 \\n for page in self.pages: \\n numSeen += len(page.names) # page.names is a list of Name objects \\n for name in page.names: \\n if name.match in verified: \\n numVerified += 1\\n if numSeen == 0: # No names in any of the pages of the journal \\n return 0, 0, 0\\n return numVerified, numSeen, numVerified / numSeen\",\n \"def information_ratio(returns, factor_returns):\\n active_return = returns - factor_returns\\n tracking_error = np.std(active_return, ddof=1)\\n if np.isnan(tracking_error):\\n return 0.0\\n return np.mean(active_return) / tracking_error\",\n \"def calculate_vote_fractions():\\n return _calculate_vote_fractions(models.get_candidate_to_vote_count())\",\n \"def custom_score_3(game, player):\\n \\\"\\\"\\\"custom_score_3 heuristic function aims at maximizing win chances of my agent\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = 1.0 * len(game.get_legal_moves(player))#Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves with oppositePlayer\\n\\n if length_my_player_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n if length_opp_payer_moves == 0:\\n return float(\\\"inf\\\")\\n\\n return float(length_my_player_moves/length_opp_payer_moves)\",\n \"def heuristic_1_center(game, player) -> float:\\n center_available_factor = get_center_available_factor(game, player)\\n\\n # Heuristic score output\\n return float(center_available_factor)\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def infected_ratio(self):\\n if self.max_pop != 0:\\n return int(self.infected_pop) / self.max_pop\\n else:\\n return 1\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n outcomes = get_outcomes(num_die_sides)\\n print \\\"outcomes:\\\", outcomes\\n\\n # generate all possible sequences of rolls\\n all_rolls = list(gen_all_sequences(outcomes, num_free_dice))\\n results = [max_repeats(roll) for roll in all_rolls]\\n value = 0.0 \\n\\n\\n for result in all_rolls:\\n curr_hand = tuple(list(held_dice) + list(result))\\n value += score(curr_hand)\\n\\n return value / len(all_rolls)\",\n \"def custom_score_5(game, player):\\n \\\"\\\"\\\"custom_score_5 heuristic function defines chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def weighted_score(player, board):\\n opp = Othello.opponent(player)\\n total = 0\\n for sq in Othello.squares():\\n if board[sq] == player:\\n total += SQUARE_WEIGHTS[sq]\\n elif board[sq] == opp:\\n total -= SQUARE_WEIGHTS[sq]\\n return total\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return -math.inf\\n\\n if game.is_winner(player):\\n return math.inf\\n\\n opp_moves = game.get_legal_moves(game.get_opponent(player))\\n own_moves = game.get_legal_moves(player)\\n\\n return len(own_moves) / max(len(opp_moves), 1e-6)\",\n \"def score(self):\\n # loop over aminoacids in protein and calculate how often H and C are surrounded by H and C\\n for aminoacid in self.aminoacids:\\n if aminoacid.aminoacid_type == \\\"H\\\":\\n self.stability = self.stability + (-1 * self.surrounded_by(aminoacid.location, \\\"H\\\", aminoacid.aminoacid_number)) + (-1 * self.surrounded_by(aminoacid.location, \\\"C\\\", aminoacid.aminoacid_number))\\n elif aminoacid.aminoacid_type == \\\"C\\\":\\n self.stability = self.stability + (-5 * self.surrounded_by(aminoacid.location, \\\"C\\\", aminoacid.aminoacid_number)) + (-1 * self.surrounded_by(aminoacid.location, \\\"H\\\", aminoacid.aminoacid_number))\\n self.stability = self.stability/2\\n return int(self.stability)\",\n \"def taper_ratio(self) -> float:\\n return self.xsecs[-1].chord / self.xsecs[0].chord\",\n \"def pe_ratio(self):\\n try:\\n return self.price / self.dividend_yield\\n except ZeroDivisionError:\\n return 0.0\",\n \"def calculate_score(self):\\n\\n correct_award = 150\\n turns_total = self.turns.count()\\n turns_correct = self.turns.filter(is_match=True).count()\\n seconds_left = (60.0 - (self.turns.last().created - self.turns.first().created).total_seconds()) or 0\\n maxpoints = turns_correct * correct_award\\n deduction_for_errors = correct_award * 0.11123\\n\\n maxpoints -= ((turns_total - turns_correct) * 2 * deduction_for_errors)\\n maxpoints += seconds_left * 5.123214\\n\\n return Decimal(maxpoints)\",\n \"def _estimate_strength_from_results(\\n number_of_games: int, number_of_wins: int, opponent_rating: float\\n) -> Tuple[float, Tuple[float, float]]:\\n n, p = number_of_games, number_of_wins / number_of_games\\n q = 1 - p\\n\\n if n * p * q < 9: # Cannot apply normal approximation of binomial distribution\\n raise ValueError(\\n \\\"The results obtained in evaluate_player are too extreme to obtain an \\\"\\n \\\"accurate player evaluation. You can try to solve this issue by increasing\\\"\\n \\\" the total number of battles. Obtained results: %d victories out of %d\\\"\\n \\\" games.\\\" % (p * n, n)\\n )\\n\\n estimate = opponent_rating * p / q\\n error = (\\n math.sqrt(n * p * q) / n * 1.96\\n ) # 95% confidence interval for normal distribution\\n\\n lower_bound = max(0, p - error)\\n lower_bound = opponent_rating * lower_bound / (1 - lower_bound)\\n\\n higher_bound = min(1, p + error)\\n\\n if higher_bound == 1:\\n higher_bound = math.inf\\n else:\\n higher_bound = opponent_rating * higher_bound / (1 - higher_bound)\\n\\n return estimate, (lower_bound, higher_bound)\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\r\\n \\r\\n scores = []\\r\\n \\r\\n die_sides = [(die + 1) for die in range(num_die_sides)]\\r\\n \\r\\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\\r\\n\\r\\n for outcome in pos_outcomes:\\r\\n scores.append(score(held_dice + outcome))\\r\\n \\r\\n expected_result = float(sum(scores))/len(scores)\\r\\n \\r\\n return expected_result\",\n \"def calculate(self):\\n\\n rating = 0\\n\\n props = ['aroma', 'appearance', 'taste', 'palate', 'bottle_style']\\n for item in props:\\n rating += getattr(self, item, 0)\\n\\n self.overall = (rating / self.total) / .2\",\n \"def custom_score_7(game, player):\\n \\\"\\\"\\\"custom_score_7 heuristic function also aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def _calculate_score(predictions: np.ndarray, correct: np.ndarray) -> float:\\n return np.sqrt(np.sum(np.square(np.log(predictions + 1) - np.log(correct + 1))) / len(correct))\",\n \"def get_score(self, player: int) -> int:\\n score = 0\\n i = 0\\n while i < len(self.leylines):\\n score += 1 if self.leylines[i].player == player else 0\\n score += 1 if self.rights[i].player == player else 0\\n score += 1 if self.lefts[i].player == player else 0\\n i += 1\\n return score\",\n \"def vertical_ratio(self):\\n if self.pupils_located:\\n pupil_left = self.eye_left.pupil.y / (self.eye_left.center[1] * 2 - 10)\\n pupil_right = self.eye_right.pupil.y / (self.eye_right.center[1] * 2 - 10)\\n return (pupil_left + pupil_right) / 2\",\n \"def calc_artists_match(song: Song, result: Result) -> float:\\n\\n artist_match_number = 0.0\\n\\n # Result has only one artist, return 0.0\\n if len(song.artists) == 1 or not result.artists:\\n return artist_match_number\\n\\n artist1_list, artist2_list = based_sort(\\n list(map(slugify, song.artists)), list(map(slugify, result.artists))\\n )\\n\\n artists_match = 0.0\\n for artist1, artist2 in zip_longest(artist1_list, artist2_list):\\n artist12_match = ratio(artist1, artist2)\\n artists_match += artist12_match\\n\\n artist_match_number = artists_match / len(artist1_list)\\n\\n debug(song.song_id, result.result_id, f\\\"Artists match: {artist_match_number}\\\")\\n\\n return artist_match_number\",\n \"def information_ratio(returns, factor_returns):\\n if len(returns) < 2:\\n return np.nan\\n\\n active_return = _adjust_returns(returns, factor_returns)\\n tracking_error = np.std(active_return, ddof=1)\\n if np.isnan(tracking_error):\\n return 0.0\\n if tracking_error == 0:\\n return np.nan\\n return np.mean(active_return) / tracking_error\",\n \"def quality(self, rating_groups, weights=None):\\n rating_groups, keys = self.validate_rating_groups(rating_groups)\\n weights = self.validate_weights(weights, rating_groups, keys)\\n flatten_ratings = sum(map(tuple, rating_groups), ())\\n flatten_weights = sum(map(tuple, weights), ())\\n length = len(flatten_ratings)\\n # a vector of all of the skill means\\n mean_matrix = Matrix([[r.mu] for r in flatten_ratings])\\n # a matrix whose diagonal values are the variances (sigma ** 2) of each\\n # of the players.\\n def variance_matrix(height, width):\\n variances = (r.sigma ** 2 for r in flatten_ratings)\\n for x, variance in enumerate(variances):\\n yield (x, x), variance\\n variance_matrix = Matrix(variance_matrix, length, length)\\n # the player-team assignment and comparison matrix\\n def rotated_a_matrix(set_height, set_width):\\n t = 0\\n for r, (cur, next) in enumerate(zip(rating_groups[:-1],\\n rating_groups[1:])):\\n for x in range(t, t + len(cur)):\\n yield (r, x), flatten_weights[x]\\n t += 1\\n x += 1\\n for x in range(x, x + len(next)):\\n yield (r, x), -flatten_weights[x]\\n set_height(r + 1)\\n set_width(x + 1)\\n rotated_a_matrix = Matrix(rotated_a_matrix)\\n a_matrix = rotated_a_matrix.transpose()\\n # match quality further derivation\\n _ata = (self.beta ** 2) * rotated_a_matrix * a_matrix\\n _atsa = rotated_a_matrix * variance_matrix * a_matrix\\n start = mean_matrix.transpose() * a_matrix\\n middle = _ata + _atsa\\n end = rotated_a_matrix * mean_matrix\\n # make result\\n e_arg = (-0.5 * start * middle.inverse() * end).determinant()\\n s_arg = _ata.determinant() / middle.determinant()\\n return math.exp(e_arg) * math.sqrt(s_arg)\",\n \"def get_average_distance_to_opponents(obs, player_x, player_y):\\n distances_sum = 0\\n distances_amount = 0\\n for i in range(1, len(obs[\\\"right_team\\\"])):\\n # if opponent is ahead of player\\n if obs[\\\"right_team\\\"][i][0] > (player_x - 0.02):\\n distance_to_opponent = get_distance(player_x, player_y, obs[\\\"right_team\\\"][i][0], obs[\\\"right_team\\\"][i][1])\\n if distance_to_opponent < 0.03:\\n distances_sum += distance_to_opponent\\n distances_amount += 1\\n # if there is no opponents close around\\n if distances_amount == 0:\\n return 2, distances_amount\\n return distances_sum / distances_amount, distances_amount\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def entropy(self) -> float:\\n probabilities = np.array([len(players) for players in self.answers.values()])\\n probabilities = probabilities / sum(probabilities)\\n return sc.stats.entropy(probabilities)\",\n \"def calculate_perimeter_ratio(gt_perimeter, perf_perimeter):\\n return min(gt_perimeter, perf_perimeter) / max(gt_perimeter, perf_perimeter)\",\n \"def get_ratio_guarantee_advance(self):\\n return (\\n self.ratio_guarantee_advance *\\n self.get_period_guarantee_advance *\\n self.ratio2_guarantee_advance\\n )\",\n \"def sharpe_ratio(factor_returns, annualization_factor):\\r\\n\\r\\n return annualization_factor * factor_returns.mean() / factor_returns.std()\",\n \"def calculate_a(self):\\n self.a = float(len(self.neighbors)) / total_connections\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72646964","0.64316165","0.6352074","0.6281999","0.6247194","0.6209247","0.6207199","0.61734754","0.61600745","0.61037296","0.609562","0.607315","0.60665053","0.60465765","0.6046293","0.60187536","0.6009164","0.59791255","0.5958189","0.59420407","0.5881529","0.5880197","0.58754414","0.5865603","0.5865355","0.5836641","0.5815389","0.5805758","0.57964987","0.57841754","0.5774557","0.57651186","0.5753168","0.5747919","0.573551","0.5730925","0.5729146","0.5724391","0.5722815","0.5722815","0.5722815","0.57179284","0.5703159","0.5701336","0.56977355","0.5697034","0.5685612","0.5684638","0.56842166","0.5683044","0.56809956","0.5680193","0.5667492","0.5665352","0.5664911","0.566407","0.56606287","0.5660204","0.5651556","0.5648373","0.56422526","0.5638467","0.5638272","0.5636231","0.5629354","0.56291103","0.56194985","0.56179714","0.56166536","0.5614553","0.5603615","0.56022424","0.5595793","0.559293","0.5592488","0.5582595","0.5579975","0.5571609","0.5571215","0.55674523","0.5566796","0.5564611","0.5560355","0.5554855","0.5541081","0.55260545","0.55236727","0.55229205","0.5519234","0.550625","0.55048186","0.55013376","0.54978853","0.54838264","0.5479403","0.54767466","0.5476007","0.54758567","0.5473573","0.5471991"],"string":"[\n \"0.72646964\",\n \"0.64316165\",\n \"0.6352074\",\n \"0.6281999\",\n \"0.6247194\",\n \"0.6209247\",\n \"0.6207199\",\n \"0.61734754\",\n \"0.61600745\",\n \"0.61037296\",\n \"0.609562\",\n \"0.607315\",\n \"0.60665053\",\n \"0.60465765\",\n \"0.6046293\",\n \"0.60187536\",\n \"0.6009164\",\n \"0.59791255\",\n \"0.5958189\",\n \"0.59420407\",\n \"0.5881529\",\n \"0.5880197\",\n \"0.58754414\",\n \"0.5865603\",\n \"0.5865355\",\n \"0.5836641\",\n \"0.5815389\",\n \"0.5805758\",\n \"0.57964987\",\n \"0.57841754\",\n \"0.5774557\",\n \"0.57651186\",\n \"0.5753168\",\n \"0.5747919\",\n \"0.573551\",\n \"0.5730925\",\n \"0.5729146\",\n \"0.5724391\",\n \"0.5722815\",\n \"0.5722815\",\n \"0.5722815\",\n \"0.57179284\",\n \"0.5703159\",\n \"0.5701336\",\n \"0.56977355\",\n \"0.5697034\",\n \"0.5685612\",\n \"0.5684638\",\n \"0.56842166\",\n \"0.5683044\",\n \"0.56809956\",\n \"0.5680193\",\n \"0.5667492\",\n \"0.5665352\",\n \"0.5664911\",\n \"0.566407\",\n \"0.56606287\",\n \"0.5660204\",\n \"0.5651556\",\n \"0.5648373\",\n \"0.56422526\",\n \"0.5638467\",\n \"0.5638272\",\n \"0.5636231\",\n \"0.5629354\",\n \"0.56291103\",\n \"0.56194985\",\n \"0.56179714\",\n \"0.56166536\",\n \"0.5614553\",\n \"0.5603615\",\n \"0.56022424\",\n \"0.5595793\",\n \"0.559293\",\n \"0.5592488\",\n \"0.5582595\",\n \"0.5579975\",\n \"0.5571609\",\n \"0.5571215\",\n \"0.55674523\",\n \"0.5566796\",\n \"0.5564611\",\n \"0.5560355\",\n \"0.5554855\",\n \"0.5541081\",\n \"0.55260545\",\n \"0.55236727\",\n \"0.55229205\",\n \"0.5519234\",\n \"0.550625\",\n \"0.55048186\",\n \"0.55013376\",\n \"0.54978853\",\n \"0.54838264\",\n \"0.5479403\",\n \"0.54767466\",\n \"0.5476007\",\n \"0.54758567\",\n \"0.5473573\",\n \"0.5471991\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7257836"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":3099,"cells":{"query":{"kind":"string","value":"Method which calculate Defensive Ratio of a player. The total points received in 100 possessions"},"document":{"kind":"string","value":"def set_defensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0:\n opp_fga = opp_team[\"t2p_int\"] + opp_team[\"t3p_int\"]\n opp_fgm = opp_team[\"t2p_conv\"] + opp_team[\"t3p_conv\"]\n try:\n dor = Decimal(opp_team[\"reb_of\"] / (opp_team[\"reb_of\"] + team[\"reb_def\"]))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n dor = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n dor = 0\n\n try:\n dfg = Decimal(opp_fgm / opp_fga)\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n dfg = 0\n try:\n fmwt = Decimal((dfg * (1 - dor)) / (dfg * (1 - dor) + (1 - dfg) * dor))\n except:\n fmwt = 0\n stops1 = bx[\"steals\"] + bx[\"block_shots\"] * fmwt * (1 - Decimal('1.07') * dor) + bx[\"reb_def\"] * (1 - fmwt)\n\n try:\n stops2 = (Decimal((opp_fga - opp_fgm - team[\"block_shots\"]) / team[\"minutes\"]) * fmwt * (1 - Decimal('1.07') * dor) + Decimal((opp_team[\"turnovers\"] - team[\"steals\"]) / team[\"minutes\"])) * bx[\"minutes\"] + Decimal(bx[\"fouls_cm\"] / team[\"fouls_cm\"]) * Decimal('0.4') * opp_team[\"tl_int\"] * (1 - Decimal(opp_team[\"tl_conv\"] / opp_team[\"tl_int\"]))**2\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n stops2 = 0\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n stops2 = 0\n\n stops = stops1 + stops2\n poss = self.get_team_possessions()\n if bx[\"minutes\"] > 0:\n stop_percentage = (float(stops) * float(opp_team[\"minutes\"])) / (float(poss) * float(bx[\"minutes\"]))\n else:\n stop_percentage = 0.00\n opp_points = opp_team[\"t2p_conv\"] * 2 + opp_team[\"t3p_conv\"] * 3 + opp_team[\"tl_conv\"]\n team_defensive_rating = 100 * (float(opp_points) / poss)\n try:\n d_pts_per_scposs = float(opp_points) / (float(opp_fgm) + (1 - (1 - (float(opp_team[\"tl_conv\"]) / float(opp_team[\"tl_int\"])))**2) * float(opp_team[\"tl_int\"])*0.4)\n result = Decimal(team_defensive_rating) + Decimal('0.2') * (100 * Decimal(d_pts_per_scposs) * (1 - Decimal(stop_percentage)) - Decimal(team_defensive_rating))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n d_pts_per_scposs = 0\n result = 0.00\n\n\n\n # print(\"dor: \" + str(dor))\n # print(\"dfg: \" + str(dfg))\n # print(\"fmwt: \" + str(fmwt))\n # print(\"stops1: \" + str(stops1))\n # print(\"stops2: \" + str(stops2))\n # print(\"stops: \" + str(stops))\n # print(\"poss: \" + str(poss))\n # print(\"stop_percentage: \" + str(stop_percentage))\n # print(\"opp_points: \" + str(opp_points))\n # print(\"team_defensive_rating: \" + str(team_defensive_rating))\n # print(\"d_pts_per_scposs: \" + str(d_pts_per_scposs))\n # print(\"drtg: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n self.drtg = \"%.2f\" % round(result, 2)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\"WoW_Token\")) as res:\r\n if res.status == 200:\r\n data = await res.json()\r\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\r\n await ctx.message.channel.send(u\"Player: {:s}\").format(player)\r\n await ctx.message.channel.send(\"Rating: {:d}\".format(player_pvp_stats['rating']))\r\n await ctx.message.channel.send(\"Season Wins: {:d}\".format(player_pvp_stats['seasonWon']))\r\n await ctx.message.channel.send(\"Season Losses: {:d}\".format(player_pvp_stats['seasonLost']))\r\n\r\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\r\n await ctx.message.channel.send(\"Ratio: 0\")\r\n else:\r\n await ctx.message.channel.send(\"Ratio: {:.4f}\".format(\r\n float(player_pvp_stats['seasonWon'])/\r\n float(player_pvp_stats['seasonLost']))\r\n )","def set_offensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0 and (bx[\"t2p_int\"] + bx[\"t3p_int\"]) > 0:\n fgm = bx[\"t2p_conv\"] + bx[\"t3p_conv\"]\n fga = bx[\"t2p_int\"] + bx[\"t3p_int\"]\n team_fgm = team[\"t2p_conv\"] + team[\"t3p_conv\"]\n team_fga = team[\"t2p_int\"] + team[\"t3p_int\"]\n team_points = team[\"t2p_conv\"]*2 + team[\"t3p_conv\"]*3 + team[\"tl_conv\"]\n points = bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"]\n\n try:\n qAST = (Decimal(bx[\"minutes\"] / (team[\"minutes\"] / 5)) * (Decimal('1.14') * Decimal((team[\"assists\"] - bx[\"assists\"]) / team_fgm))) + \\\n Decimal((((team[\"assists\"] / team[\"minutes\"]) * bx[\"minutes\"] * 5 - bx[\"assists\"]) / ((team_fgm / team[\"minutes\"]) * bx[\"minutes\"] * 5 - fgm)) * (1 - (bx[\"minutes\"] / (team[\"minutes\"] / 5))))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n qAST = 1\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n qAST = 1\n\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2*(team_fga - fga))) * bx[\"assists\"]\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n ast_part = 0\n\n if bx[\"tl_int\"] > 0:\n ft_part = Decimal(1 - (1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_part = 0\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\"tl_conv\"] / team[\"tl_int\"]))**2) * team[\"tl_int\"] * Decimal('0.4'))\n try:\n team_orb_percentage = Decimal(team[\"reb_of\"] / (team[\"reb_of\"] + ((opp_team[\"reb_def\"] + opp_team[\"reb_of\"]) - opp_team[\"reb_of\"])))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_percentage = 0\n\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\"tl_int\"] * Decimal('0.4') + team[\"turnovers\"]))\n try:\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n team_orb_weight = 0\n\n orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage\n\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\n if bx[\"tl_conv\"] > 0:\n ft_x_poss = Decimal((1 - (bx[\"tl_conv\"] / bx[\"tl_int\"]))**2) * Decimal('0.4') * bx[\"tl_int\"]\n else:\n ft_x_poss = Decimal(1 - (bx[\"tl_conv\"] / 1)**2) * Decimal('0.4') * bx[\"tl_int\"]\n try:\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n sc_poss =0\n\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\"turnovers\"]\n\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\"t3p_conv\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\"tl_conv\"]) / (2 * fga)) * qAST)\n\n try:\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\"t3p_conv\"] - bx[\"t3p_conv\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\"tl_conv\"]) - (points - bx[\"tl_conv\"])) / (2 * (team_fga - fga))) * bx[\"assists\"]\n except:\n pprod_ast_part = 0\n\n pprod_orb_part = bx[\"reb_of\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\"tl_conv\"] / team[\"tl_int\"])**2) * Decimal('0.4') * team[\"tl_int\"]))\n try:\n pprod = (pprod_fg_part + pprod_ast_part + bx[\"tl_conv\"]) * (1 - (team[\"reb_of\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n pprod = 0\n\n try:\n result = 100 * (pprod / tot_poss)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n result = 0\n\n # print(\"fgm: \" + str(fgm))\n # print(\"fga: \" + str(fga))\n # print(\"team_fgm: \" + str(team_fgm))\n # print(\"team_fga: \" + str(team_fga))\n # print(\"team_points: \" + str(team_points))\n # print(\"points: \" + str(points))\n # print(\"qAST: \" + str(qAST))\n # print(\"fg_part: \" + str(fg_part))\n # print(\"ast_part: \" + str(ast_part))\n # print(\"ft_part: \" + str(ft_part))\n # print(\"team_scoring_poss: \" + str(team_scoring_poss))\n # print(\"team_orb_percentage: \" + str(team_orb_percentage))\n # print(\"team_play_percentage: \" + str(team_play_percentage))\n # print(\"team_orb_weight: \" + str(team_orb_weight))\n # print(\"orb_part: \" + str(orb_part))\n # print(\"fg_x_poss: \" + str(fg_x_poss))\n # print(\"ft_x_poss: \" + str(ft_x_poss))\n # print(\"sc_poss: \" + str(sc_poss))\n # print(\"tot_poss: \" + str(tot_poss))\n # print(\"pprod_fg_part: \" + str(pprod_fg_part))\n # print(\"pprod_ast_part: \" + str(pprod_ast_part))\n # print(\"pprod_orb_part: \" + str(pprod_orb_part))\n # print(\"pprod: \" + str(pprod))\n # print(\"result: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n\n self.ortg = \"%.2f\" % round(result, 2)\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\n \"\"\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \n using team's formula\"\"\"\n print(BCOLORS.OKBLUE + \"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\" + BCOLORS.ENDC)\n bx = self.get_standard_stats()\n result = round((bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])/self.get_team_possessions(), 2)\n self.ortg = \"%.2f\" % result","def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n progress_bar.end(\"\\n\\n\")\n\n return survivals_count / PARALLEL_UNIVERSES_COUNT","def exceeded_ratio(self) -> float:\n return self.amount_spent / self.total_amount","def winRate(DF):\r\n df = DF[\"return\"]\r\n pos = df[df>1]\r\n neg = df[df<1]\r\n return (len(pos) / len(pos + neg)) * 100","def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)","def winning_percentage(self):\n return float(len(self.wins))/len((self.wins+self.losses))","def KPI(self, total=True):\n \n data = self.select_table('ChordLog')\n correct = data[data['PredictedLabel'] == data['ActualLabel']]\n\n # % correctly predicted in chord net\n human_level_performance = (len(correct) / len(data)) * 100\n \n # round value\n human_level_performance = round(human_level_performance, 4) \n \n return human_level_performance","def calculate_score(self):\n\n correct_award = 150\n turns_total = self.turns.count()\n turns_correct = self.turns.filter(is_match=True).count()\n seconds_left = (60.0 - (self.turns.last().created - self.turns.first().created).total_seconds()) or 0\n maxpoints = turns_correct * correct_award\n deduction_for_errors = correct_award * 0.11123\n\n maxpoints -= ((turns_total - turns_correct) * 2 * deduction_for_errors)\n maxpoints += seconds_left * 5.123214\n\n return Decimal(maxpoints)","def pct(self):\n\t\treturn self.bottle.pct()","def offensive_rating(data_frame, mode):\n off_rat = dict()\n average_points = calculate_average_points(data_frame, mode)\n for k, possessions in possessions_home_away(data_frame, mode).items():\n try:\n off_rat[k] = format(float(average_points[k]) * 100 / float(possessions), '.2f')\n except ZeroDivisionError:\n off_rat[k] = 0.0\n return off_rat","def quick_ratio(self):\n return (\n self.current_assets - self.inventory_net) / self.current_liabilities","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def ratio_local_prod(self):\n if self.current_energy_produced == 0.0:\n return 1.0\n else:\n return 1. - self.export_grid / self.current_energy_produced","def points_percentage(plane, p, points, total):\n match = 0\n for point in points:\n if distance_to_plane(plane, point) <= p:\n match += 1\n\n return match / total","def get_free_set_percentage(self, params):\n raise NotImplementedError()","def expected_value(held_dice, num_die_sides, num_free_dice):\n result = 0\n outcomes = range(1, num_die_sides + 1)\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\n for hand in possible:\n result += score(held_dice + hand)\n return float(result)/len(possible)","def do_damage(self) -> float:\n sum = 0\n for operator in self.__operators:\n if operator.is_alive:\n operator.experience += 1\n sum += operator.experience / 100\n return 0.1 + sum","def percent_passing(self) -> float:\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\n num_pass = (\n Enumerable(self.mlc_meas)\n .select_many(lambda m: m.passed)\n .count(lambda p: bool(p) is True)\n )\n return float(100 * num_pass / num_meas)","def expected_value(held_dice, num_die_sides, num_free_dice):\r\n die_outcomes = set(range(1, num_die_sides + 1))\r\n \r\n possible_sequences = gen_all_sequences(die_outcomes, num_free_dice)\r\n \r\n total_score = 0.0\r\n for sequence in possible_sequences:\r\n total_score += score(held_dice + sequence)\r\n \r\n return float(total_score / len(possible_sequences))","def expected_value(held_dice, num_die_sides, num_free_dice):\n list_scores = []\n die_sides = [die for die in range(1, num_die_sides + 1)]\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\n for item in possible_seq:\n list_scores.append(score(held_dice + item))\n \n return float(sum(list_scores)) / len(list_scores)","def custom_score_4(game, player):\n \"\"\"custom_score_4 heuristic function aims at minimizing loosing chances of myPlayer\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = 1.0 * len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n\n if length_my_player_moves == 0:\n return float(\"-inf\")\n\n if length_opp_payer_moves == 0:\n return float(\"inf\")\n\n return float(-length_opp_payer_moves/length_my_player_moves)","def calculate_probability(self):\n return 0","def pe_ratio(self):\n try:\n return self.price / self.dividend_yield\n except ZeroDivisionError:\n return 0.0","def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw","def administer(self):\n\n score = 0.0\n for question in self.questions:\n if question.ask_and_evaluate() is True:\n score += 1\n return (score / len(self.questions)) * 100","def rate(self) -> float:\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0","def evaluate(game, player):\n weights = [2, 200, 2000, 20000]\n reward = 0\n opponent = get_opponent(player)\n for length in range(2, 6):\n reward += weights[length - 2] * get_num_series(game, player, length)\n reward -= weights[length - 2] * get_num_series(game, opponent, length)\n return reward","def cal_hit_ratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n score = 0.0\n # golden items hit in the top_K items\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\n score = score_1 - score_2\n return score/full['user'].nunique()","def get_improved_score_factor(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)","def points_per_dollar(self):\n if float(self.draftkings_salary) == 0.0:\n return 0.0\n\n return float(self.predicted_draftkings_points) / float(self.draftkings_salary)","def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)","def custom_score(game, player):\n if game.is_loser(player):\n return -math.inf\n\n if game.is_winner(player):\n return math.inf\n\n opp_moves = game.get_legal_moves(game.get_opponent(player))\n own_moves = game.get_legal_moves(player)\n\n return len(own_moves) / max(len(opp_moves), 1e-6)","async def get_rob_percentage(level):\n chance = int(6 + (level // 10)) # first 10 levels is 6 for 30% chance\n if chance > 16:\n chance = 16\n return chance","def expected_value(held_dice, num_die_sides, num_free_dice):\r\n \r\n scores = []\r\n \r\n die_sides = [(die + 1) for die in range(num_die_sides)]\r\n \r\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\r\n\r\n for outcome in pos_outcomes:\r\n scores.append(score(held_dice + outcome))\r\n \r\n expected_result = float(sum(scores))/len(scores)\r\n \r\n return expected_result","def determineAmountToCall(self, player):\n\t\treturn sum(self.currentBet) - sum(player.betAmount)","def calculate_profit(self):","def custom_score_6(game, player):\n \"\"\"custom_score_6 heuristic function aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)","def Probability(rating1, rating2):\n return 1.0 * 1.0 / (1 + 1.0 * math.pow(10, 1.0 * (rating1 - rating2) / 400))","def cash_ratio(self):\n return self.cash / self.current_liabilities","def punch(self, a_fighter):\n points = int(uniform(0.7,1.0)*10*self.get_strength()/a_fighter.get_agility())\n a_fighter.__health_points = a_fighter.get_health_points() - points\n return a_fighter.__health_points","def p(party, vote_count, s):\n return t(party, vote_count) / d(s)","def get_real_rating(self):\n if not (self.votes and self.score):\n return 0\n return float(self.score)/self.votes","def get_sharpe_ratio(allocs, prices):\n\tport_val = get_portfolio_value(prices, allocs, start_val=1.0)\n\tsharpe_ratio = get_portfolio_stats(port_val, daily_rf=0.0, samples_per_year=252)[3]\n\treturn -sharpe_ratio","def defense(self):\n #return self.stats.dexterity + (self.stats.reiatsu * self.stats.density)\n return self.stats.defense","def depiction_score(self):\n\n collision_penalty = 1\n degenerated_penalty = 0.4\n\n bond_collisions = self.count_bond_collisions()\n degenerated_atoms = self.count_suboptimal_atom_positions(0.0, 0.5)\n\n score = (\n collision_penalty * bond_collisions\n + degenerated_penalty * degenerated_atoms\n )\n\n return round(score, 1)","def custom_score(game, player):\n \n # get avaliable moves for each player\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n \n # return different between # of my agent's move and oppenent's\n return float(own_moves - opp_moves)","def heuristic_1_center(game, player) -> float:\n center_available_factor = get_center_available_factor(game, player)\n\n # Heuristic score output\n return float(center_available_factor)","def percent_processed(self):\n try:\n return (self.pos / self.data_encap.size) * 100.0\n except ZeroDivisionError:\n return 100.0","def penalty(self):\n return 0","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n if game.is_winner(player):\n return float(\"inf\")\n\n # Aim to maximise your own available moves vs the opponent (Factor 2)\n\n opponent = game.get_opponent(player)\n return float(len(game.get_legal_moves(player)))-2.0*float(len(game.get_legal_moves(opponent)))","def expected_value(held_dice, num_die_sides, num_free_dice):\n outcomes = get_outcomes(num_die_sides)\n print \"outcomes:\", outcomes\n\n # generate all possible sequences of rolls\n all_rolls = list(gen_all_sequences(outcomes, num_free_dice))\n results = [max_repeats(roll) for roll in all_rolls]\n value = 0.0 \n\n\n for result in all_rolls:\n curr_hand = tuple(list(held_dice) + list(result))\n value += score(curr_hand)\n\n return value / len(all_rolls)","def calc_win_lose_ratio(self):\n total = len(self.train_y)\n survived = 0\n for i in self.train_y:\n if i > 0:\n survived += 1\n\n self.survival_sum = [survived, total-survived]","def _prorata_rate(self, days_used, days_in_month):\n return (100 * days_used // days_in_month) / 100.0","def do_damage(self) -> float:\n res = 0.05 + self.experience / 100\n self.experience = self.experience + 1\n return res","def getProduction(self, playerID):\n prod=0\n for p in self.__camps:\n if( p.getOwner() == playerID ):\n prod = prod + p.getGrowthrate()\n return prod","def infected_ratio(self):\n if self.max_pop != 0:\n return int(self.infected_pop) / self.max_pop\n else:\n return 1","def getScore(self):\n tempscore = 1000 - 0.01*self.timeDriving \n tempscore -= 0.1*getDist(self.maze.checkpoints[self.checkpoint].getMid(),self.pos)\n tempscore += self.checkpoint *1000\n tempscore += self.laps * 1000 * len(self.maze.checkpoints)\n return tempscore","def calculate_overall_rating(player_dict):\r\n if player_dict[\"position\"].upper() == \"QB\":\r\n throw_power = int(max(min(int(player_dict[\"throw_power\"]), 99), 70))\r\n throw_accuracy = int(max(min(math.ceil(\r\n ((2 * (\r\n int(player_dict[\"throw_accuracy_short\"]) + \r\n int(player_dict[\"throw_accuracy_mid\"]) + \r\n int(player_dict[\"throw_accuracy_deep\"]) + \r\n int(player_dict[\"throw_on_the_run\"]) + \r\n int(player_dict[\"playaction\"])\r\n )) - (2 * min(\r\n int(player_dict[\"throw_accuracy_short\"]), \r\n int(player_dict[\"throw_accuracy_mid\"]), \r\n int(player_dict[\"throw_accuracy_deep\"]), \r\n int(player_dict[\"throw_on_the_run\"]), \r\n int(player_dict[\"playaction\"])\r\n ))\r\n ) / 8\r\n ), 99), 60))\r\n break_tackles = int(max(min(\r\n math.ceil(((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 7), \r\n 90), 20))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 98), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 55))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((throw_power - 50.0) / 10.0) * 4.9\r\n overall_rating += ((throw_accuracy - 50.0) / 10.0) * 5.8\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.0\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"HB\":\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 70), 25))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 99), 50))\r\n carrying = int(max(min(int(player_dict[\"carrying\"]), 99), 60))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 45))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 50))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 0.33\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((carrying - 50.0) / 10.0) * 2.0\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.8\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.0\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.6\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 1.4\r\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"FB\":\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 75), 40))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 85), 45))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 99), 55))\r\n carrying = int(max(min(int(player_dict[\"carrying\"]), 99), 60))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 55))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 95), 60))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 60))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.0\r\n overall_rating += ((run_block - 50.0) / 10.0) * 7.2\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.8\r\n overall_rating += ((carrying - 50.0) / 10.0) * 1.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.0\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 1.8\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\r\n overall_rating += ((catching - 50.0) / 10.0) * 5.2\r\n overall_rating = int(max(min((round(overall_rating) + 39), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"WR\":\r\n break_tackles = int(max(min(\r\n math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2), \r\n 80), 35))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 75))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 75))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 35))\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 99), 65))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.3\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.3\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.3\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.8\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 4.75\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.4\r\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"TE\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 55))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 55))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 55))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 60))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 99), 45))\r\n break_tackles = int(max(min(\r\n (math.ceil((int(player_dict[\"elusiveness\"]) + int(player_dict[\"trucking\"])) / 2) + 5), \r\n 95), 20))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 80), 35))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 85), 35))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 2.65\r\n overall_rating += ((strength - 50.0) / 10.0) * 2.65\r\n overall_rating += ((awareness - 50.0) / 10.0) * 2.65\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.25\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.25\r\n overall_rating += ((catching - 50.0) / 10.0) * 5.4\r\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.2\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.2\r\n overall_rating += ((run_block - 50.0) / 10.0) * 5.4\r\n overall_rating = int(max(min((round(overall_rating) + 35), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LT\" or player_dict[\"position\"].upper() == \"RT\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 85), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 85), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 90), 60))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 99), 60))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 0.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.3\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.3\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 0.8\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 4.75\r\n overall_rating += ((run_block - 50.0) / 10.0) * 3.75\r\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\r\n return overall_rating\r\n \r\n if (player_dict[\"position\"].upper() == \"LG\" or player_dict[\"position\"].upper() == \"RG\" or \r\n player_dict[\"position\"].upper() == \"C\"):\r\n speed = int(max(min(int(player_dict[\"speed\"]), 85), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 85), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 90), 60))\r\n pass_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"pass_block\"]) + \r\n int(player_dict[\"pass_block_power\"]) + \r\n int(player_dict[\"pass_block_finesse\"])\r\n ) / 3\r\n ), 99), 65))\r\n run_block = int(max(min(math.ceil(\r\n (\r\n int(player_dict[\"run_block\"]) + \r\n int(player_dict[\"run_block_power\"]) + \r\n int(player_dict[\"run_block_finesse\"])\r\n ) / 3\r\n ), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.7\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.25\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.25\r\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\r\n overall_rating += ((pass_block - 50.0) / 10.0) * 3.25\r\n overall_rating += ((run_block - 50.0) / 10.0) * 4.8\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LE\" or player_dict[\"position\"].upper() == \"RE\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 90), 55))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 90), 45))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.75\r\n overall_rating += ((awareness - 50.0) / 10.0) * 1.75\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.75\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 3.8\r\n overall_rating += ((tackle - 50.0) / 10.0) * 5.5\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"DT\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 90), 45))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 70))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 90), 40))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\r\n overall_rating += ((strength - 50.0) / 10.0) * 5.5\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.8\r\n overall_rating += ((agility - 50.0) / 10.0) * 1\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.8\r\n overall_rating += ((tackle - 50.0) / 10.0) * 4.55\r\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"LOLB\" or player_dict[\"position\"].upper() == \"ROLB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 70))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 65))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 75))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 90), 20))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 60))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 2.4\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.6\r\n overall_rating += ((agility - 50.0) / 10.0) * 2.4\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.3\r\n overall_rating += ((catching - 50.0) / 10.0) * 1.3\r\n overall_rating += ((tackle - 50.0) / 10.0) * 4.8\r\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"MLB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 95), 65))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 99), 60))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 95), 65))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 95), 75))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 99), 65))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 0.75\r\n overall_rating += ((strength - 50.0) / 10.0) * 3.4\r\n overall_rating += ((awareness - 50.0) / 10.0) * 5.2\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.65\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.75\r\n overall_rating += ((tackle - 50.0) / 10.0) * 5.2\r\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"CB\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 80))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 40))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 35))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 75))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 40))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 85), 30))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.85\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\r\n overall_rating += ((awareness - 50.0) / 10.0) * 3.85\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.55\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.35\r\n overall_rating += ((catching - 50.0) / 10.0) * 3\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.55\r\n overall_rating += ((tackle - 50.0) / 10.0) * 1.55\r\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"FS\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 75))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 85), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 35))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 90), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.0\r\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.85\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.5\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.5\r\n overall_rating += ((catching - 50.0) / 10.0) * 3.0\r\n overall_rating += ((jumping - 50.0) / 10.0) * 1.5\r\n overall_rating += ((tackle - 50.0) / 10.0) * 2.5\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"SS\":\r\n speed = int(max(min(int(player_dict[\"speed\"]), 99), 75))\r\n strength = int(max(min(int(player_dict[\"strength\"]), 90), 45))\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 99), 40))\r\n agility = int(max(min(int(player_dict[\"agility\"]), 99), 70))\r\n acceleration = int(max(min(int(player_dict[\"acceleration\"]), 99), 80))\r\n catching = int(max(min(int(player_dict[\"catching\"]), 95), 35))\r\n jumping = int(max(min(int(player_dict[\"jumping\"]), 99), 65))\r\n tackle = int(max(min(int(player_dict[\"tackle\"]), 90), 45))\r\n \r\n overall_rating = 0.0\r\n overall_rating += ((speed - 50.0) / 10.0) * 3.2\r\n overall_rating += ((strength - 50.0) / 10.0) * 1.7\r\n overall_rating += ((awareness - 50.0) / 10.0) * 4.75\r\n overall_rating += ((agility - 50.0) / 10.0) * 1.7\r\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\r\n overall_rating += ((catching - 50.0) / 10.0) * 3.2\r\n overall_rating += ((jumping - 50.0) / 10.0) * 0.9\r\n overall_rating += ((tackle - 50.0) / 10.0) * 3.2\r\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"K\":\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 85), 35))\r\n kick_power = int(max(min(int(player_dict[\"kick_power\"]), 99), 80))\r\n kick_accuracy = int(max(min(int(player_dict[\"kick_accuracy\"]), 99), 70))\r\n \r\n overall_rating = (-177 + (0.218 * awareness) + (1.28 * kick_power) + (1.47 * kick_accuracy))\r\n overall_rating = int(max(min(round(overall_rating), 99), 40))\r\n return overall_rating\r\n \r\n if player_dict[\"position\"].upper() == \"P\":\r\n awareness = int(max(min(int(player_dict[\"awareness\"]), 85), 40))\r\n kick_power = int(max(min(int(player_dict[\"kick_power\"]), 99), 80))\r\n kick_accuracy = int(max(min(int(player_dict[\"kick_accuracy\"]), 99), 70))\r\n \r\n overall_rating = (-183 + (0.218 * awareness) + (1.5 * kick_power) + (1.33 * kick_accuracy))\r\n overall_rating = int(max(min(round(overall_rating), 99), 40))\r\n return overall_rating","def getPercent(self):\n if isinstance(self.score,numbers.Number) and self.getMaximum():\n return (1.0*self.score/self.getMaximum())\n return None","def betterEvaluationFunction(currentGameState):\n \"*** YOUR CODE HERE ***\"\n pacmanPos = currentGameState.getPacmanPosition()\n\n food = currentGameState.getFood()\n capsules = currentGameState.getCapsules()\n return currentGameState.getScore() - 10 * capsuleDistancePlan(pacmanPos, capsules) - foodDistPlan(pacmanPos, food)","def get_fool_ratio(self, test_acc, attack_accs):\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]","def get_perf(self) :\n self.train()\n\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\n self.recall = tp/(tp+fn)\n self.specificity = tn / (tn+fp)\n\n\n self.df_true = self.df_true[self.length:]\n\n profit = 1\n mini = 1\n maxi = 1\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\n for s in range(1,len(self.df_true)):\n if prediction[x-1] == 1 :\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\n profit = profit * result\n if result < mini :\n mini = result\n if maxi < result :\n maxi = result\n self.mini = mini\n self.maxi = maxi\n self.profit = profit","def custom_score(game, player):\n \n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the improved score\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n improved = len(player_legal_moves) - len(opponent_legal_moves)\n if improved != 0:\n return float(improved)\n \n # Second get differences from center\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n player_coordinates = game.get_player_location(player)\n opponent_coordinates = game.get_player_location(opponent)\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\n center_dist_diff = player_center_dist - opponent_center_dist\n \n # Third obtain next_moves\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \n improved_next = len(player_next_moves) - len(opponent_next_moves)\n \n # Put player and opponent feature differences in a tuple/vector surrogoate\n feature_diff_vector = (improved, center_dist_diff, improved_next)\n \n # Provide a weighting vector for the features of each player-participant\n weight_vector = (1.5,0.1,1.0)\n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*q for p,q, \\\n in zip(feature_diff_vector, weight_vector))\n \n return float(weighted_difference_dot_product)","def get_win_percentage(self) -> float:\n if self.wins == 0:\n return 0.0\n else:\n return round((self.wins / (self.wins + self.losses)) * 100, 2)","def betterEvaluationFunction(currentGameState):\n score = 0\n\n if currentGameState.isWin():\n score += 10000000\n elif currentGameState.isLose():\n score -= 10000000\n\n pacmanPos = currentGameState.getPacmanPosition()\n foodList = gridToList(currentGameState.getFood())\n\n closestFoodDistance = distanceToClosestFood(pacmanPos, foodList) \n\n ghostPoses = currentGameState.getGhostPositions()\n closestGhostDistance = distanceToClosestGhost(pacmanPos, ghostPoses)\n\n score = (10/closestFoodDistance) - closestGhostDistance*10 + currentGameState.getScore()\n return score","def _cost_caught_by_police(self):\n if self.fine_frequency != 0:\n if self.number_of_courses % self.fine_frequency == 0 and self.number_of_courses != 0:\n if self.number_of_courses % self.fine_frequency_paid_by_driver == 0 and self.number_of_courses != 0:\n self.fine_paid_number_of_courses += 1\n fine_value = np.random.choice([100, 200, 500], p=[0.25, 0.4, 0.35])\n self.total_penalty_points += self._add_penalty_points() # adding penalty points\n return fine_value\n else:\n return 0\n else:\n return 0\n else:\n return 0","def calculateWinRate():\n times = 10\n winRate = 0.0\n for i in range(times):\n game = Game('user', 6, 6)\n winRate += game.play(5, False, True, False, False)\n winRate = winRate/times\n print \"Winrate:\", winRate","def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp_team[\"reb_def\"] + opp_team[\"reb_of\"]\n result = 0.00\n try:\n if bx[\"minutes\"] > 0 and bx[\"minutes\"] > 0:\n result = ((player_rebounds * (team[\"minutes\"]/5)) / (bx[\"minutes\"] * (team_rebounds + opp_team_rebounds)))*100\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n\n self.total_reb_percentage = \"%.2f\" % round(result, 2)","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def get_opinion_percent(self):\n return (self.get_percent()+100)/2","def heuristic_2_reflection(game, player) -> float:\n\n reflection_available_factor = get_reflection_available_factor(game, player)\n\n return float(reflection_available_factor)","def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\n if game and player:\n pass\n elif game:\n play_count = self.play_set.filter(game=game).count()\n win_count = self.play_set.filter(winner=self, game=game).count()\n return win_count / play_count * 100\n elif player:\n pass\n # play_count = self.play_set.filter(players__in=player).count()\n # win_count = self.play_set.filter(\n # winner=self, player=player).count()\n # return win_count / play_count * 100\n else:\n return self.winpercent","def calculate_gpa(self):\n cur_node = self.head\n gpa = 0\n total_credits = 0\n while cur_node is not None:\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\n total_credits += cur_node.data.credit_hr()\n cur_node = cur_node.next\n if total_credits == 0:\n return 0\n return gpa / total_credits","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n \n # First obtain the base information to calculate player & opponent\n # feature values\n player_legal_moves = game.get_legal_moves(player)\n opponent = game.get_opponent(player)\n opponent_legal_moves = game.get_legal_moves(opponent)\n if len(player_legal_moves) != len(opponent_legal_moves):\n return float(len(player_legal_moves) - len(opponent_legal_moves))\n \n # Get_center_coordinates and opponent. Then set the list of participants\n center_coordinates = center_y, center_x = get_center_coordinates(game)\n participants = [player, opponent]\n \n # Then, for each participant obtain his/her feature values \n for participant in participants:\n if participant == player:\n p_legal_moves = player_legal_moves\n player_either = player\n participant_coordinates = p_y, p_x = \\\n game.get_player_location(participant)\n player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, \\\n player_path_count, player_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either,participant_coordinates, p_legal_moves)\n else:\n p_legal_moves = opponent_legal_moves\n player_either = opponent\n participant_coordinates = p_y, p_x \\\n = game.get_player_location(participant)\n opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, opponent_min_center_diff \\\n = \\\n get_player_feature_values(game, center_coordinates, \\\n player_either, participant_coordinates, p_legal_moves)\n \n # Place each participant's feature values in a tuple/vector surrogate \n pro_player_vector = \\\n (player_legal_move_count, player_start_center_distance, \\\n player_total_next_moves, player_max_path_length, player_path_count, \\\n opponent_min_center_diff)\n pro_opponent_vector = \\\n (opponent_legal_move_count, opponent_start_center_distance, \\\n opponent_total_next_moves, opponent_max_path_length, \\\n opponent_path_count, player_min_center_diff)\n \n # Provide a weighting vector for the features \n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\n \n # Calculate the return value = weighted difference of players' features\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\n \n return float(weighted_difference_dot_product)","def get_points(self):\n self.round_points = 0\n for die in self.dice:\n if die == 1:\n self.round_points += 100\n elif die == 5:\n self.round_points += 50\n return self.round_points","def custom_score_2(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = len(game.get_legal_moves(player))\n\n if game.move_count < 15:\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)\n\n delta = 0\n\n moves = game.get_legal_moves()\n initial_moves_count = len(moves)\n indexes = np.random.permutation(initial_moves_count)\n\n for i in range(0, min(4, initial_moves_count)):\n first_level = True\n simulation = game.copy()\n\n while True:\n moves = simulation.get_legal_moves()\n moves_count = len(moves)\n if moves_count == 0:\n if simulation.is_winner(player):\n delta = delta + 1\n else:\n delta = delta - 1\n break\n if first_level:\n selected_move = indexes[i]\n first_level = False\n else:\n selected_move = random.randint(0, moves_count - 1)\n\n simulation.apply_move(moves[selected_move])\n\n return float(own_moves + delta) #float(own_moves - opp_moves + 5 * delta)\n\n #return float(own_moves - opp_moves + free_area_score(game, player) - free_area_score(game, game.get_opponent(player)))","def get_percentage_f_votes(self):\n\n votes_f = self.get_num_f_votes()\n votes_sf = self.get_num_sf_votes()\n\n # avoid dividing by zero\n if votes_f + votes_sf == 0:\n return 0\n else:\n ratio = float(votes_f)/(votes_f + votes_sf)\n return round(ratio * 100, 1)","def dilutionneeded(self) -> float:\n return self.stock*1.0/self.final","def ucbScore(self,totalPlayedTimes):\n winRate = self.winRate()\n #print totalPlayedTimes\n #print self.playedTimes\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\n \n return winRate + confidenceInterval","def _evaluate_num_pieces(self, player):\n evaluation = 0\n if player is Player.black:\n evaluation += self.num_black_pieces * 10\n evaluation -= self.num_white_pieces * 10\n evaluation += self.num_black_kings * 10\n evaluation -= self.num_white_kings * 10\n elif player is Player.white:\n evaluation -= self.num_black_pieces * 10\n evaluation += self.num_white_pieces * 10\n evaluation -= self.num_black_kings * 10\n evaluation += self.num_white_kings * 10\n\n return evaluation","def credits_earned(self):\n\n if self.grade() >= 69.5:\n return self.nCredits\n else:\n return 0.0","def update_calculated_stats(self, player_data):\n # Updates calculated statistics\n fga = player_data['FGA']\n fgm = player_data['FGM']\n pa3 = player_data['3FGA']\n pm3 = player_data['3FGM']\n try:\n player_data['FG%'] = fgm/fga\n except:\n player_data['FG%'] = 0.0\n try:\n player_data['3FG%'] = pm3/pa3\n except:\n player_data['3FG%'] = 0.0\n return(player_data)","def custom_score_7(game, player):\n \"\"\"custom_score_7 heuristic function also aims towards weighted chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def get_excess(self) -> int:\n excess_to_min_treasury = self._treasury_balance.get() - self._treasury_min.get()\n auth_score = self.create_interface_score(self._game_auth_score.get(), AuthInterface)\n if not self._excess_smoothing_live.get():\n return excess_to_min_treasury - auth_score.get_excess()\n else:\n third_party_games_excess: int = 0\n games_excess = auth_score.get_todays_games_excess()\n for game in games_excess:\n third_party_games_excess += max(0, int(games_excess[game]))\n reward_pool = excess_to_min_treasury - third_party_games_excess * 20 // 100\n return reward_pool","def winrate(matches):\n if not matches:\n print('no matches')\n return None\n\n win_loss = [match['result'] for match in matches]\n return sum(win_loss)/len(win_loss)","def golden_ratio():\n return 1.61803398875","def required_points(self):\n req_points = self.min_performance * self.initial_available_points()\n return np.maximum(0, np.int64(np.ceil(req_points)))","def custom_score_5(game, player):\n \"\"\"custom_score_5 heuristic function defines chances heuristics\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\n return float(length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)","def cost(self) -> float:","def improved_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = len(game.get_legal_moves(player))\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\n return float(own_moves - opp_moves)","def precision(self, user_list):\n hit = 0\n all_recom = 0\n print('Calculate precision: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n all_recom += len(recom_item)\n print('\\nprecision is: ', hit / (all_recom * 1.0))\n return hit / (all_recom * 1.0)","def betterEvaluationFunction(currentGameState: GameState):\n \"*** YOUR CODE HERE ***\"\n ghostScore : float = 1\n nearGhosts : float = 0\n foodScore : float = 0\n curScore = currentGameState.getScore()\n\n nearestFood = [(0, 0), float('inf')]\n pacPos = currentGameState.getPacmanPosition()\n foodPoss= currentGameState.getFood().asList()\n capsulePoss = currentGameState.getCapsules()\n ghostPoss = currentGameState.getGhostPositions()\n\n for foodPos in foodPoss:\n val = manhattanDistance(foodPos, pacPos)\n if val < nearestFood[1]:\n nearestFood[1] = val\n nearestFood[0] = foodPos\n foodScore = nearestFood[1]\n \n for gpos in ghostPoss:\n val = manhattanDistance(pacPos, gpos)\n if val <= 1:\n nearGhosts += (1-val)\n ghostScore += val\n\n return curScore - (1/ghostScore) + (1/foodScore) - nearGhosts - len(capsulePoss)","def custom_score(game, player):\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n own_moves = number_moves(game, player) / 8\n if own_moves == 0:\n return float(\"-inf\")\n\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\n if opp_moves == 0:\n return float(\"inf\")\n\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\n\n # Calculate centerness_score\n completeness = completeness_of_game(game)\n centerness_score = 0\n if completeness < 0.5:\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\n\n own_centerness = centerness(game, player) / centerness_max\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\n\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\n\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score","def getRate(self) -> int:\n if (self._total_stake.get() + self._daily_reward.get()) == 0:\n rate = DENOMINATOR\n else:\n rate = (self._total_stake.get() + self._daily_reward.get()) * DENOMINATOR // self.sICX_score.totalSupply()\n return rate","def custom_score_3(game, player):\n \"\"\"custom_score_3 heuristic function aims at maximizing win chances of my agent\n \"\"\"\n if game.is_loser(player):\n return float(\"-inf\")\n\n if game.is_winner(player):\n return float(\"inf\")\n\n length_my_player_moves = 1.0 * len(game.get_legal_moves(player))#Calculate length of available moves for myPlayer\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves with oppositePlayer\n\n if length_my_player_moves == 0:\n return float(\"-inf\")\n\n if length_opp_payer_moves == 0:\n return float(\"inf\")\n\n return float(length_my_player_moves/length_opp_payer_moves)","def centre_priority_evaluate(self):\r\n evaluation = 0\r\n for player in range(2):\r\n player_sign = player * 2 - 1\r\n for i in range(4):\r\n score = i + 1\r\n evaluation += player_sign * score * count_bits(self.bitboard_king[player] &\r\n self.CENTRE_PRIORITY_BITMASKS[i])\r\n evaluation += player_sign * score * count_bits(self.bitboard_pawns[player] &\r\n self.CENTRE_PRIORITY_BITMASKS[i])\r\n return evaluation","def dollars_per_point(self):\n if float(self.predicted_draftkings_points) == 0.0:\n return 0.0\n\n return float(self.draftkings_salary) / float(self.predicted_draftkings_points)","def rate_club(user, club):\n if not user.is_authenticated():\n return None\n if not club.posel_set.exists():\n return None\n return sum(x[1] for x in rank_in_club(user, club)) / club.posel_set.count()","def current_ratio(self):\n return self.current_assets / self.current_liabilities"],"string":"[\n \"async def player_ratio(self, ctx):\\r\\n player = ctx.message.content.split(' ')[1]\\r\\n if os.environ.get(\\\"WoW_Token\\\") is None:\\r\\n return\\r\\n else:\\r\\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\\\'jin/' + player + '?fields=pvp&locale=en_US&apikey=' + os.environ.get(\\\"WoW_Token\\\")) as res:\\r\\n if res.status == 200:\\r\\n data = await res.json()\\r\\n player_pvp_stats = data['pvp']['brackets']['ARENA_BRACKET_3v3']\\r\\n await ctx.message.channel.send(u\\\"Player: {:s}\\\").format(player)\\r\\n await ctx.message.channel.send(\\\"Rating: {:d}\\\".format(player_pvp_stats['rating']))\\r\\n await ctx.message.channel.send(\\\"Season Wins: {:d}\\\".format(player_pvp_stats['seasonWon']))\\r\\n await ctx.message.channel.send(\\\"Season Losses: {:d}\\\".format(player_pvp_stats['seasonLost']))\\r\\n\\r\\n if player_pvp_stats['seasonWon'] == 0 or player_pvp_stats['seasonLost'] == 0:\\r\\n await ctx.message.channel.send(\\\"Ratio: 0\\\")\\r\\n else:\\r\\n await ctx.message.channel.send(\\\"Ratio: {:.4f}\\\".format(\\r\\n float(player_pvp_stats['seasonWon'])/\\r\\n float(player_pvp_stats['seasonLost']))\\r\\n )\",\n \"def set_offensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0 and (bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]) > 0:\\n fgm = bx[\\\"t2p_conv\\\"] + bx[\\\"t3p_conv\\\"]\\n fga = bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"]\\n team_fgm = team[\\\"t2p_conv\\\"] + team[\\\"t3p_conv\\\"]\\n team_fga = team[\\\"t2p_int\\\"] + team[\\\"t3p_int\\\"]\\n team_points = team[\\\"t2p_conv\\\"]*2 + team[\\\"t3p_conv\\\"]*3 + team[\\\"tl_conv\\\"]\\n points = bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"]\\n\\n try:\\n qAST = (Decimal(bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5)) * (Decimal('1.14') * Decimal((team[\\\"assists\\\"] - bx[\\\"assists\\\"]) / team_fgm))) + \\\\\\n Decimal((((team[\\\"assists\\\"] / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - bx[\\\"assists\\\"]) / ((team_fgm / team[\\\"minutes\\\"]) * bx[\\\"minutes\\\"] * 5 - fgm)) * (1 - (bx[\\\"minutes\\\"] / (team[\\\"minutes\\\"] / 5))))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n qAST = 1\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n qAST = 1\\n\\n fg_part = fgm * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n ast_part = Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2*(team_fga - fga))) * bx[\\\"assists\\\"]\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n ast_part = 0\\n\\n if bx[\\\"tl_int\\\"] > 0:\\n ft_part = Decimal(1 - (1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_part = 0\\n team_scoring_poss = Decimal(team_fgm + Decimal(1 - (1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"]))**2) * team[\\\"tl_int\\\"] * Decimal('0.4'))\\n try:\\n team_orb_percentage = Decimal(team[\\\"reb_of\\\"] / (team[\\\"reb_of\\\"] + ((opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]) - opp_team[\\\"reb_of\\\"])))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_percentage = 0\\n\\n team_play_percentage = Decimal(team_scoring_poss / (team_fga + team[\\\"tl_int\\\"] * Decimal('0.4') + team[\\\"turnovers\\\"]))\\n try:\\n team_orb_weight = ((1 - team_orb_percentage) * team_play_percentage) / ((1 - team_orb_percentage) * team_play_percentage + team_orb_percentage * (1 - team_play_percentage))\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n team_orb_weight = 0\\n\\n orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage\\n\\n fg_x_poss = (fga - fgm) * (1 - Decimal('1.07') * team_orb_percentage)\\n if bx[\\\"tl_conv\\\"] > 0:\\n ft_x_poss = Decimal((1 - (bx[\\\"tl_conv\\\"] / bx[\\\"tl_int\\\"]))**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n else:\\n ft_x_poss = Decimal(1 - (bx[\\\"tl_conv\\\"] / 1)**2) * Decimal('0.4') * bx[\\\"tl_int\\\"]\\n try:\\n sc_poss = (fg_part + ast_part + ft_part) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n sc_poss =0\\n\\n tot_poss = sc_poss + fg_x_poss + ft_x_poss + bx[\\\"turnovers\\\"]\\n\\n pprod_fg_part = 2 * (fgm + Decimal('0.5') * bx[\\\"t3p_conv\\\"]) * (1 - Decimal('0.5') * Decimal((points - bx[\\\"tl_conv\\\"]) / (2 * fga)) * qAST)\\n\\n try:\\n pprod_ast_part = 2 * ((team_fgm - fgm + Decimal('0.5') * (team[\\\"t3p_conv\\\"] - bx[\\\"t3p_conv\\\"])) / (team_fgm - fgm)) * Decimal('0.5') * Decimal(((team_points - team[\\\"tl_conv\\\"]) - (points - bx[\\\"tl_conv\\\"])) / (2 * (team_fga - fga))) * bx[\\\"assists\\\"]\\n except:\\n pprod_ast_part = 0\\n\\n pprod_orb_part = bx[\\\"reb_of\\\"] * team_orb_weight * team_play_percentage * (team_points / (team_fgm + Decimal(1 - (team[\\\"tl_conv\\\"] / team[\\\"tl_int\\\"])**2) * Decimal('0.4') * team[\\\"tl_int\\\"]))\\n try:\\n pprod = (pprod_fg_part + pprod_ast_part + bx[\\\"tl_conv\\\"]) * (1 - (team[\\\"reb_of\\\"] / team_scoring_poss) * team_orb_weight * team_play_percentage) + pprod_orb_part\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n pprod = 0\\n\\n try:\\n result = 100 * (pprod / tot_poss)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n result = 0\\n\\n # print(\\\"fgm: \\\" + str(fgm))\\n # print(\\\"fga: \\\" + str(fga))\\n # print(\\\"team_fgm: \\\" + str(team_fgm))\\n # print(\\\"team_fga: \\\" + str(team_fga))\\n # print(\\\"team_points: \\\" + str(team_points))\\n # print(\\\"points: \\\" + str(points))\\n # print(\\\"qAST: \\\" + str(qAST))\\n # print(\\\"fg_part: \\\" + str(fg_part))\\n # print(\\\"ast_part: \\\" + str(ast_part))\\n # print(\\\"ft_part: \\\" + str(ft_part))\\n # print(\\\"team_scoring_poss: \\\" + str(team_scoring_poss))\\n # print(\\\"team_orb_percentage: \\\" + str(team_orb_percentage))\\n # print(\\\"team_play_percentage: \\\" + str(team_play_percentage))\\n # print(\\\"team_orb_weight: \\\" + str(team_orb_weight))\\n # print(\\\"orb_part: \\\" + str(orb_part))\\n # print(\\\"fg_x_poss: \\\" + str(fg_x_poss))\\n # print(\\\"ft_x_poss: \\\" + str(ft_x_poss))\\n # print(\\\"sc_poss: \\\" + str(sc_poss))\\n # print(\\\"tot_poss: \\\" + str(tot_poss))\\n # print(\\\"pprod_fg_part: \\\" + str(pprod_fg_part))\\n # print(\\\"pprod_ast_part: \\\" + str(pprod_ast_part))\\n # print(\\\"pprod_orb_part: \\\" + str(pprod_orb_part))\\n # print(\\\"pprod: \\\" + str(pprod))\\n # print(\\\"result: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n\\n self.ortg = \\\"%.2f\\\" % round(result, 2)\\n if Decimal(self.ortg) < 0 or Decimal(self.ortg) >= 1000:\\n \\\"\\\"\\\"For one game, maybe we've got a negative result or one so big, so, for just only a game, we get the ORTG \\n using team's formula\\\"\\\"\\\"\\n print(BCOLORS.OKBLUE + \\\"ORTG negativo o superior a 1000 para jugadora => recalculamos a través de la fórmula de equipo\\\" + BCOLORS.ENDC)\\n bx = self.get_standard_stats()\\n result = round((bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])/self.get_team_possessions(), 2)\\n self.ortg = \\\"%.2f\\\" % result\",\n \"def compute_player_score():\\n\\n progress_bar = ProgressBar(label=\\\"Computing universes\\\")\\n\\n survivals_count = 0\\n for i in range(PARALLEL_UNIVERSES_COUNT):\\n if simulate_universe():\\n survivals_count += 1\\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\\n\\n progress_bar.end(\\\"\\\\n\\\\n\\\")\\n\\n return survivals_count / PARALLEL_UNIVERSES_COUNT\",\n \"def exceeded_ratio(self) -> float:\\n return self.amount_spent / self.total_amount\",\n \"def winRate(DF):\\r\\n df = DF[\\\"return\\\"]\\r\\n pos = df[df>1]\\r\\n neg = df[df<1]\\r\\n return (len(pos) / len(pos + neg)) * 100\",\n \"def get_real_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_real_rating() / self.field.range)\",\n \"def winning_percentage(self):\\n return float(len(self.wins))/len((self.wins+self.losses))\",\n \"def KPI(self, total=True):\\n \\n data = self.select_table('ChordLog')\\n correct = data[data['PredictedLabel'] == data['ActualLabel']]\\n\\n # % correctly predicted in chord net\\n human_level_performance = (len(correct) / len(data)) * 100\\n \\n # round value\\n human_level_performance = round(human_level_performance, 4) \\n \\n return human_level_performance\",\n \"def calculate_score(self):\\n\\n correct_award = 150\\n turns_total = self.turns.count()\\n turns_correct = self.turns.filter(is_match=True).count()\\n seconds_left = (60.0 - (self.turns.last().created - self.turns.first().created).total_seconds()) or 0\\n maxpoints = turns_correct * correct_award\\n deduction_for_errors = correct_award * 0.11123\\n\\n maxpoints -= ((turns_total - turns_correct) * 2 * deduction_for_errors)\\n maxpoints += seconds_left * 5.123214\\n\\n return Decimal(maxpoints)\",\n \"def pct(self):\\n\\t\\treturn self.bottle.pct()\",\n \"def offensive_rating(data_frame, mode):\\n off_rat = dict()\\n average_points = calculate_average_points(data_frame, mode)\\n for k, possessions in possessions_home_away(data_frame, mode).items():\\n try:\\n off_rat[k] = format(float(average_points[k]) * 100 / float(possessions), '.2f')\\n except ZeroDivisionError:\\n off_rat[k] = 0.0\\n return off_rat\",\n \"def quick_ratio(self):\\n return (\\n self.current_assets - self.inventory_net) / self.current_liabilities\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def ratio_local_prod(self):\\n if self.current_energy_produced == 0.0:\\n return 1.0\\n else:\\n return 1. - self.export_grid / self.current_energy_produced\",\n \"def points_percentage(plane, p, points, total):\\n match = 0\\n for point in points:\\n if distance_to_plane(plane, point) <= p:\\n match += 1\\n\\n return match / total\",\n \"def get_free_set_percentage(self, params):\\n raise NotImplementedError()\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n result = 0\\n outcomes = range(1, num_die_sides + 1)\\n possible = sorted(gen_all_sequences(outcomes, num_free_dice))\\n for hand in possible:\\n result += score(held_dice + hand)\\n return float(result)/len(possible)\",\n \"def do_damage(self) -> float:\\n sum = 0\\n for operator in self.__operators:\\n if operator.is_alive:\\n operator.experience += 1\\n sum += operator.experience / 100\\n return 0.1 + sum\",\n \"def percent_passing(self) -> float:\\n num_meas = Enumerable(self.mlc_meas).select_many(lambda m: m.passed).count()\\n num_pass = (\\n Enumerable(self.mlc_meas)\\n .select_many(lambda m: m.passed)\\n .count(lambda p: bool(p) is True)\\n )\\n return float(100 * num_pass / num_meas)\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\r\\n die_outcomes = set(range(1, num_die_sides + 1))\\r\\n \\r\\n possible_sequences = gen_all_sequences(die_outcomes, num_free_dice)\\r\\n \\r\\n total_score = 0.0\\r\\n for sequence in possible_sequences:\\r\\n total_score += score(held_dice + sequence)\\r\\n \\r\\n return float(total_score / len(possible_sequences))\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n list_scores = []\\n die_sides = [die for die in range(1, num_die_sides + 1)]\\n possible_seq = gen_all_sequences(die_sides, num_free_dice)\\n for item in possible_seq:\\n list_scores.append(score(held_dice + item))\\n \\n return float(sum(list_scores)) / len(list_scores)\",\n \"def custom_score_4(game, player):\\n \\\"\\\"\\\"custom_score_4 heuristic function aims at minimizing loosing chances of myPlayer\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = 1.0 * len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n\\n if length_my_player_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n if length_opp_payer_moves == 0:\\n return float(\\\"inf\\\")\\n\\n return float(-length_opp_payer_moves/length_my_player_moves)\",\n \"def calculate_probability(self):\\n return 0\",\n \"def pe_ratio(self):\\n try:\\n return self.price / self.dividend_yield\\n except ZeroDivisionError:\\n return 0.0\",\n \"def adv_ratio(self): # XXX\\r\\n bw = StatsRouter.global_bw_mean\\r\\n if bw == 0.0: return 0\\r\\n else: return self.bw/bw\",\n \"def administer(self):\\n\\n score = 0.0\\n for question in self.questions:\\n if question.ask_and_evaluate() is True:\\n score += 1\\n return (score / len(self.questions)) * 100\",\n \"def rate(self) -> float:\\n return self.success_cnt / self.total_cnt if self.total_cnt > 0 else 1.0\",\n \"def evaluate(game, player):\\n weights = [2, 200, 2000, 20000]\\n reward = 0\\n opponent = get_opponent(player)\\n for length in range(2, 6):\\n reward += weights[length - 2] * get_num_series(game, player, length)\\n reward -= weights[length - 2] * get_num_series(game, opponent, length)\\n return reward\",\n \"def cal_hit_ratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\\n score = score_1 - score_2\\n return score/full['user'].nunique()\",\n \"def get_improved_score_factor(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\",\n \"def points_per_dollar(self):\\n if float(self.draftkings_salary) == 0.0:\\n return 0.0\\n\\n return float(self.predicted_draftkings_points) / float(self.draftkings_salary)\",\n \"def get_percent(self):\\n if not (self.votes and self.score):\\n return 0\\n return 100 * (self.get_rating() / self.field.range)\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return -math.inf\\n\\n if game.is_winner(player):\\n return math.inf\\n\\n opp_moves = game.get_legal_moves(game.get_opponent(player))\\n own_moves = game.get_legal_moves(player)\\n\\n return len(own_moves) / max(len(opp_moves), 1e-6)\",\n \"async def get_rob_percentage(level):\\n chance = int(6 + (level // 10)) # first 10 levels is 6 for 30% chance\\n if chance > 16:\\n chance = 16\\n return chance\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\r\\n \\r\\n scores = []\\r\\n \\r\\n die_sides = [(die + 1) for die in range(num_die_sides)]\\r\\n \\r\\n pos_outcomes = gen_all_sequences(die_sides, num_free_dice)\\r\\n\\r\\n for outcome in pos_outcomes:\\r\\n scores.append(score(held_dice + outcome))\\r\\n \\r\\n expected_result = float(sum(scores))/len(scores)\\r\\n \\r\\n return expected_result\",\n \"def determineAmountToCall(self, player):\\n\\t\\treturn sum(self.currentBet) - sum(player.betAmount)\",\n \"def calculate_profit(self):\",\n \"def custom_score_6(game, player):\\n \\\"\\\"\\\"custom_score_6 heuristic function aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - 1.5*length_opp_payer_moves*length_opp_payer_moves)\",\n \"def Probability(rating1, rating2):\\n return 1.0 * 1.0 / (1 + 1.0 * math.pow(10, 1.0 * (rating1 - rating2) / 400))\",\n \"def cash_ratio(self):\\n return self.cash / self.current_liabilities\",\n \"def punch(self, a_fighter):\\n points = int(uniform(0.7,1.0)*10*self.get_strength()/a_fighter.get_agility())\\n a_fighter.__health_points = a_fighter.get_health_points() - points\\n return a_fighter.__health_points\",\n \"def p(party, vote_count, s):\\n return t(party, vote_count) / d(s)\",\n \"def get_real_rating(self):\\n if not (self.votes and self.score):\\n return 0\\n return float(self.score)/self.votes\",\n \"def get_sharpe_ratio(allocs, prices):\\n\\tport_val = get_portfolio_value(prices, allocs, start_val=1.0)\\n\\tsharpe_ratio = get_portfolio_stats(port_val, daily_rf=0.0, samples_per_year=252)[3]\\n\\treturn -sharpe_ratio\",\n \"def defense(self):\\n #return self.stats.dexterity + (self.stats.reiatsu * self.stats.density)\\n return self.stats.defense\",\n \"def depiction_score(self):\\n\\n collision_penalty = 1\\n degenerated_penalty = 0.4\\n\\n bond_collisions = self.count_bond_collisions()\\n degenerated_atoms = self.count_suboptimal_atom_positions(0.0, 0.5)\\n\\n score = (\\n collision_penalty * bond_collisions\\n + degenerated_penalty * degenerated_atoms\\n )\\n\\n return round(score, 1)\",\n \"def custom_score(game, player):\\n \\n # get avaliable moves for each player\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n \\n # return different between # of my agent's move and oppenent's\\n return float(own_moves - opp_moves)\",\n \"def heuristic_1_center(game, player) -> float:\\n center_available_factor = get_center_available_factor(game, player)\\n\\n # Heuristic score output\\n return float(center_available_factor)\",\n \"def percent_processed(self):\\n try:\\n return (self.pos / self.data_encap.size) * 100.0\\n except ZeroDivisionError:\\n return 100.0\",\n \"def penalty(self):\\n return 0\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n # Aim to maximise your own available moves vs the opponent (Factor 2)\\n\\n opponent = game.get_opponent(player)\\n return float(len(game.get_legal_moves(player)))-2.0*float(len(game.get_legal_moves(opponent)))\",\n \"def expected_value(held_dice, num_die_sides, num_free_dice):\\n outcomes = get_outcomes(num_die_sides)\\n print \\\"outcomes:\\\", outcomes\\n\\n # generate all possible sequences of rolls\\n all_rolls = list(gen_all_sequences(outcomes, num_free_dice))\\n results = [max_repeats(roll) for roll in all_rolls]\\n value = 0.0 \\n\\n\\n for result in all_rolls:\\n curr_hand = tuple(list(held_dice) + list(result))\\n value += score(curr_hand)\\n\\n return value / len(all_rolls)\",\n \"def calc_win_lose_ratio(self):\\n total = len(self.train_y)\\n survived = 0\\n for i in self.train_y:\\n if i > 0:\\n survived += 1\\n\\n self.survival_sum = [survived, total-survived]\",\n \"def _prorata_rate(self, days_used, days_in_month):\\n return (100 * days_used // days_in_month) / 100.0\",\n \"def do_damage(self) -> float:\\n res = 0.05 + self.experience / 100\\n self.experience = self.experience + 1\\n return res\",\n \"def getProduction(self, playerID):\\n prod=0\\n for p in self.__camps:\\n if( p.getOwner() == playerID ):\\n prod = prod + p.getGrowthrate()\\n return prod\",\n \"def infected_ratio(self):\\n if self.max_pop != 0:\\n return int(self.infected_pop) / self.max_pop\\n else:\\n return 1\",\n \"def getScore(self):\\n tempscore = 1000 - 0.01*self.timeDriving \\n tempscore -= 0.1*getDist(self.maze.checkpoints[self.checkpoint].getMid(),self.pos)\\n tempscore += self.checkpoint *1000\\n tempscore += self.laps * 1000 * len(self.maze.checkpoints)\\n return tempscore\",\n \"def calculate_overall_rating(player_dict):\\r\\n if player_dict[\\\"position\\\"].upper() == \\\"QB\\\":\\r\\n throw_power = int(max(min(int(player_dict[\\\"throw_power\\\"]), 99), 70))\\r\\n throw_accuracy = int(max(min(math.ceil(\\r\\n ((2 * (\\r\\n int(player_dict[\\\"throw_accuracy_short\\\"]) + \\r\\n int(player_dict[\\\"throw_accuracy_mid\\\"]) + \\r\\n int(player_dict[\\\"throw_accuracy_deep\\\"]) + \\r\\n int(player_dict[\\\"throw_on_the_run\\\"]) + \\r\\n int(player_dict[\\\"playaction\\\"])\\r\\n )) - (2 * min(\\r\\n int(player_dict[\\\"throw_accuracy_short\\\"]), \\r\\n int(player_dict[\\\"throw_accuracy_mid\\\"]), \\r\\n int(player_dict[\\\"throw_accuracy_deep\\\"]), \\r\\n int(player_dict[\\\"throw_on_the_run\\\"]), \\r\\n int(player_dict[\\\"playaction\\\"])\\r\\n ))\\r\\n ) / 8\\r\\n ), 99), 60))\\r\\n break_tackles = int(max(min(\\r\\n math.ceil(((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 7), \\r\\n 90), 20))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 98), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 55))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((throw_power - 50.0) / 10.0) * 4.9\\r\\n overall_rating += ((throw_accuracy - 50.0) / 10.0) * 5.8\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.0\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"HB\\\":\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 70), 25))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 99), 50))\\r\\n carrying = int(max(min(int(player_dict[\\\"carrying\\\"]), 99), 60))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 45))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 50))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 0.33\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((carrying - 50.0) / 10.0) * 2.0\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.0\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.6\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 1.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"FB\\\":\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 75), 40))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 85), 45))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 99), 55))\\r\\n carrying = int(max(min(int(player_dict[\\\"carrying\\\"]), 99), 60))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 55))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 95), 60))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 60))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.0\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 7.2\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((carrying - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.0\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 5.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 39), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"WR\\\":\\r\\n break_tackles = int(max(min(\\r\\n math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2), \\r\\n 80), 35))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 75))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 75))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 35))\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 99), 65))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"TE\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 55))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 55))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 55))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 60))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 99), 45))\\r\\n break_tackles = int(max(min(\\r\\n (math.ceil((int(player_dict[\\\"elusiveness\\\"]) + int(player_dict[\\\"trucking\\\"])) / 2) + 5), \\r\\n 95), 20))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 80), 35))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 85), 35))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 2.65\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.25\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.25\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 5.4\\r\\n overall_rating += ((break_tackles - 50.0) / 10.0) * 1.2\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 1.2\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 5.4\\r\\n overall_rating = int(max(min((round(overall_rating) + 35), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LT\\\" or player_dict[\\\"position\\\"].upper() == \\\"RT\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 85), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 85), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 90), 60))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 60))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.3\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 3.75\\r\\n overall_rating = int(max(min((round(overall_rating) + 26), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if (player_dict[\\\"position\\\"].upper() == \\\"LG\\\" or player_dict[\\\"position\\\"].upper() == \\\"RG\\\" or \\r\\n player_dict[\\\"position\\\"].upper() == \\\"C\\\"):\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 85), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 85), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 90), 60))\\r\\n pass_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"pass_block\\\"]) + \\r\\n int(player_dict[\\\"pass_block_power\\\"]) + \\r\\n int(player_dict[\\\"pass_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 65))\\r\\n run_block = int(max(min(math.ceil(\\r\\n (\\r\\n int(player_dict[\\\"run_block\\\"]) + \\r\\n int(player_dict[\\\"run_block_power\\\"]) + \\r\\n int(player_dict[\\\"run_block_finesse\\\"])\\r\\n ) / 3\\r\\n ), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 0.8\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((pass_block - 50.0) / 10.0) * 3.25\\r\\n overall_rating += ((run_block - 50.0) / 10.0) * 4.8\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LE\\\" or player_dict[\\\"position\\\"].upper() == \\\"RE\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 90), 55))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 90), 45))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 3.8\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 5.5\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"DT\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 90), 45))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 70))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 90), 40))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 1.8\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 5.5\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.8\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.8\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 4.55\\r\\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"LOLB\\\" or player_dict[\\\"position\\\"].upper() == \\\"ROLB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 70))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 65))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 75))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 90), 20))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 60))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 2.4\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.6\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 2.4\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.3\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 1.3\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 4.8\\r\\n overall_rating = int(max(min((round(overall_rating) + 29), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"MLB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 95), 65))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 99), 60))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 95), 65))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 95), 75))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 99), 65))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 0.75\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 3.4\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 5.2\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.65\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.75\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 5.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 27), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"CB\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 80))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 40))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 35))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 75))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 40))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 85), 30))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.85\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 3.85\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.55\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.35\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.55\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 1.55\\r\\n overall_rating = int(max(min((round(overall_rating) + 28), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"FS\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 75))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 85), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 35))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 90), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.0\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.85\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.5\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 2.5\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3.0\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 1.5\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 2.5\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"SS\\\":\\r\\n speed = int(max(min(int(player_dict[\\\"speed\\\"]), 99), 75))\\r\\n strength = int(max(min(int(player_dict[\\\"strength\\\"]), 90), 45))\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 99), 40))\\r\\n agility = int(max(min(int(player_dict[\\\"agility\\\"]), 99), 70))\\r\\n acceleration = int(max(min(int(player_dict[\\\"acceleration\\\"]), 99), 80))\\r\\n catching = int(max(min(int(player_dict[\\\"catching\\\"]), 95), 35))\\r\\n jumping = int(max(min(int(player_dict[\\\"jumping\\\"]), 99), 65))\\r\\n tackle = int(max(min(int(player_dict[\\\"tackle\\\"]), 90), 45))\\r\\n \\r\\n overall_rating = 0.0\\r\\n overall_rating += ((speed - 50.0) / 10.0) * 3.2\\r\\n overall_rating += ((strength - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((awareness - 50.0) / 10.0) * 4.75\\r\\n overall_rating += ((agility - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((acceleration - 50.0) / 10.0) * 1.7\\r\\n overall_rating += ((catching - 50.0) / 10.0) * 3.2\\r\\n overall_rating += ((jumping - 50.0) / 10.0) * 0.9\\r\\n overall_rating += ((tackle - 50.0) / 10.0) * 3.2\\r\\n overall_rating = int(max(min((round(overall_rating) + 30), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"K\\\":\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 85), 35))\\r\\n kick_power = int(max(min(int(player_dict[\\\"kick_power\\\"]), 99), 80))\\r\\n kick_accuracy = int(max(min(int(player_dict[\\\"kick_accuracy\\\"]), 99), 70))\\r\\n \\r\\n overall_rating = (-177 + (0.218 * awareness) + (1.28 * kick_power) + (1.47 * kick_accuracy))\\r\\n overall_rating = int(max(min(round(overall_rating), 99), 40))\\r\\n return overall_rating\\r\\n \\r\\n if player_dict[\\\"position\\\"].upper() == \\\"P\\\":\\r\\n awareness = int(max(min(int(player_dict[\\\"awareness\\\"]), 85), 40))\\r\\n kick_power = int(max(min(int(player_dict[\\\"kick_power\\\"]), 99), 80))\\r\\n kick_accuracy = int(max(min(int(player_dict[\\\"kick_accuracy\\\"]), 99), 70))\\r\\n \\r\\n overall_rating = (-183 + (0.218 * awareness) + (1.5 * kick_power) + (1.33 * kick_accuracy))\\r\\n overall_rating = int(max(min(round(overall_rating), 99), 40))\\r\\n return overall_rating\",\n \"def getPercent(self):\\n if isinstance(self.score,numbers.Number) and self.getMaximum():\\n return (1.0*self.score/self.getMaximum())\\n return None\",\n \"def betterEvaluationFunction(currentGameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n pacmanPos = currentGameState.getPacmanPosition()\\n\\n food = currentGameState.getFood()\\n capsules = currentGameState.getCapsules()\\n return currentGameState.getScore() - 10 * capsuleDistancePlan(pacmanPos, capsules) - foodDistPlan(pacmanPos, food)\",\n \"def get_fool_ratio(self, test_acc, attack_accs):\\n return [round(100*((test_acc - attack_acc) / test_acc), 2) for attack_acc in attack_accs]\",\n \"def get_perf(self) :\\n self.train()\\n\\n prediction = self.clf.predict(self.df_test.drop(columns = 'up')[:-1])\\n self.accuracy = accuracy_score(df_test['up'][length:].values, prediction)\\n tn, fp, fn, tp = confusion_matrix(df_test['up'][length:].values, prediction).ravel()\\n self.recall = tp/(tp+fn)\\n self.specificity = tn / (tn+fp)\\n\\n\\n self.df_true = self.df_true[self.length:]\\n\\n profit = 1\\n mini = 1\\n maxi = 1\\n self.df_true['close'] = self.df_true['close'].map(lambda x : np.exp(x))\\n for s in range(1,len(self.df_true)):\\n if prediction[x-1] == 1 :\\n result = ((self.df_true['close'].iloc[s] -self.df_true['close'].iloc[s-1]) / self.df_true['close'].iloc[s-1]) + 1\\n profit = profit * result\\n if result < mini :\\n mini = result\\n if maxi < result :\\n maxi = result\\n self.mini = mini\\n self.maxi = maxi\\n self.profit = profit\",\n \"def custom_score(game, player):\\n \\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the improved score\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n improved = len(player_legal_moves) - len(opponent_legal_moves)\\n if improved != 0:\\n return float(improved)\\n \\n # Second get differences from center\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n player_coordinates = game.get_player_location(player)\\n opponent_coordinates = game.get_player_location(opponent)\\n player_center_dist = get_distances_from_center(center_coordinates, player_coordinates)\\n opponent_center_dist = get_distances_from_center(center_coordinates, opponent_coordinates)\\n center_dist_diff = player_center_dist - opponent_center_dist\\n \\n # Third obtain next_moves\\n player_next_moves = [get_next_moves(game, move, list(move)) for move in player_legal_moves]\\n opponent_next_moves = [get_next_moves(game, move, list(move)) for move in opponent_legal_moves] \\n improved_next = len(player_next_moves) - len(opponent_next_moves)\\n \\n # Put player and opponent feature differences in a tuple/vector surrogoate\\n feature_diff_vector = (improved, center_dist_diff, improved_next)\\n \\n # Provide a weighting vector for the features of each player-participant\\n weight_vector = (1.5,0.1,1.0)\\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*q for p,q, \\\\\\n in zip(feature_diff_vector, weight_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def get_win_percentage(self) -> float:\\n if self.wins == 0:\\n return 0.0\\n else:\\n return round((self.wins / (self.wins + self.losses)) * 100, 2)\",\n \"def betterEvaluationFunction(currentGameState):\\n score = 0\\n\\n if currentGameState.isWin():\\n score += 10000000\\n elif currentGameState.isLose():\\n score -= 10000000\\n\\n pacmanPos = currentGameState.getPacmanPosition()\\n foodList = gridToList(currentGameState.getFood())\\n\\n closestFoodDistance = distanceToClosestFood(pacmanPos, foodList) \\n\\n ghostPoses = currentGameState.getGhostPositions()\\n closestGhostDistance = distanceToClosestGhost(pacmanPos, ghostPoses)\\n\\n score = (10/closestFoodDistance) - closestGhostDistance*10 + currentGameState.getScore()\\n return score\",\n \"def _cost_caught_by_police(self):\\n if self.fine_frequency != 0:\\n if self.number_of_courses % self.fine_frequency == 0 and self.number_of_courses != 0:\\n if self.number_of_courses % self.fine_frequency_paid_by_driver == 0 and self.number_of_courses != 0:\\n self.fine_paid_number_of_courses += 1\\n fine_value = np.random.choice([100, 200, 500], p=[0.25, 0.4, 0.35])\\n self.total_penalty_points += self._add_penalty_points() # adding penalty points\\n return fine_value\\n else:\\n return 0\\n else:\\n return 0\\n else:\\n return 0\",\n \"def calculateWinRate():\\n times = 10\\n winRate = 0.0\\n for i in range(times):\\n game = Game('user', 6, 6)\\n winRate += game.play(5, False, True, False, False)\\n winRate = winRate/times\\n print \\\"Winrate:\\\", winRate\",\n \"def set_total_reb_percentage(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n player_rebounds = bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"]\\n team_rebounds = team[\\\"reb_def\\\"] + team[\\\"reb_of\\\"]\\n opp_team_rebounds = opp_team[\\\"reb_def\\\"] + opp_team[\\\"reb_of\\\"]\\n result = 0.00\\n try:\\n if bx[\\\"minutes\\\"] > 0 and bx[\\\"minutes\\\"] > 0:\\n result = ((player_rebounds * (team[\\\"minutes\\\"]/5)) / (bx[\\\"minutes\\\"] * (team_rebounds + opp_team_rebounds)))*100\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n\\n self.total_reb_percentage = \\\"%.2f\\\" % round(result, 2)\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def get_opinion_percent(self):\\n return (self.get_percent()+100)/2\",\n \"def heuristic_2_reflection(game, player) -> float:\\n\\n reflection_available_factor = get_reflection_available_factor(game, player)\\n\\n return float(reflection_available_factor)\",\n \"def get_winpercent(self, game: 'Game' = None, player: 'Player' = None):\\n if game and player:\\n pass\\n elif game:\\n play_count = self.play_set.filter(game=game).count()\\n win_count = self.play_set.filter(winner=self, game=game).count()\\n return win_count / play_count * 100\\n elif player:\\n pass\\n # play_count = self.play_set.filter(players__in=player).count()\\n # win_count = self.play_set.filter(\\n # winner=self, player=player).count()\\n # return win_count / play_count * 100\\n else:\\n return self.winpercent\",\n \"def calculate_gpa(self):\\n cur_node = self.head\\n gpa = 0\\n total_credits = 0\\n while cur_node is not None:\\n gpa += cur_node.data.grade() * cur_node.data.credit_hr()\\n total_credits += cur_node.data.credit_hr()\\n cur_node = cur_node.next\\n if total_credits == 0:\\n return 0\\n return gpa / total_credits\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n \\n # First obtain the base information to calculate player & opponent\\n # feature values\\n player_legal_moves = game.get_legal_moves(player)\\n opponent = game.get_opponent(player)\\n opponent_legal_moves = game.get_legal_moves(opponent)\\n if len(player_legal_moves) != len(opponent_legal_moves):\\n return float(len(player_legal_moves) - len(opponent_legal_moves))\\n \\n # Get_center_coordinates and opponent. Then set the list of participants\\n center_coordinates = center_y, center_x = get_center_coordinates(game)\\n participants = [player, opponent]\\n \\n # Then, for each participant obtain his/her feature values \\n for participant in participants:\\n if participant == player:\\n p_legal_moves = player_legal_moves\\n player_either = player\\n participant_coordinates = p_y, p_x = \\\\\\n game.get_player_location(participant)\\n player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, \\\\\\n player_path_count, player_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either,participant_coordinates, p_legal_moves)\\n else:\\n p_legal_moves = opponent_legal_moves\\n player_either = opponent\\n participant_coordinates = p_y, p_x \\\\\\n = game.get_player_location(participant)\\n opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, opponent_min_center_diff \\\\\\n = \\\\\\n get_player_feature_values(game, center_coordinates, \\\\\\n player_either, participant_coordinates, p_legal_moves)\\n \\n # Place each participant's feature values in a tuple/vector surrogate \\n pro_player_vector = \\\\\\n (player_legal_move_count, player_start_center_distance, \\\\\\n player_total_next_moves, player_max_path_length, player_path_count, \\\\\\n opponent_min_center_diff)\\n pro_opponent_vector = \\\\\\n (opponent_legal_move_count, opponent_start_center_distance, \\\\\\n opponent_total_next_moves, opponent_max_path_length, \\\\\\n opponent_path_count, player_min_center_diff)\\n \\n # Provide a weighting vector for the features \\n weight_vector = (1.5,0.1,1.0,0.001,0.001,0.001)\\n \\n # Calculate the return value = weighted difference of players' features\\n weighted_difference_dot_product = sum(p*(q-r ) for p,q,r \\\\\\n in zip(weight_vector, pro_player_vector, pro_opponent_vector))\\n \\n return float(weighted_difference_dot_product)\",\n \"def get_points(self):\\n self.round_points = 0\\n for die in self.dice:\\n if die == 1:\\n self.round_points += 100\\n elif die == 5:\\n self.round_points += 50\\n return self.round_points\",\n \"def custom_score_2(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = len(game.get_legal_moves(player))\\n\\n if game.move_count < 15:\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\\n\\n delta = 0\\n\\n moves = game.get_legal_moves()\\n initial_moves_count = len(moves)\\n indexes = np.random.permutation(initial_moves_count)\\n\\n for i in range(0, min(4, initial_moves_count)):\\n first_level = True\\n simulation = game.copy()\\n\\n while True:\\n moves = simulation.get_legal_moves()\\n moves_count = len(moves)\\n if moves_count == 0:\\n if simulation.is_winner(player):\\n delta = delta + 1\\n else:\\n delta = delta - 1\\n break\\n if first_level:\\n selected_move = indexes[i]\\n first_level = False\\n else:\\n selected_move = random.randint(0, moves_count - 1)\\n\\n simulation.apply_move(moves[selected_move])\\n\\n return float(own_moves + delta) #float(own_moves - opp_moves + 5 * delta)\\n\\n #return float(own_moves - opp_moves + free_area_score(game, player) - free_area_score(game, game.get_opponent(player)))\",\n \"def get_percentage_f_votes(self):\\n\\n votes_f = self.get_num_f_votes()\\n votes_sf = self.get_num_sf_votes()\\n\\n # avoid dividing by zero\\n if votes_f + votes_sf == 0:\\n return 0\\n else:\\n ratio = float(votes_f)/(votes_f + votes_sf)\\n return round(ratio * 100, 1)\",\n \"def dilutionneeded(self) -> float:\\n return self.stock*1.0/self.final\",\n \"def ucbScore(self,totalPlayedTimes):\\n winRate = self.winRate()\\n #print totalPlayedTimes\\n #print self.playedTimes\\n confidenceInterval = math.sqrt(2 * math.log(totalPlayedTimes,math.e) / self.playedTimes)\\n \\n return winRate + confidenceInterval\",\n \"def _evaluate_num_pieces(self, player):\\n evaluation = 0\\n if player is Player.black:\\n evaluation += self.num_black_pieces * 10\\n evaluation -= self.num_white_pieces * 10\\n evaluation += self.num_black_kings * 10\\n evaluation -= self.num_white_kings * 10\\n elif player is Player.white:\\n evaluation -= self.num_black_pieces * 10\\n evaluation += self.num_white_pieces * 10\\n evaluation -= self.num_black_kings * 10\\n evaluation += self.num_white_kings * 10\\n\\n return evaluation\",\n \"def credits_earned(self):\\n\\n if self.grade() >= 69.5:\\n return self.nCredits\\n else:\\n return 0.0\",\n \"def update_calculated_stats(self, player_data):\\n # Updates calculated statistics\\n fga = player_data['FGA']\\n fgm = player_data['FGM']\\n pa3 = player_data['3FGA']\\n pm3 = player_data['3FGM']\\n try:\\n player_data['FG%'] = fgm/fga\\n except:\\n player_data['FG%'] = 0.0\\n try:\\n player_data['3FG%'] = pm3/pa3\\n except:\\n player_data['3FG%'] = 0.0\\n return(player_data)\",\n \"def custom_score_7(game, player):\\n \\\"\\\"\\\"custom_score_7 heuristic function also aims towards weighted chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(1.5*length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def get_excess(self) -> int:\\n excess_to_min_treasury = self._treasury_balance.get() - self._treasury_min.get()\\n auth_score = self.create_interface_score(self._game_auth_score.get(), AuthInterface)\\n if not self._excess_smoothing_live.get():\\n return excess_to_min_treasury - auth_score.get_excess()\\n else:\\n third_party_games_excess: int = 0\\n games_excess = auth_score.get_todays_games_excess()\\n for game in games_excess:\\n third_party_games_excess += max(0, int(games_excess[game]))\\n reward_pool = excess_to_min_treasury - third_party_games_excess * 20 // 100\\n return reward_pool\",\n \"def winrate(matches):\\n if not matches:\\n print('no matches')\\n return None\\n\\n win_loss = [match['result'] for match in matches]\\n return sum(win_loss)/len(win_loss)\",\n \"def golden_ratio():\\n return 1.61803398875\",\n \"def required_points(self):\\n req_points = self.min_performance * self.initial_available_points()\\n return np.maximum(0, np.int64(np.ceil(req_points)))\",\n \"def custom_score_5(game, player):\\n \\\"\\\"\\\"custom_score_5 heuristic function defines chances heuristics\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = len(game.get_legal_moves(player)) #Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves for the oppositePlayer\\n return float(length_my_player_moves*length_my_player_moves - length_opp_payer_moves*length_opp_payer_moves)\",\n \"def cost(self) -> float:\",\n \"def improved_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = len(game.get_legal_moves(player))\\n opp_moves = len(game.get_legal_moves(game.get_opponent(player)))\\n return float(own_moves - opp_moves)\",\n \"def precision(self, user_list):\\n hit = 0\\n all_recom = 0\\n print('Calculate precision: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n all_recom += len(recom_item)\\n print('\\\\nprecision is: ', hit / (all_recom * 1.0))\\n return hit / (all_recom * 1.0)\",\n \"def betterEvaluationFunction(currentGameState: GameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n ghostScore : float = 1\\n nearGhosts : float = 0\\n foodScore : float = 0\\n curScore = currentGameState.getScore()\\n\\n nearestFood = [(0, 0), float('inf')]\\n pacPos = currentGameState.getPacmanPosition()\\n foodPoss= currentGameState.getFood().asList()\\n capsulePoss = currentGameState.getCapsules()\\n ghostPoss = currentGameState.getGhostPositions()\\n\\n for foodPos in foodPoss:\\n val = manhattanDistance(foodPos, pacPos)\\n if val < nearestFood[1]:\\n nearestFood[1] = val\\n nearestFood[0] = foodPos\\n foodScore = nearestFood[1]\\n \\n for gpos in ghostPoss:\\n val = manhattanDistance(pacPos, gpos)\\n if val <= 1:\\n nearGhosts += (1-val)\\n ghostScore += val\\n\\n return curScore - (1/ghostScore) + (1/foodScore) - nearGhosts - len(capsulePoss)\",\n \"def custom_score(game, player):\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n own_moves = number_moves(game, player) / 8\\n if own_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n opp_moves = number_moves(game, game.get_opponent(player)) / 8\\n if opp_moves == 0:\\n return float(\\\"inf\\\")\\n\\n move_ratio = (own_moves * 8) / (opp_moves * 8) / 8\\n\\n # Calculate centerness_score\\n completeness = completeness_of_game(game)\\n centerness_score = 0\\n if completeness < 0.5:\\n centerness_max = (game.width / 2.)**2 + (game.height / 2.)**2\\n\\n own_centerness = centerness(game, player) / centerness_max\\n opp_centerness = centerness(game, game.get_opponent(player)) / centerness_max\\n centerness_ratio = (own_centerness * centerness_max) / (centerness_max * opp_centerness + 0.1) / centerness_max\\n\\n centerness_score = -1 * own_centerness + opp_centerness - centerness_ratio\\n\\n return 2 * own_moves - 2 * opp_moves + 2 * move_ratio + centerness_score\",\n \"def getRate(self) -> int:\\n if (self._total_stake.get() + self._daily_reward.get()) == 0:\\n rate = DENOMINATOR\\n else:\\n rate = (self._total_stake.get() + self._daily_reward.get()) * DENOMINATOR // self.sICX_score.totalSupply()\\n return rate\",\n \"def custom_score_3(game, player):\\n \\\"\\\"\\\"custom_score_3 heuristic function aims at maximizing win chances of my agent\\n \\\"\\\"\\\"\\n if game.is_loser(player):\\n return float(\\\"-inf\\\")\\n\\n if game.is_winner(player):\\n return float(\\\"inf\\\")\\n\\n length_my_player_moves = 1.0 * len(game.get_legal_moves(player))#Calculate length of available moves for myPlayer\\n length_opp_payer_moves = len(game.get_legal_moves(game.get_opponent(player)))#Calculate length of available moves with oppositePlayer\\n\\n if length_my_player_moves == 0:\\n return float(\\\"-inf\\\")\\n\\n if length_opp_payer_moves == 0:\\n return float(\\\"inf\\\")\\n\\n return float(length_my_player_moves/length_opp_payer_moves)\",\n \"def centre_priority_evaluate(self):\\r\\n evaluation = 0\\r\\n for player in range(2):\\r\\n player_sign = player * 2 - 1\\r\\n for i in range(4):\\r\\n score = i + 1\\r\\n evaluation += player_sign * score * count_bits(self.bitboard_king[player] &\\r\\n self.CENTRE_PRIORITY_BITMASKS[i])\\r\\n evaluation += player_sign * score * count_bits(self.bitboard_pawns[player] &\\r\\n self.CENTRE_PRIORITY_BITMASKS[i])\\r\\n return evaluation\",\n \"def dollars_per_point(self):\\n if float(self.predicted_draftkings_points) == 0.0:\\n return 0.0\\n\\n return float(self.draftkings_salary) / float(self.predicted_draftkings_points)\",\n \"def rate_club(user, club):\\n if not user.is_authenticated():\\n return None\\n if not club.posel_set.exists():\\n return None\\n return sum(x[1] for x in rank_in_club(user, club)) / club.posel_set.count()\",\n \"def current_ratio(self):\\n return self.current_assets / self.current_liabilities\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6531963","0.6401618","0.61817557","0.6132738","0.6081823","0.6071461","0.60199296","0.5966795","0.5962311","0.59621847","0.5957963","0.59393156","0.59319943","0.5922137","0.5918801","0.5913682","0.5907549","0.58991516","0.5896585","0.5889761","0.5885497","0.58792573","0.5869189","0.5865168","0.58413595","0.5838629","0.5836382","0.58291775","0.5822119","0.58184373","0.58169717","0.58143294","0.5811706","0.57919323","0.578745","0.57854813","0.57723236","0.5758267","0.57561344","0.57535964","0.57506484","0.57280684","0.57116556","0.5706946","0.57020426","0.569756","0.5695808","0.569299","0.567984","0.56726795","0.5668198","0.56649","0.565448","0.5652856","0.56515527","0.5643938","0.5643929","0.56411755","0.5641122","0.5640217","0.56401664","0.5636776","0.5620967","0.5619293","0.5616671","0.5614021","0.5602146","0.55925447","0.55884004","0.5577805","0.5577222","0.55698454","0.5567678","0.5565706","0.55634207","0.5562125","0.55569094","0.55520463","0.5549593","0.5549295","0.5546663","0.5546206","0.5546096","0.5545535","0.55374354","0.55356914","0.55318314","0.553074","0.55285645","0.552515","0.5525104","0.5524755","0.5511058","0.550978","0.5507363","0.5507355","0.5506616","0.5504503","0.55024606","0.5501506"],"string":"[\n \"0.6531963\",\n \"0.6401618\",\n \"0.61817557\",\n \"0.6132738\",\n \"0.6081823\",\n \"0.6071461\",\n \"0.60199296\",\n \"0.5966795\",\n \"0.5962311\",\n \"0.59621847\",\n \"0.5957963\",\n \"0.59393156\",\n \"0.59319943\",\n \"0.5922137\",\n \"0.5918801\",\n \"0.5913682\",\n \"0.5907549\",\n \"0.58991516\",\n \"0.5896585\",\n \"0.5889761\",\n \"0.5885497\",\n \"0.58792573\",\n \"0.5869189\",\n \"0.5865168\",\n \"0.58413595\",\n \"0.5838629\",\n \"0.5836382\",\n \"0.58291775\",\n \"0.5822119\",\n \"0.58184373\",\n \"0.58169717\",\n \"0.58143294\",\n \"0.5811706\",\n \"0.57919323\",\n \"0.578745\",\n \"0.57854813\",\n \"0.57723236\",\n \"0.5758267\",\n \"0.57561344\",\n \"0.57535964\",\n \"0.57506484\",\n \"0.57280684\",\n \"0.57116556\",\n \"0.5706946\",\n \"0.57020426\",\n \"0.569756\",\n \"0.5695808\",\n \"0.569299\",\n \"0.567984\",\n \"0.56726795\",\n \"0.5668198\",\n \"0.56649\",\n \"0.565448\",\n \"0.5652856\",\n \"0.56515527\",\n \"0.5643938\",\n \"0.5643929\",\n \"0.56411755\",\n \"0.5641122\",\n \"0.5640217\",\n \"0.56401664\",\n \"0.5636776\",\n \"0.5620967\",\n \"0.5619293\",\n \"0.5616671\",\n \"0.5614021\",\n \"0.5602146\",\n \"0.55925447\",\n \"0.55884004\",\n \"0.5577805\",\n \"0.5577222\",\n \"0.55698454\",\n \"0.5567678\",\n \"0.5565706\",\n \"0.55634207\",\n \"0.5562125\",\n \"0.55569094\",\n \"0.55520463\",\n \"0.5549593\",\n \"0.5549295\",\n \"0.5546663\",\n \"0.5546206\",\n \"0.5546096\",\n \"0.5545535\",\n \"0.55374354\",\n \"0.55356914\",\n \"0.55318314\",\n \"0.553074\",\n \"0.55285645\",\n \"0.552515\",\n \"0.5525104\",\n \"0.5524755\",\n \"0.5511058\",\n \"0.550978\",\n \"0.5507363\",\n \"0.5507355\",\n \"0.5506616\",\n \"0.5504503\",\n \"0.55024606\",\n \"0.5501506\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65123755"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":30,"numItemsPerPage":100,"numTotalItems":95772,"offset":3000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzY5NzE1OSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM3MDA3NTksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.cqX8T3WlKt1m08s748-zPAzZsARJqOMlt-M5tkIWRDIZmOWmvRepWNXgFVIiaBbv6sjk2vKbWlAvXfT4SGcKAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102 values |
|---|---|---|---|---|---|---|
Softmax loss function, vectorized version. Inputs and outputs are the same as softmax_loss_naive. | def softmax_loss_vectorized(W, X, y, reg):
# Initialize the loss and gradient to zero.
loss = 0.0
dW = np.zeros_like(W)
#############################################################################
# TODO: Compute the softmax loss and its gradient using no explicit loops. #
# Store the loss in loss and the gradient in dW. If you are not careful #
# here, it is easy to run into numeric instability. Don't forget the #
# regularization! #
#############################################################################
N = X.shape[0]
f = np.dot(X, W)
f -= np.amax(f, axis = 1, keepdims = True) # for numerical stability
exp_f = np.exp(f)
exp_fyi = exp_f[range(N), y].reshape((N, 1)) # correct class probabilities
sum_exp_f = np.sum(exp_f, axis = 1, keepdims = True)
losses = -np.log(exp_fyi / sum_exp_f)
loss = 1 / N * np.sum(losses) + reg * np.sum(W * W)
P = exp_f / sum_exp_f
y_one_hot = np.zeros_like(P)
y_one_hot[range(len(y)), y] = 1
df = 1 / N * (P - y_one_hot)
dW = np.dot(X.T, df)
#############################################################################
# END OF YOUR CODE #
#############################################################################
return loss, dW | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def softmax_loss_naive(W, X, y, reg):\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n num_train = X.shape[1]\n num_classes = W.shape[0]\n #############################################################################\n # Compute the softmax loss and its gradient usi... | [
"0.76837397",
"0.75555336",
"0.755513",
"0.75321347",
"0.7522562",
"0.7514906",
"0.7509924",
"0.74732995",
"0.747066",
"0.74670047",
"0.7465988",
"0.7429649",
"0.7429498",
"0.74292433",
"0.74264807",
"0.74254495",
"0.7410896",
"0.7408939",
"0.7406985",
"0.738524",
"0.7385114"... | 0.0 | -1 |
Initialize the axis ranges from proviuded Plot or renderer. | def initialize_axis_ranges(self, plot, transform=None):
if transform is None:
def transform(x):
return x
elif isinstance(transform, int):
ndigits = transform
def transform(x):
return round(x, ndigits)
# Avoid UI polluting with non-sensical digits
self.x_axis_range_low = transform(plot.x_axis.mapper.range.low)
self.auto_x_axis_range_low = self.x_axis_range_low
self.x_axis_range_high = transform(plot.x_axis.mapper.range.high)
self.auto_x_axis_range_high = self.x_axis_range_high
self.y_axis_range_low = transform(plot.y_axis.mapper.range.low)
self.auto_y_axis_range_low = self.y_axis_range_low
self.y_axis_range_high = transform(plot.y_axis.mapper.range.high)
self.auto_y_axis_range_high = self.y_axis_range_high | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_axes(self):\n mini, maxi = self._get_extremes()\n self.y_axis.min = mini\n self.y_axis.max = maxi\n self.y_axis._max_min()\n\n if not None in [s.xvalues for s in self]:\n mini, maxi = self._get_extremes('xvalues')\n self.x_axis.min = mini\n ... | [
"0.71792495",
"0.7129534",
"0.68548447",
"0.67877525",
"0.6537042",
"0.64943486",
"0.641954",
"0.6235867",
"0.6223747",
"0.6188791",
"0.61873025",
"0.61726326",
"0.6160985",
"0.6133905",
"0.61263645",
"0.61139727",
"0.61138016",
"0.61124223",
"0.60551167",
"0.60020185",
"0.60... | 0.7375276 | 0 |
Setup a host for proper deployment. Assuming Debian Linux. | def setup():
debs = ("python-setuptools", "apache2", "libapache2-mod-wsgi")
require("hosts", provided_by=[production, staging])
sudo("apt-get install %s" % " ".join(debs))
sudo("easy_install virtualenv pip")
sudo("mkdir -p %(path)s" % env)
with cd("%(path)s" % env):
sudo("mkdir -p releases; mkdir -p packages")
sudo("virtualenv --no-site-packages .")
sudo("mkdir -p /var/log/twit-demo; chown www-data:www-data /var/log/twit-demo") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_machine():\n # Initial setup and package install.\n sudo(\"aptitude update\")\n sudo(\"aptitude -y install git-core python-dev python-setuptools \"\n \"postgresql-dev postgresql-client build-essential \"\n \"libpq-dev subversion mercurial... | [
"0.7073709",
"0.69501",
"0.65425813",
"0.63506156",
"0.6257246",
"0.6216987",
"0.61947876",
"0.60763687",
"0.6047417",
"0.601704",
"0.59991187",
"0.5992791",
"0.5950253",
"0.58975947",
"0.5893902",
"0.5886802",
"0.5858583",
"0.5855254",
"0.5841016",
"0.5830183",
"0.581706",
... | 0.6556086 | 2 |
Deploy a new relase. | def deploy():
require("hosts", provided_by=[production, staging])
env.release = time.strftime("%Y-%m-%d_%H:%M:%S")
upload_tar_from_git()
install_requirements()
setup_webserver()
symlink_current_release()
restart_webserver() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deploy():",
"def deploy():\n return do_deploy(do_pack())",
"def deploy():\n return do_deploy(do_pack())",
"def deploy():\n return do_deploy(do_pack())",
"def deploy():\n build()\n copy()\n install()",
"def deploy():\n update_treesheets()\n restart_treesheets()",
"def deploy():\n... | [
"0.7744899",
"0.706143",
"0.706143",
"0.706143",
"0.6948104",
"0.69311583",
"0.6749892",
"0.6712348",
"0.67008215",
"0.66962844",
"0.6653298",
"0.66502756",
"0.6646828",
"0.6614402",
"0.65999466",
"0.65739655",
"0.65360653",
"0.647553",
"0.6442106",
"0.64005727",
"0.6380691",... | 0.68142927 | 6 |
Create an archive from the given tree, upload, and untar it. | def upload_tar_from_git():
require("release", provided_by=[deploy])
tree = prompt("Please enter a branch or SHA1 to deploy", default="master")
local("git archive --format=tar %s | gzip > %s.tar.gz" % (tree, env['release']))
sudo("mkdir %(path)s/releases/%(release)s" % env)
put("%(release)s.tar.gz" % env, "%(path)s/packages/" % env, use_sudo=True)
sudo("cd %(path)s/releases/%(release)s && tar zxf ../../packages/%(release)s.tar.gz" % env)
local("rm %(release)s.tar.gz" % env) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_tar(self):\n with tarfile.open(self.tgzfile, \"w:gz\") as tar_handle:\n for root, _, files in os.walk(self.dirname):\n for file in files:\n tar_handle.add(os.path.join(root, file))",
"def untar(conn, tarball, path):\n conn.run(f\"tar xf {tarball} -C... | [
"0.6552709",
"0.6145302",
"0.59912825",
"0.590548",
"0.5857982",
"0.5824896",
"0.5788129",
"0.57454973",
"0.5727448",
"0.5701735",
"0.5637337",
"0.5634134",
"0.5598457",
"0.55868477",
"0.5579905",
"0.5539658",
"0.5536656",
"0.5533471",
"0.5514017",
"0.5374604",
"0.53565294",
... | 0.6242641 | 1 |
Install the required Python packages inside the virtualenv. | def install_requirements():
require("release", provided_by=[deploy])
with cd("%(path)s" % env):
sudo("./bin/pip install -r ./releases/%(release)s/requirements.txt" % env) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub_install_python_requirements():\n # Activate the virtualenv\n activate = 'source {0}/{1}/bin/activate'.format(\n env.virtualenv['dir'], env.virtualenv['name'])\n run(activate)\n\n # Install Python requirements\n install = 'pip install -r /vagrant/Flask_app/requirements.txt'\n\n # Jo... | [
"0.79861814",
"0.7786814",
"0.7778329",
"0.77555937",
"0.76573926",
"0.7628999",
"0.7594286",
"0.75698286",
"0.744025",
"0.74060243",
"0.73893565",
"0.7277837",
"0.72283304",
"0.72203624",
"0.72196406",
"0.7206115",
"0.71840227",
"0.7166442",
"0.7125818",
"0.706724",
"0.70155... | 0.6828054 | 38 |
Symlink to the new current release. | def symlink_current_release():
require("release", provided_by=[deploy])
with cd("%(path)s/releases" % env):
sudo("ln -s %(release)s current_tmp && mv -Tf current_tmp current" % env) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def symlink():\n releases()\n env.current_path = '/root/your_project/current'\n run('rm %(current_path)s' % env)\n run('ln -s %(current_release)s %(current_path)s' % env)",
"def symlink(timestamp):\n if exists(env.current_dir):\n run('rm -r %(current_dir)s' % env)\n run('ln -s %s %s' % (... | [
"0.85483825",
"0.7888362",
"0.6896718",
"0.6580014",
"0.640067",
"0.6382023",
"0.609916",
"0.59879214",
"0.598062",
"0.58782184",
"0.5851017",
"0.5815926",
"0.5792104",
"0.57686156",
"0.57686156",
"0.57261956",
"0.57167125",
"0.5602009",
"0.55953795",
"0.55733645",
"0.5570685... | 0.8182266 | 1 |
Remove older releases, keeping the last `keep_num` intact. | def cleanup(keep_num=5):
keep_num = int(keep_num)
assert keep_num > 0, "[ERROR] keep_num must be > 0; refusing to proceed."
with cd("%(path)s/packages" % env):
package_files = sorted(run("ls -1").split())
package_files = [_.replace(".tar.gz", "") for _ in package_files]
with cd("%(path)s/releases" % env):
release_files = sorted(run("ls -1").split())
release_files.remove('current')
diff = set(package_files).symmetric_difference(set(release_files))
if diff:
raise Exception("[ERROR]: Package and release directories are out of sync;"
" refusing to proceed. Please fix this difference manually: %s" % diff)
package_files = package_files[:-keep_num]
release_files = release_files[:-keep_num]
with cd("%(path)s/packages" % env):
[sudo("rm %s.tar.gz" % _) for _ in package_files]
with cd("%(path)s/releases" % env):
[sudo("rm -r %s" % _) for _ in release_files] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _deleteOldVersionsByAge(self, model, max_age, number_to_keep=None):\r\n adapter = getVersionManagementAdapter(model)\r\n\r\n version_ids = self._getOldVersionIds(adapter)\r\n if number_to_keep is not None:\r\n if len(version_ids) < number_to_keep:\r\n return\r\n ... | [
"0.64156675",
"0.6380838",
"0.63680077",
"0.56757736",
"0.544219",
"0.5342159",
"0.5324215",
"0.52694285",
"0.5213804",
"0.51900595",
"0.51862675",
"0.5181022",
"0.51753306",
"0.51589394",
"0.51021165",
"0.50865173",
"0.50815326",
"0.5056275",
"0.5055268",
"0.505497",
"0.5032... | 0.69273704 | 0 |
Class handles loading data for many separate nodes. | def __init__(self,
dataset: str,
train: bool,
subset: bool):
PERCENT = .3
if dataset == 'MNIST':
data = torchvision.datasets.MNIST('./data', train=train, download=True,
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(
(0.1307,), (0.3081,))
]))
else:
raise ValueError
data_size = len(data)
self.data = data
if subset:
indx = torch.randperm(data_size)[:int(data_size * PERCENT)]
self.samples = self.data.data[indx, :, :]
self.labels = self.data.targets[indx]
else:
self.samples = self.data.data
self.labels = self.data.targets
self.random_seed = 42 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data():\n\n server_node = load_nodes(SERVER_NODE_INFILE)\n road_node = load_nodes(ROAD_NODE_INFILE)\n road_segment_point = load_nodes(ROAD_SEGMENT_POINT_INFILE)\n\n return server_node, road_node, road_segment_point",
"def load_data(self):",
"def dispatch_load(self):\n\n for node in ... | [
"0.7005817",
"0.6853901",
"0.68161523",
"0.67189497",
"0.65886134",
"0.6483465",
"0.64096814",
"0.6365568",
"0.63560086",
"0.62556756",
"0.62167966",
"0.6192285",
"0.618386",
"0.6101325",
"0.6019031",
"0.5991078",
"0.59765136",
"0.59683806",
"0.5959553",
"0.59291226",
"0.5928... | 0.0 | -1 |
Separate data into number of agents | def partition(self, to_partition, indices, nr_agents):
return [to_partition[indices[i]:indices[i + 1]] for i in range(nr_agents)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_number_of_agents(model):\n\n n_agents = len(model.schedule.agents_by_type['Customer'])\n return n_agents",
"def get_agent_number_of_players(players):\n return sum([count_players(player) for player in players\n if player.startswith('agent')])",
"def parse_data(self, data):\n p... | [
"0.6075499",
"0.60177237",
"0.5733644",
"0.56019175",
"0.551722",
"0.5478866",
"0.5476945",
"0.5474742",
"0.5418446",
"0.53685576",
"0.5309423",
"0.530098",
"0.530098",
"0.5294951",
"0.5268969",
"0.525845",
"0.52577895",
"0.52215326",
"0.5189219",
"0.51605994",
"0.5125644",
... | 0.0 | -1 |
Different ways to split data between nodes. | def split(self, how, nr_agents, **kwargs):
if how == 'random':
self.random_split(nr_agents)
elif how == 'uniform':
self.uniform_split(nr_agents)
elif how == 'non_iid_uniform':
self.non_iid_split(nr_agents, kwargs['class_per_node'], random=False)
elif how == 'non_iid_random':
self.non_iid_split(nr_agents, kwargs['class_per_node'], random=True)
return self.get_data() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __split_node(self, cur_node):\n temp = self.Node(cur_node.data_list[len(cur_node.data_list) / 2:], cur_node.next_node)\n cur_node.data_list = cur_node.data_list[:len(cur_node.data_list) / 2]\n cur_node.next_node = temp\n\n if cur_node == self.tail:\n self.tail = cur_node.... | [
"0.6493564",
"0.6465813",
"0.63918084",
"0.62302977",
"0.6212308",
"0.6188923",
"0.6174351",
"0.61242145",
"0.61228055",
"0.60877246",
"0.6079287",
"0.6019898",
"0.60130966",
"0.598436",
"0.59603816",
"0.5949242",
"0.59408516",
"0.59373665",
"0.59328663",
"0.59160835",
"0.591... | 0.0 | -1 |
Give each Node random splits of data. Nodes will have different amounts of data. | def random_split(self, nr_agents):
np.random.seed(self.random_seed)
# Get random indices
indices = sorted(np.random.randint(0, high=self.samples.shape[0], size=nr_agents - 1).tolist())
indices = [0] + indices
indices += [self.samples.shape[0]]
self.samples = self.partition(self.samples, indices, nr_agents)
self.labels = self.partition(self.labels, indices, nr_agents) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_test_split(self):\n random.seed(self.args.seed)\n nodes = [node for node in range(self.ncount)]\n random.shuffle(nodes)\n self.train_nodes = torch.LongTensor(nodes[0:self.args.training_size])\n self.validation_nodes = torch.LongTensor(nodes[self.args.training_size:self.... | [
"0.68305767",
"0.6814471",
"0.6748061",
"0.6691443",
"0.66873974",
"0.65587986",
"0.6541015",
"0.6525626",
"0.64753836",
"0.64283437",
"0.63601255",
"0.6316696",
"0.63140213",
"0.6251376",
"0.6247065",
"0.62162656",
"0.6213909",
"0.6207955",
"0.61947703",
"0.6160189",
"0.6145... | 0.6804831 | 2 |
Give each Node uniform splits of data. Nodes will have same amounts of data. | def uniform_split(self, nr_agents):
indices = np.linspace(start=0, stop=self.samples.shape[0], num=nr_agents + 1, dtype=int).tolist()
self.samples = self.partition(self.samples, indices, nr_agents)
self.labels = self.partition(self.labels, indices, nr_agents) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_data(self):\r\n print('split data')\r\n np.random.shuffle(self.dataList)\r\n l = len(self.dataList)/self.fold\r\n self.dataList = [self.dataList[i*l: (i+1)*l] for i in range(self.fold-1)] + [self.dataList[(self.fold-1)*l:]] # each element in the list is splitted data list\r",... | [
"0.6593751",
"0.64535356",
"0.6275442",
"0.624764",
"0.6210491",
"0.61586165",
"0.61282647",
"0.6122043",
"0.6105798",
"0.6105246",
"0.6102763",
"0.60595816",
"0.6045628",
"0.6025434",
"0.60080785",
"0.5965141",
"0.5959221",
"0.59428424",
"0.5918808",
"0.59182876",
"0.5914056... | 0.6529111 | 1 |
Give nodes only certain number of class labels as data. | def non_iid_split(self, nr_agents, class_per_node, random):
unique = list(set(self.labels.tolist()))
len_unique = len(unique)
# Create array that assigns a class to specific nodes
# Use 'np.arange' to ensure every class is represented before repeating
# A row represents nr_agents, a column represents classes per node
agent_class_master = np.arange(start=0, stop=nr_agents * class_per_node) % len_unique
np.random.shuffle(agent_class_master)
agent_class_master = agent_class_master.reshape(nr_agents, class_per_node)
# Split data by labels
sample_list = [[] for _ in range(len_unique)]
for i in range(len(self.labels)):
sample_list[self.labels[i]].append(self.samples[i])
# By class creates uniform or random indices splits to partition data to agents evenly
class_count = np.bincount(agent_class_master.ravel())
class_indices = {}
for i in range(len(class_count)):
if random:
indices = sorted(np.random.randint(0, high=len(sample_list[i]), size=class_count[i] - 1).tolist())
indices = [0] + indices
indices += [len(sample_list[i])]
class_indices[i] = indices
else:
class_indices[i] = np.linspace(start=0, stop=len(sample_list[i]), num=class_count[i] + 1,
dtype=int).tolist()
# Main loop that partitions data by the assigned class and proper amount
all_agents = []
all_class = []
for agent in agent_class_master:
agent_data = []
agent_class = []
for cls in agent:
# Proportioned indices for data and grab correctly indexed data
temp_indices = class_indices[cls]
data_for_agent = sample_list[cls][temp_indices[0]:temp_indices[1] - 1]
# Add data and class to this agents list
agent_data = agent_data + data_for_agent
agent_class = agent_class + [cls for _ in range(len(data_for_agent))]
# Drop first index since we used that data, forces next person to use next index
class_indices[cls] = temp_indices[1:]
# Append agents data and class labels in order
all_agents.append(torch.stack(agent_data))
all_class.append(torch.tensor(agent_class))
self.samples = all_agents
self.labels = all_class | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multi_class5_classification_dataset_sparse_labels() -> tf.data.Dataset:\n\n # Create features\n X = tf.random.normal(shape=(100, 3))\n\n # Create one multi-class (one hot) labels\n y = tf.random.uniform(minval=0, maxval=5, dtype=tf.int32, shape=(100,))\n\n return tf.data.Dataset.from_tensor_slic... | [
"0.63320434",
"0.6277881",
"0.6271124",
"0.6242542",
"0.6160365",
"0.6119636",
"0.60193723",
"0.59684384",
"0.59684384",
"0.5925846",
"0.5914046",
"0.58883923",
"0.58800185",
"0.5870202",
"0.58377177",
"0.58357537",
"0.5825657",
"0.5825657",
"0.5825657",
"0.5825657",
"0.58256... | 0.56607765 | 32 |
Uses LoadData class to partition prepare data. Puts data into dataloader objects to make use of batching and shuffling. | def load_mnist_data(nr_nodes, nr_classes, allocation, subset, batch_size):
train_loader_list = []
test_loader_list = []
train = LoadData('MNIST', True, subset)
test = LoadData('MNIST', False, False)
train_data, train_targets = train.split(allocation, nr_nodes, class_per_node=nr_classes)
for data, targets in zip(train_data, train_targets):
train_dataset = CustomDataset(data, targets)
train_loader_list.append(DataLoader(train_dataset, batch_size=batch_size, shuffle=True))
test_data, test_targets = test.split('uniform', nr_nodes)
for data, targets in zip(test_data, test_targets):
test_dataset = CustomDataset(data, targets)
test_loader_list.append(DataLoader(test_dataset, batch_size=batch_size, shuffle=False))
return train_loader_list, test_loader_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataloader(self):\n\n # load / split data\n train_data = self.data.get_train_data()\n if self.args.use_dev:\n train_data, dev_data = self.data.split_data(train_data)\n test_data = self.data.get_test_data()\n\n #print(train_data[0])\n #print(dev_data[0])\n ... | [
"0.7089528",
"0.69590586",
"0.6943236",
"0.6820497",
"0.67818403",
"0.665066",
"0.662082",
"0.65793914",
"0.65624624",
"0.65569514",
"0.6556639",
"0.6548388",
"0.6527811",
"0.65153986",
"0.6513853",
"0.6507452",
"0.65053266",
"0.6497079",
"0.64861447",
"0.64734644",
"0.646940... | 0.0 | -1 |
This function computes the distribution internal parameters from its two first moments. | def _compute_internals(self, moments):
[mean, stdv] = moments
internals = {}
internals['a'] = mean - np.sqrt(3) * stdv
internals['b'] = mean + np.sqrt(3) * stdv
return internals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['mu'] = mean\n internals['sigma'] = stdv\n\n return internals",
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['k... | [
"0.6455378",
"0.6220392",
"0.6185545",
"0.6109156",
"0.6106636",
"0.60708535",
"0.60512894",
"0.60178155",
"0.5966822",
"0.59502286",
"0.58735156",
"0.5850575",
"0.58171284",
"0.5816514",
"0.57661724",
"0.5720821",
"0.57173246",
"0.57122564",
"0.5709464",
"0.57005703",
"0.565... | 0.6434524 | 1 |
This function computes the distribution internal parameters from its two first moments. | def _compute_internals(self, moments):
[mean, stdv] = moments
internals = {}
internals['a'] = mean - np.sqrt(3) * stdv
internals['b'] = mean + np.sqrt(3) * stdv
return internals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['mu'] = mean\n internals['sigma'] = stdv\n\n return internals",
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['k... | [
"0.6455378",
"0.6220392",
"0.6185545",
"0.6109156",
"0.6106636",
"0.60708535",
"0.60512894",
"0.60178155",
"0.5966822",
"0.59502286",
"0.58735156",
"0.5850575",
"0.58171284",
"0.5816514",
"0.57661724",
"0.5720821",
"0.57173246",
"0.57122564",
"0.5709464",
"0.57005703",
"0.565... | 0.6434524 | 2 |
This function computes the distribution internal parameters from its two first moments. | def _compute_internals(self, moments):
[mean, stdv] = moments
internals = {}
internals['mu'] = mean
internals['sigma'] = stdv
return internals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['a'] = mean - np.sqrt(3) * stdv\n internals['b'] = mean + np.sqrt(3) * stdv\n\n return internals",
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n i... | [
"0.6434524",
"0.6434524",
"0.6220392",
"0.6185545",
"0.6109156",
"0.6106636",
"0.60708535",
"0.60512894",
"0.60178155",
"0.5966822",
"0.59502286",
"0.58735156",
"0.5850575",
"0.58171284",
"0.5816514",
"0.57661724",
"0.5720821",
"0.57173246",
"0.57122564",
"0.5709464",
"0.5700... | 0.6455378 | 0 |
This function computes the distribution internal parameters from its two first moments. | def _compute_internals(self, moments):
[mean, stdv] = moments
cov = stdv / mean
zeta = np.sqrt(np.log(1. + cov ** 2.))
LAMBDA = np.log(mean) - 0.5 * zeta ** 2.
internals = {}
internals['LAMBDA'] = LAMBDA
internals['zeta'] = zeta
return internals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['mu'] = mean\n internals['sigma'] = stdv\n\n return internals",
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['a... | [
"0.6455378",
"0.6434524",
"0.6434524",
"0.6220392",
"0.6185545",
"0.6109156",
"0.60708535",
"0.60512894",
"0.60178155",
"0.5966822",
"0.59502286",
"0.58735156",
"0.5850575",
"0.58171284",
"0.5816514",
"0.57661724",
"0.5720821",
"0.57173246",
"0.57122564",
"0.5709464",
"0.5700... | 0.6106636 | 6 |
This function computes the distribution internal parameters from its two first moments. | def _compute_internals(self, moments):
[mean, stdv] = moments
internals = {}
internals['k'] = mean ** 2. / stdv ** 2.
internals['LAMBDA'] = mean / stdv ** 2.
return internals | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['mu'] = mean\n internals['sigma'] = stdv\n\n return internals",
"def _compute_internals(self, moments):\n\n [mean, stdv] = moments\n internals = {}\n internals['a... | [
"0.6455378",
"0.6434524",
"0.6434524",
"0.6185545",
"0.6109156",
"0.6106636",
"0.60708535",
"0.60512894",
"0.60178155",
"0.5966822",
"0.59502286",
"0.58735156",
"0.5850575",
"0.58171284",
"0.5816514",
"0.57661724",
"0.5720821",
"0.57173246",
"0.57122564",
"0.5709464",
"0.5700... | 0.6220392 | 3 |
Date the activity was created. | def creation_date(self) -> str:
return pulumi.get(self, "creation_date") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def date_created(self) -> datetime:\n return self._date_created",
"def created_date(self):\n return self._created_date",
"def created_date(self):\n return self._created_date",
"def date_created(self):\n return self._date_created",
"def date_created(self):\n return self._d... | [
"0.8107826",
"0.7986173",
"0.7986173",
"0.797429",
"0.797429",
"0.797429",
"0.7832342",
"0.78072244",
"0.7796537",
"0.7792625",
"0.76402485",
"0.75940555",
"0.7574318",
"0.75237525",
"0.75237525",
"0.75183827",
"0.7475857",
"0.74230283",
"0.73979384",
"0.7372514",
"0.7362803"... | 0.8029383 | 3 |
The providerassigned unique ID for this managed resource. | def id(self) -> str:
return pulumi.get(self, "id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def provider_id(self):\n return self.get('_id')",
"def provider_id(self):\n raise NotImplementedError",
"def id(self):\n return self.raw_resource.uuid",
"def healthcare_provider_id(self):\n return self._healthcare_provider_id",
"def unique_identifier(self) -> str:\n retur... | [
"0.8193402",
"0.7851373",
"0.77124894",
"0.7604287",
"0.7477648",
"0.7476093",
"0.7476093",
"0.7476093",
"0.7425807",
"0.7380237",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.7371964",
"0.735787",
"0.735787",
"0.73477197",
"... | 0.0 | -1 |
Provides a Step Functions Activity data source Example Usage ```python import pulumi import pulumi_aws as aws sfn_activity = aws.sfn.get_activity(name="myactivity") ``` | def get_activity(arn: Optional[str] = None,
name: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetActivityResult:
__args__ = dict()
__args__['arn'] = arn
__args__['name'] = name
opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
__ret__ = pulumi.runtime.invoke('aws:sfn/getActivity:getActivity', __args__, opts=opts, typ=GetActivityResult).value
return AwaitableGetActivityResult(
arn=pulumi.get(__ret__, 'arn'),
creation_date=pulumi.get(__ret__, 'creation_date'),
id=pulumi.get(__ret__, 'id'),
name=pulumi.get(__ret__, 'name')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_activities():\n pass",
"def get_activity_output(arn: Optional[pulumi.Input[Optional[str]]] = None,\n name: Optional[pulumi.Input[Optional[str]]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetActivityResult]:\n ...",
"def c... | [
"0.6528125",
"0.64868456",
"0.60511726",
"0.6050907",
"0.59809947",
"0.5972801",
"0.5858322",
"0.5832111",
"0.57496256",
"0.57023674",
"0.56348556",
"0.56348556",
"0.5538348",
"0.5492945",
"0.54754126",
"0.5414958",
"0.53552705",
"0.53485847",
"0.53307176",
"0.5305301",
"0.52... | 0.6439963 | 2 |
Provides a Step Functions Activity data source Example Usage ```python import pulumi import pulumi_aws as aws sfn_activity = aws.sfn.get_activity(name="myactivity") ``` | def get_activity_output(arn: Optional[pulumi.Input[Optional[str]]] = None,
name: Optional[pulumi.Input[Optional[str]]] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetActivityResult]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_activities():\n pass",
"def get_activity(arn: Optional[str] = None,\n name: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetActivityResult:\n __args__ = dict()\n __args__['arn'] = arn\n __args__['name'] = name\n opts = pul... | [
"0.652813",
"0.64412045",
"0.6052704",
"0.60521966",
"0.59815174",
"0.5974512",
"0.58580536",
"0.58321756",
"0.57499844",
"0.57043284",
"0.5635826",
"0.5635826",
"0.55382925",
"0.5494571",
"0.5475397",
"0.5416918",
"0.53558916",
"0.5349023",
"0.53315115",
"0.5306385",
"0.5292... | 0.64874995 | 1 |
get constraints of the current layer | def get_constraints(self, prev_layer):
constraints = []
if self.activation is not None:
constraints += self.activation.get_constraints(self, prev_layer)
else:
# for linear activations
current_constraints = []
for channel_indx in range(self.n_in_channels):
upper_bound, _ = prev_layer.get_bounds(channel_indx)
critical_prob = prev_layer.get_critical_neurons(channel_indx)
if critical_prob is None:
keep_upper_bound = 0
else:
keep_upper_bound = cp.multiply(1 - critical_prob, upper_bound)
current_constraints += [
self.layer_input[channel_indx]
== prev_layer.get_computation_layer(channel_indx) - keep_upper_bound
]
constraints += self.create_constraint(
f"{self.name}_linear", current_constraints
)
if prev_layer.compute_critical_neurons:
constraints += self.create_constraint(
f"neuron_importance_bounds_{prev_layer.name}",
[prev_layer.neuron_importance >= 0, prev_layer.neuron_importance <= 1],
)
return constraints | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_constraints(self):\n return self.constraints",
"def constraints(self):\n return self._constraints",
"def constraints(self):\n return self._constraints",
"def get_constraints(self):\n\n return vertcat(*self.g), self.g_min, self.g_max",
"def getConstraint(self):\n r... | [
"0.80761766",
"0.79321265",
"0.79321265",
"0.7608304",
"0.75793535",
"0.7431221",
"0.72901845",
"0.71523994",
"0.7082262",
"0.7023915",
"0.6928313",
"0.6927668",
"0.69181097",
"0.68804044",
"0.6866544",
"0.6732997",
"0.6618143",
"0.66156757",
"0.66137815",
"0.6589468",
"0.658... | 0.79009855 | 3 |
get the cvxpy variable associated with this layer | def get_cvxpy_variable(self, channel_indx=None):
if channel_indx is None:
output_channels = cp.hstack(
[
self.layer_input[cur_channel_indx]
for cur_channel_indx in range(self.n_in_channels)
]
)
else:
output_channels = self.layer_input[channel_indx]
return output_channels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xvar ( self ) :\n return self.__xvar",
"def x ( self ) :\n return self.xvar",
"def var(self, name):\n return self.get_ground_vector('!Var:{}'.format(name))",
"def var(self, name):\n return self.get_ground_vector('!Var:{}'.format(name))",
"def var(self, name):\n ret... | [
"0.6952394",
"0.6349231",
"0.6311073",
"0.6311073",
"0.6311073",
"0.6210869",
"0.614176",
"0.61036706",
"0.6093137",
"0.5973595",
"0.5904504",
"0.58920914",
"0.5774172",
"0.5744649",
"0.5726218",
"0.5713547",
"0.56973785",
"0.56402665",
"0.5625536",
"0.5621677",
"0.5595852",
... | 0.7194828 | 0 |
compute the output of this layer based on the weights biases and decision variable | def get_computation_layer(self, channel_indx=0):
if channel_indx is None:
return self._get_multi_channel_output_flat()
normalized_batch = (
self.layer_input[channel_indx] - self.running_mean[channel_indx]
) / (np.sqrt(self.running_var[channel_indx] + self.epsilon))
if self.affine:
return (normalized_batch * self.weights[channel_indx]) + self.bias[
channel_indx
]
return normalized_batch | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_outputs(self, *args, **kwargs):\n pass\n # self.outputs = self.model(input_ids=self.input_ids, masked_lm_labels=self.input_ids)\n # self.logits = self.outputs[0][0]\n # self.probs = torch.softmax(self.logits, 1)",
"def get_output(weight, data, regression= \"logistic\"):\n... | [
"0.67609805",
"0.6741717",
"0.6619007",
"0.65938884",
"0.650701",
"0.65016365",
"0.6475759",
"0.6448658",
"0.63928056",
"0.63902205",
"0.63838184",
"0.63790214",
"0.63790214",
"0.6343709",
"0.6316035",
"0.6315198",
"0.6305553",
"0.62861043",
"0.628232",
"0.62760216",
"0.62695... | 0.0 | -1 |
returns the bounds asssociated with input to this layer | def get_bounds(self, channel_indx=None):
if channel_indx is None:
upper_bound = self.upper_bound.reshape(self.batch_size, -1)
lower_bound = self.lower_bound.reshape(self.batch_size, -1)
else:
upper_bound = self.upper_bound[:, channel_indx, :].reshape(
self.batch_size, -1
)
lower_bound = self.lower_bound[:, channel_indx, :].reshape(
self.batch_size, -1
)
return upper_bound, lower_bound | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bounds(self):\n return self.kernel.bounds",
"def input_bounds(self):\n return self.__input_bounds",
"def bounds(self):\n return self.GetBounds()",
"def bounds(self):\n return self._bounds",
"def GetBounds(self):\n ...",
"def GetBounds(self):\n ...",
"def Ge... | [
"0.8187093",
"0.8182944",
"0.7970464",
"0.7969971",
"0.7886397",
"0.7886397",
"0.7886397",
"0.7886397",
"0.7886397",
"0.7886397",
"0.7886397",
"0.7886397",
"0.78816897",
"0.78816897",
"0.78687114",
"0.7821428",
"0.77718407",
"0.77343",
"0.7731461",
"0.7682162",
"0.7611129",
... | 0.6802181 | 53 |
routine used to test the current pooling implementation to make sure no discrepency between cvxpy and original pytorch layer | def _test(self):
self.pytorch_layer.eval()
pytorch_layer = copy.deepcopy(self.pytorch_layer).cpu()
image_w_h = int(self.input_size ** 0.5)
input_image = torch.rand(1, self.n_in_channels, image_w_h, image_w_h)
output_tensor = pytorch_layer(input_image)[0]
for channel in range(self.n_in_channels):
current_channel = input_image[0, channel].squeeze().flatten().cpu().numpy()
normalized_data = (current_channel - self.running_mean[channel]) / np.sqrt(
self.running_var[channel] + self.epsilon
)
if self.affine:
output_numpy = (self.weights[channel] * normalized_data) + self.bias[
channel
]
else:
output_numpy = normalized_data
assert np.isclose(
output_numpy,
output_tensor[channel].detach().flatten().cpu().numpy(),
atol=1e-6,
).all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_pool_consistency(self) -> None:\n x = Constant(\n 'const1',\n Float32(),\n np.zeros([1, 3, 3, 3])\n )\n input_ops = {'X': cast(Operator, x)}\n\n MaxPool(\n 'max_pool1',\n [1, 2, 2, 3],\n Float32(),\n i... | [
"0.6518167",
"0.6481036",
"0.64059615",
"0.6386542",
"0.6330426",
"0.6294219",
"0.62897485",
"0.6237556",
"0.61123407",
"0.603048",
"0.6028792",
"0.5981502",
"0.58038086",
"0.57659817",
"0.57648206",
"0.5753006",
"0.573803",
"0.57336324",
"0.57228494",
"0.57161427",
"0.571519... | 0.5887395 | 12 |
returns number of output channels | def get_n_channels(self):
return self.n_out_channels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_channels(self):\n return len(self.channels)",
"def num_channels_per_output(cls) -> list[tuple[int, ...]]:\n return [\n (16, 24, 40, 112, 320),\n (16, 24, 40, 112, 320),\n (16, 24, 48, 120, 352),\n (24, 32, 48, 136, 384),\n (24, 32, 56, 16... | [
"0.7895569",
"0.78375614",
"0.7822447",
"0.77712107",
"0.763508",
"0.7623057",
"0.76186246",
"0.75209033",
"0.7185467",
"0.717589",
"0.71026057",
"0.70969474",
"0.7064426",
"0.7045207",
"0.6935932",
"0.6927934",
"0.69142646",
"0.68657845",
"0.6865311",
"0.6837313",
"0.6834410... | 0.86962193 | 0 |
Adds operations that perform JPEG decoding and resizing to the graph.. | def _image_preprocess_fn(image_buffer, input_height, input_width, input_mean, input_std, return_full_size_image=False):
# image_buffer 1-D string Tensor representing the raw JPEG image buffer.
# Extract image shape from raw JPEG image buffer.
image_shape = tf.image.extract_jpeg_shape(image_buffer)
# Decode and crop image.
offset_x = 0
offset_y = image_shape[0] // 3 # We want to crop off the top fifth of the image
crop_width = image_shape[1]
crop_height = 2 * image_shape[0] // 3
crop_window = tf.stack([offset_y, offset_x, crop_height, crop_width])
cropped_image = tf.image.decode_and_crop_jpeg(image_buffer, crop_window, channels=3)
# Resize image.
# decoded_image_as_float = tf.cast(decoded_image, dtype=tf.float32)
decoded_image_4d = tf.expand_dims(cropped_image, 0)
resize_shape = tf.stack([input_height, input_width])
resize_shape_as_int = tf.cast(resize_shape, dtype=tf.int32)
resized_image = tf.image.resize_bilinear(decoded_image_4d, resize_shape_as_int)
# Normalize image
offset_image = tf.subtract(resized_image, input_mean)
mul_image = tf.multiply(offset_image, 1.0 / input_std)
if return_full_size_image:
return tf.squeeze(mul_image, axis=0), cropped_image
return tf.squeeze(mul_image, axis=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, image):",
"def process_image(self):\n pass",
"def adjust(self, image):\n ...",
"def augment(self, image):\n pass",
"def add_jpeg_decoding(input_width, input_height, input_depth, input_mean,\n input_std):\n\n jpeg_data = tf.placeholder(tf.strin... | [
"0.6741079",
"0.6175979",
"0.6148263",
"0.59459597",
"0.59365785",
"0.58881974",
"0.58312756",
"0.58165944",
"0.56556207",
"0.56259316",
"0.5575787",
"0.55362195",
"0.55134434",
"0.54918855",
"0.5491029",
"0.54815876",
"0.5451435",
"0.5449056",
"0.5448799",
"0.5446489",
"0.54... | 0.0 | -1 |
Creates input_fn according to parameters | def get_input_fn(input_file_names, batch_size=1, num_epochs=None, shuffle=False, shard_size=3000,
return_full_size_image=False):
def parse_fn(example):
"""Parse TFExample records and perform simple data augmentation."""
example_fmt = {
"image": tf.FixedLenFeature((), tf.string),
"target": tf.FixedLenFeature((), tf.float32, -1)
}
parsed = tf.parse_single_example(example, example_fmt)
if return_full_size_image:
preprocessed_image, full_size_image = _image_preprocess_fn(
image_buffer=parsed["image"], input_height=299, input_width=299, input_mean=128,
input_std=128, return_full_size_image=True)
return preprocessed_image, parsed["target"], full_size_image
preprocessed_image = _image_preprocess_fn(image_buffer=parsed["image"], input_height=299, input_width=299,
input_mean=128, input_std=128)
return preprocessed_image, parsed["target"]
def input_fn():
file_names = tf.constant(input_file_names, dtype=tf.string, name='input_file_names')
if shuffle:
num_shards = len(input_file_names)
files = tf.data.Dataset.from_tensor_slices(file_names).shuffle(num_shards)
dataset = files.interleave(tf.data.TFRecordDataset, cycle_length=3)
dataset = dataset.shuffle(buffer_size=shard_size*2)
else:
dataset = tf.data.TFRecordDataset(file_names)
dataset = dataset.map(map_func=parse_fn, num_parallel_calls=FLAGS.num_parallel_img_parsers)
dataset = dataset.batch(batch_size=batch_size)
dataset = dataset.repeat(num_epochs) # the input is repeated indefinitely if num_epochs is None
dataset = dataset.prefetch(buffer_size=64)
# print("Dataset ouput types: {}".format(dataset.output_types))
# print("Dataset ouput shapes: {}".format(dataset.output_shapes))
iterator = dataset.make_one_shot_iterator()
return iterator.get_next()
return input_fn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input_fn(sources, train, params):\n \n raise NotImplementedError",
"def _input_fn(input_pipeline_context=None):\n return _create_dataset(options, is_training, input_pipeline_context)",
"def generate_input_fn(mode='TRAIN'):\n mode = mode.upper()\n if mode == 'TRAIN' or mode == 'EVAL':\n ... | [
"0.77863973",
"0.70128167",
"0.6983106",
"0.6836533",
"0.6774335",
"0.6678941",
"0.66704524",
"0.6666463",
"0.66138333",
"0.66047716",
"0.6547102",
"0.6434819",
"0.6386017",
"0.63624465",
"0.63570637",
"0.63555074",
"0.634394",
"0.6342538",
"0.6278813",
"0.62751496",
"0.62735... | 0.0 | -1 |
Parse TFExample records and perform simple data augmentation. | def parse_fn(example):
example_fmt = {
"image": tf.FixedLenFeature((), tf.string),
"target": tf.FixedLenFeature((), tf.float32, -1)
}
parsed = tf.parse_single_example(example, example_fmt)
if return_full_size_image:
preprocessed_image, full_size_image = _image_preprocess_fn(
image_buffer=parsed["image"], input_height=299, input_width=299, input_mean=128,
input_std=128, return_full_size_image=True)
return preprocessed_image, parsed["target"], full_size_image
preprocessed_image = _image_preprocess_fn(image_buffer=parsed["image"], input_height=299, input_width=299,
input_mean=128, input_std=128)
return preprocessed_image, parsed["target"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parser(record):\n record_spec = {\n \"input\": tf.FixedLenFeature([seq_len], tf.int64),\n \"labels\": tf.FixedLenFeature([tgt_len], tf.int64),\n \"input_mask\": tf.FixedLenFeature([seq_len],tf.float32),\n \"target_mask\": tf.FixedLenFeature([tgt_len],tf.float32)\n }\n\n # r... | [
"0.684948",
"0.6609394",
"0.6605501",
"0.6414771",
"0.6374184",
"0.63535416",
"0.6350793",
"0.63333046",
"0.63030624",
"0.6258336",
"0.62369555",
"0.6210575",
"0.6175964",
"0.61759615",
"0.6129125",
"0.61166155",
"0.6116493",
"0.6086684",
"0.60770196",
"0.6074543",
"0.6071042... | 0.5721495 | 55 |
3x3 convolution with padding | def conv3x3(in_planes, out_planes, stride=1):
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conv3x3(in_planes, out_planes, stride=1, dilation=1, padding=1):\n return nn.Conv2d(in_planes,\n out_planes,\n kernel_size=3,\n stride=stride,\n padding=padding,\n dilation=dilation,\n bia... | [
"0.75487494",
"0.7377383",
"0.7326011",
"0.7300764",
"0.72812986",
"0.7276984",
"0.725113",
"0.72361106",
"0.723129",
"0.72272843",
"0.71892864",
"0.7178802",
"0.71645725",
"0.71645725",
"0.71645725",
"0.7158782",
"0.7156602",
"0.7156602",
"0.7156602",
"0.7156602",
"0.7156602... | 0.7081058 | 74 |
Constructs a BiRealNet18 model. | def birealnet18(pretrained=False, **kwargs):
model = BiRealNet(BasicBlock, [4, 4, 4, 4], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet18(pretrained=False, **kwargs):\n model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)\n if pretrained:\n model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))\n fc = transfer_fc(model.fc)\n model.fc = fc\n return model",
"def birealnet34(pretrained=False, **kwargs):\n ... | [
"0.6268504",
"0.620634",
"0.6204012",
"0.61781776",
"0.616232",
"0.61510354",
"0.61510354",
"0.61510354",
"0.61510354",
"0.61510354",
"0.6100227",
"0.6087697",
"0.6079006",
"0.6012798",
"0.5975343",
"0.59738714",
"0.59638786",
"0.5960628",
"0.5948427",
"0.5936224",
"0.5920398... | 0.70269394 | 1 |
Constructs a BiRealNet34 model. | def birealnet34(pretrained=False, **kwargs):
model = BiRealNet(BasicBlock, [6, 8, 12, 6], **kwargs)
return model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def birealnet18(pretrained=False, **kwargs):\n model = BiRealNet(BasicBlock, [4, 4, 4, 4], **kwargs)\n return model",
"def birealnet18(pretrained=False, **kwargs):\n model = BiRealNet(BasicBlock, [4, 4, 4, 4], **kwargs)\n return model",
"def resnet34(bitW, bitA, pretrained=False, **kwargs):\n mo... | [
"0.6753302",
"0.6753302",
"0.63931054",
"0.63634723",
"0.6265441",
"0.6239585",
"0.6229357",
"0.6220196",
"0.6198277",
"0.6196694",
"0.6196694",
"0.6196694",
"0.61152387",
"0.6085224",
"0.60785514",
"0.6060138",
"0.60452986",
"0.6025176",
"0.6025176",
"0.6025176",
"0.60139596... | 0.73481995 | 0 |
Kernel Density Estimation with Scipy | def kde_scipy(x, x_grid, bandwidth=0.2, **kwargs):
# Note that scipy weights its bandwidth by the covariance of the
# input data. To make the results comparable to the other methods,
# we divide the bandwidth by the sample standard deviation here.
#kde = gaussian_kde(x, bw_method=bandwidth / x.std(ddof=1), **kwargs)
kde = gaussian_kde(x)
return kde.evaluate(x_grid) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kde_sklearn(x, x_grid, bandwidth=0.8, **kwargs):\n \n kde_skl = KernelDensity(bandwidth=bandwidth, **kwargs)\n #kde_skl = KernelDensity()\n kde_skl.fit(x[:, np.newaxis])\n # score_samples() returns the log-likelihood of the samples\n log_pdf = kde_skl.score_samples(x_grid[:, np.newaxis])\n \... | [
"0.6899102",
"0.68290377",
"0.6813299",
"0.68107426",
"0.66186744",
"0.66110486",
"0.6379504",
"0.6353802",
"0.6331665",
"0.62971747",
"0.62869173",
"0.6239997",
"0.623953",
"0.6189176",
"0.6178441",
"0.6158369",
"0.6149099",
"0.61140794",
"0.6109274",
"0.6099322",
"0.6058081... | 0.6502326 | 6 |
Adds a record that a certain peer has a block. | def peer_has_block(
self, header_hash: bytes32, peer_id: bytes32, weight: uint128, height: uint32, new_peak: bool
) -> None:
if self.target_peak is not None and header_hash == self.target_peak.header_hash:
self.peers_changed.set()
if header_hash in self.peak_to_peer:
self.peak_to_peer[header_hash].add(peer_id)
else:
self.peak_to_peer[header_hash] = {peer_id}
if len(self.peak_to_peer) > 256: # nice power of two
item = self.peak_to_peer.popitem(last=False) # Remove the oldest entry
# sync target hash is used throughout the sync process and should not be deleted.
if self.target_peak is not None and item[0] == self.target_peak.header_hash:
self.peak_to_peer[item[0]] = item[1] # Put it back in if it was the sync target
self.peak_to_peer.popitem(last=False) # Remove the oldest entry again
if new_peak:
self.peer_to_peak[peer_id] = Peak(header_hash, height, weight) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def announce_new_block(block):\n for peer in peers:\n url = \"{}add_block\".format(peer)\n requests.post(url, data=json.dumps(block.__dict__, sort_keys=True))",
"def add_block(self, block, proof):\n previous_hash = self.last_block.hash\n\n if previous_hash != block.previous_hash:\n... | [
"0.6661918",
"0.663433",
"0.66281337",
"0.6614235",
"0.65480334",
"0.65008473",
"0.64870596",
"0.6486342",
"0.6483645",
"0.63460624",
"0.62318516",
"0.61465347",
"0.6141715",
"0.61389035",
"0.61175793",
"0.61068624",
"0.6093761",
"0.6086257",
"0.60828084",
"0.606044",
"0.6018... | 0.66007864 | 4 |
Clears the peak_to_peer info which can get quite large. | async def clear_sync_info(self) -> None:
self.peak_to_peer = orderedDict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self):\n self._fingerprint = 0",
"def clear(self):\n self.mismatch_error = None\n self.pt_outs = None\n self._onnx_graph = None\n self.upper_graph_info = None\n self.lower_graph_info = None",
"def clear(self):\n self.molo_tcp_pack.clear()\n self... | [
"0.6206844",
"0.58822215",
"0.5839706",
"0.5757953",
"0.57487977",
"0.5747801",
"0.5705526",
"0.5700115",
"0.5695211",
"0.56707",
"0.5589478",
"0.5570707",
"0.5559506",
"0.55220956",
"0.55071974",
"0.55066085",
"0.5479404",
"0.5468562",
"0.5449649",
"0.5447672",
"0.5441297",
... | 0.7599027 | 0 |
Peak wavelength when the curve is expressed as power density. | def lambda_max(self):
return const.b_wien / self.temperature | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wavelength(energy):\r\n return 2 * np.pi * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy",
"def wavelength(self):\n return wavelength(energy)",
"def peak(self):\n pass",
"def wavelength(energy):\n return 2 * PI * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy",
"def peak_PSF(self):\n ... | [
"0.65199757",
"0.65100896",
"0.6436953",
"0.6426267",
"0.6408306",
"0.62890404",
"0.6252019",
"0.624753",
"0.6180097",
"0.61793584",
"0.6162006",
"0.6152941",
"0.61026114",
"0.6093139",
"0.6071749",
"0.6033385",
"0.59775233",
"0.59704584",
"0.5951522",
"0.5938655",
"0.5900657... | 0.5508018 | 82 |
Make a hex string from the venue names to use as a unique id. Only the last 8 characters are used for the unique id. | def make_unique_id(venue_list):
md5_hash = md5()
for name in venue_list:
md5_hash.update(name)
hash_hex = md5_hash.hexdigest()
return hash_hex[-8:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_uuid():\n parts = [Record._hex_string(k) for k in Record.UUID_PARTS]\n return \"-\".join(parts)",
"def _unique_id():\n id = \"\"\n for i in xrange(0,8):\n id += choice(ascii_letters)\n return id",
"def format_unique_id(address: str) -> str:\n return address.replace(\"... | [
"0.7108777",
"0.67829424",
"0.67574894",
"0.66712064",
"0.66090417",
"0.6605987",
"0.6547099",
"0.643587",
"0.6423709",
"0.64172685",
"0.6412221",
"0.6411684",
"0.63644415",
"0.63502777",
"0.6323095",
"0.62953424",
"0.6283156",
"0.62323576",
"0.61994445",
"0.61936736",
"0.610... | 0.8124629 | 0 |
This is the algorithm. Get the score between these two venues. | def score(cur_ven, ven):
try:
alpha = 750
numerator = (ven["rating"] * 0.75) + (2.5 * (1- eulers**(-ven["ratingSignals"]/144)))
cur_coord = (cur_ven["location"]["lat"], cur_ven["location"]["lng"])
ven_coord = (ven["location"]["lat"], ven["location"]["lng"])
denominator = vincenty(cur_coord, ven_coord).meters + alpha
except Exception as e:
print "{}, \n has produced an error from {}".format(ven["name"], e)
return float("-inf")
return numerator / denominator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_score(self, a, b):\n ### FILL IN ###",
"def __get_score(self):\n for pair in zip(self.nu[self.nu_idx:], self.sw[self.sw_idx:]):\n if pair[0] == pair[1]:\n self.score += 1\n else:\n break",
"def reviewer_similarity_score(self, other: _Ver... | [
"0.70562255",
"0.66023374",
"0.64212406",
"0.6366032",
"0.6331436",
"0.6192957",
"0.6185072",
"0.61593205",
"0.61031914",
"0.60388577",
"0.6024461",
"0.59839195",
"0.59788215",
"0.59720534",
"0.59422135",
"0.59361476",
"0.5904944",
"0.5902023",
"0.5900325",
"0.5871707",
"0.58... | 0.6433049 | 2 |
Raises a ValueError if matrix `value` is not square. | def assert_square(name: str, value: np.ndarray) -> None:
if not len(value.shape) == 2 or value.shape[0] != value.shape[1]:
raise ValueError(f"{name} must be a square") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_square(self):\n if self.rows != self.cols:\n raise IndexError(\"Matrix is not square\")",
"def test_change_basis_raises_not_square(self, fun):\n A = np.random.rand(4, 6)\n with pytest.raises(ValueError, match=\"The input matrix is not square\"):\n fun(A)",
"... | [
"0.70691025",
"0.6647211",
"0.62668157",
"0.62668157",
"0.6163664",
"0.6089783",
"0.6032893",
"0.5889549",
"0.58770996",
"0.58336306",
"0.57889503",
"0.57666147",
"0.5684565",
"0.5575981",
"0.5559106",
"0.5558494",
"0.553429",
"0.55041176",
"0.5487154",
"0.5484843",
"0.547051... | 0.7312172 | 0 |
Calculates the Shannon entropy for probabilities `ps` with `base`. | def shannon_entropy(ps: np.ndarray, base: int = 2) -> float:
return -np.sum(ps * np.log(ps) / np.log(base)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(self, base: int = None):\n\n # shannon entropy in nats\n fdist_ = self.fdist\n fdist_[\"prob\"] = fdist_[\"freq\"] / fdist_[\"freq\"].sum()\n fdist_[\"logp\"] = np.log(fdist_[\"prob\"])\n fdist_[\"nats\"] = -fdist_[\"prob\"] * fdist_[\"logp\"]\n entropy_ = fdis... | [
"0.76036006",
"0.67516744",
"0.6684365",
"0.6516514",
"0.64760756",
"0.62832654",
"0.6267193",
"0.62411416",
"0.6221311",
"0.62205845",
"0.6211119",
"0.6175704",
"0.61547273",
"0.59715253",
"0.5954994",
"0.59400564",
"0.58892614",
"0.5873213",
"0.58565325",
"0.5835365",
"0.58... | 0.8918445 | 0 |
Simply tests if `img` has 3 channels. | def is_rgb(img: np.ndarray) -> bool:
return len(img.shape) >= 1 and img.shape[-1] == 3 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_rgb(im):\n if(im.ndim == 3):\n return True\n else:\n return False",
"def rgb(self) -> bool:\n return self.image_shape[2] == 3",
"def is_RGB(self,img_path):\n image=Image.open(img_path)\n image=np.asarray(image)\n if(len(image.shape)<3):\n return... | [
"0.72373766",
"0.7074375",
"0.67956823",
"0.6699473",
"0.66691566",
"0.6518619",
"0.65036654",
"0.62500054",
"0.62126744",
"0.6188705",
"0.61673236",
"0.61294484",
"0.61257964",
"0.6089409",
"0.594763",
"0.59257436",
"0.5916708",
"0.5915381",
"0.58001804",
"0.5760735",
"0.574... | 0.74561703 | 0 |
Converts an array [..., channels] of RGB values to HSI color values (H in rad). RGB values are assumed to be normalized to (0, 1). | def rgb_to_hsi(image: np.ndarray) -> np.ndarray:
if not is_rgb(image):
raise ValueError("Input needs to be an array of RGB values")
r = image[..., 0]
g = image[..., 1]
b = image[..., 2]
out = np.zeros_like(image)
# allequal = (img == img[:, :, 0, np.newaxis]).all(axis=-1)
with np.errstate(invalid="ignore"):
tmp = (2.0 * r - g - b) / 2.0 / np.sqrt((r - g) ** 2 + (r - b) * (g - b)) # if r==g==b then 0/0
theta = np.arccos(np.clip(tmp, -1.0, +1.0))
out[..., 0] = np.where(b <= g, theta, 2 * np.pi - theta) # H
out[..., 2] = np.sum(image, axis=-1) / 3.0 # I
out[..., 1] = 1 - np.amin(image, axis=-1) / out[..., 2] # S if r==g==b==0 then 0/0
np.nan_to_num(out[..., 0:2], copy=False)
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rgb2hsl_img(rgb):\r\n \r\n def core(_rgb, _hsl):\r\n\r\n irgb = _rgb.astype(np.uint16)\r\n ir, ig, ib = irgb[:, :, 0], irgb[:, :, 1], irgb[:, :, 2]\r\n h, s, l = _hsl[:, :, 0], _hsl[:, :, 1], _hsl[:, :, 2]\r\n\r\n imin, imax = irgb.min(2), irgb.max(2)\r\n iadd, isub = i... | [
"0.6703506",
"0.6296489",
"0.6287106",
"0.60505944",
"0.59786993",
"0.5978399",
"0.59774935",
"0.59652996",
"0.5940715",
"0.59046626",
"0.58576584",
"0.5831712",
"0.58161163",
"0.58112276",
"0.5776856",
"0.57461786",
"0.57437605",
"0.5730638",
"0.5720245",
"0.56746477",
"0.56... | 0.7039188 | 0 |
Converts an array [..., channels] of RGB values to Digital Y'CbCr (0255). RGB values are assumed to be normalized to (0, 1). Don't forget to cast to uint8 for pillow. | def rgb_to_ycbcr(image: np.ndarray) -> np.ndarray:
""" from RGB (0-1).
"""
if not is_rgb(image):
raise ValueError("Input needs to be an array of RGB values")
m = np.array(
[
[+065.481, +128.553, +024.966],
[-037.797, -074.203, +112.000],
[+112.000, -093.786, -018.214],
]
)
a = np.array([16, 128, 128])
return np.dot(image, m.T) + a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rgb_to_ycbcr(image: torch.Tensor) -> torch.Tensor:\n r: torch.Tensor = image[..., 0, :, :]\n g: torch.Tensor = image[..., 1, :, :]\n b: torch.Tensor = image[..., 2, :, :]\n\n delta: float = 0.5\n y: torch.Tensor = 0.299 * r + 0.587 * g + 0.114 * b\n cb: torch.Tensor = (b - y) * 0.564 + delta\... | [
"0.65595174",
"0.65373284",
"0.65213215",
"0.6495782",
"0.64475703",
"0.64128786",
"0.6219854",
"0.6115602",
"0.5978177",
"0.5957845",
"0.59014165",
"0.5828215",
"0.5691829",
"0.5660269",
"0.5658129",
"0.56305027",
"0.5622264",
"0.5549955",
"0.55226725",
"0.5519686",
"0.55096... | 0.6613111 | 0 |
Returns a triangular matrix with random value between 0 and 1 uniformly. | def random_triangular_matrix(size: int, lower: bool = True) -> np.ndarray:
a = np.random.uniform(0, 1, (size, size))
if lower:
ind = np.triu_indices(5, 1)
else:
ind = np.tril_indices(5, 1)
a[ind] = 0
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_rand_mat(dim=3):\n tmp = npr.uniform(-1, 1, (dim,dim))\n\n # make matrix symmetric\n for i in range(dim):\n for j in range(i+1, dim):\n tmp[i,j] = tmp[j,i]\n\n return tmp",
"def random_matrix(rows, cols):\n return np.random.randn(rows, cols)",
"d... | [
"0.6796665",
"0.6433331",
"0.6395273",
"0.63390714",
"0.63257",
"0.6278706",
"0.61659557",
"0.61443967",
"0.60865873",
"0.5927011",
"0.5907153",
"0.5863584",
"0.5841046",
"0.58366776",
"0.57918566",
"0.5788798",
"0.5776318",
"0.57745236",
"0.57488704",
"0.5734677",
"0.5692929... | 0.74994147 | 0 |
Performs batched calculation of `v^T A v` transform. Special case of bilinear form `x^T A y` | def batch_vTAv(A: np.ndarray, v: np.ndarray) -> np.ndarray:
""" Faster than
Av = np.matmul(A, v[...,:,None]) # [B, X, 1]
return np.matmul(v[...,None,:], Av).squeeze((-2, -1)) # [B]
"""
return np.einsum("...k,...kl,...l->...", v, A, v) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f(t, x, n, v):\n total = 0\n for i in range(n+1):\n for j in range(n+1):\n for k in range(v):\n total = t[i][j] * x[i][j][k]",
"def __call__(self, x, y):\n #- TODO: compare speed to solution at\n #- http://stackoverflow.com/questions/12729228/simple-effici... | [
"0.59027725",
"0.58240545",
"0.57738847",
"0.5771491",
"0.56887174",
"0.5658218",
"0.56540334",
"0.56478906",
"0.5588295",
"0.55453885",
"0.5531856",
"0.55062973",
"0.548991",
"0.5472191",
"0.54176724",
"0.541392",
"0.5401743",
"0.5387512",
"0.53842276",
"0.53838414",
"0.5374... | 0.6895596 | 0 |
Performs a batched inner product over the last dimension. Replacement for deprecated `from numpy.core.umath_tests import inner1d`. | def batch_inner(a: np.ndarray, b: np.ndarray, verify: bool = True) -> np.ndarray:
if verify and a.shape != b.shape:
raise ValueError("All dimensions have to be equal")
if a.shape[-1] == 0:
return np.empty_like(a)
return np.einsum("...i,...i->...", a, b) # faster than np.sum(a * b, axis=-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_outer_product(a, b):\n a, b = normalize_and_check_ndim([a, b], 2)\n # This is a batchwise version of the matrix multiplication approach\n # used for outer_product(), see explanation there.\n return a[:, :, np.newaxis] * b[:, np.newaxis, :]",
"def outer_product(input_sets, axis=0):\n out ... | [
"0.7076053",
"0.6733254",
"0.6566906",
"0.6538848",
"0.6200467",
"0.5971671",
"0.5898091",
"0.5882279",
"0.586811",
"0.58539116",
"0.5828389",
"0.58158463",
"0.57993835",
"0.5773256",
"0.57691",
"0.570448",
"0.5675385",
"0.5650381",
"0.5588937",
"0.55867285",
"0.5513858",
"... | 0.6739568 | 1 |
Performs a batched outer product over the last dimension. | def batch_outer(a: np.ndarray, b: np.ndarray, verify: bool = True) -> np.ndarray:
if verify and a.shape[:-1] != b.shape[:-1]:
raise ValueError("All except the last dimension have to be equal")
return np.einsum("...i,...j->...ij", a, b) # slightly faster than np.multiply(a[...,:,None], b[...,None,:]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_outer_product(a, b):\n a, b = normalize_and_check_ndim([a, b], 2)\n # This is a batchwise version of the matrix multiplication approach\n # used for outer_product(), see explanation there.\n return a[:, :, np.newaxis] * b[:, np.newaxis, :]",
"def outer_product(x):\n return keras.backend.... | [
"0.755109",
"0.70560527",
"0.6960709",
"0.6768571",
"0.65054774",
"0.63410676",
"0.61378115",
"0.61229986",
"0.60099125",
"0.5946456",
"0.59233963",
"0.590922",
"0.5882272",
"0.587886",
"0.5864047",
"0.58254915",
"0.5783885",
"0.5765654",
"0.5729165",
"0.57191443",
"0.5591057... | 0.66920644 | 4 |
`probs` values ndarray `k` take the smallest `k` elements, if `reverse` is False and the largest `k` if `reverse` is True `axis` sorting and selection axis. | def batchtopk(
probs: np.ndarray, k: Optional[int] = None, axis: int = -1, reverse: bool = False
) -> Tuple[np.ndarray, np.ndarray]:
if k is not None and k <= 0:
raise ValueError("k must be larger than 0. Use None to chose all elements.")
if axis != -1:
raise ValueError("Only last axis supported atm")
if len(probs.shape) <= 1:
raise ValueError("probs must be at least 2-dimensional")
if reverse:
sign = -1
else:
sign = 1
indices = np.argsort(sign * probs, axis=-1) # use argpartition?
probs = np.take_along_axis(probs, indices[..., :k], axis=-1)
return indices, probs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tflite_top_k_probs(probs, k):\n\n if k > 0:\n return np.flip(probs[0].argsort()[-k:])\n else:\n return np.flip(probs[0].argsort())",
"def tf_top_k_probs(probs, k):\n\n if k > 0:\n return probs.argsort()[-k:][::-1]\n else:\n return probs.argsort()[:][::-1]",
"def indi... | [
"0.7283214",
"0.6759031",
"0.58316225",
"0.58071005",
"0.5797564",
"0.57924837",
"0.5782279",
"0.5650926",
"0.55970734",
"0.5593298",
"0.558886",
"0.5553999",
"0.5523884",
"0.548393",
"0.5477123",
"0.5454491",
"0.5419435",
"0.5367509",
"0.5322573",
"0.5320744",
"0.5307545",
... | 0.7433971 | 0 |
Calcuates the sum of the logs of the diagonal elements (batchwise if necessary) | def logtrace(m: np.ndarray) -> np.ndarray:
""" note: performance cannot easily be improve by numba.
`np.diagonal` not supported by numba 0.52.0
"""
return np.sum(np.log(np.diagonal(m, axis1=-2, axis2=-1)), axis=-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trace(X):\r\n return extract_diag(X).sum()",
"def trace(X):\n return extract_diag(X).sum()",
"def ln_sum_i_neq_j(x):\n\tiw_size = x.size(0)\n\tbatch_size = x.size(1)\n\n\t# TODO: Would torch.expand instead of torch.repeat make this faster?\n\tinv_mask = torch.eye(iw_size).unsqueeze(dim=2).repeat(1, 1... | [
"0.6600348",
"0.6512393",
"0.63457274",
"0.62601304",
"0.62387985",
"0.6219907",
"0.6185488",
"0.6124841",
"0.6087076",
"0.606045",
"0.6032963",
"0.6027041",
"0.6024959",
"0.60206836",
"0.60127777",
"0.6009793",
"0.598619",
"0.5973478",
"0.5966066",
"0.58722997",
"0.58696294"... | 0.6544133 | 1 |
Shifts `pvals` by the largest value in the last dimension before the exp is calculated to prevent overflow (batchwise if necessary). Can be used if probabilities are normalized again later. | def shiftedexp(pvals: np.ndarray) -> np.ndarray:
if pvals.shape[-1] == 0:
return np.empty_like(pvals)
return np.exp(pvals - np.amax(pvals, axis=-1)[..., None]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def benjamini_hochberg_step_down(pvals):\r\n tmp = fdr_correction(pvals)\r\n corrected_vals = empty(len(pvals))\r\n max_pval = 1.\r\n for i in argsort(pvals)[::-1]:\r\n if tmp[i] < max_pval:\r\n corrected_vals[i] = tmp[i]\r\n max_pval = tmp[i]\r\n else:\r\n ... | [
"0.62695336",
"0.6066202",
"0.58225965",
"0.57363963",
"0.5489803",
"0.5446892",
"0.5247545",
"0.52059096",
"0.5191071",
"0.51882726",
"0.5157705",
"0.5066351",
"0.5033633",
"0.4979771",
"0.4901542",
"0.4892328",
"0.48860258",
"0.48807552",
"0.48794442",
"0.48614326",
"0.4850... | 0.7399692 | 0 |
Sample from list of probabilities `pvals` with replacement. The probabilities don't need to be normalized. | def sample_probabilities(pvals: np.ndarray) -> Callable[[], int]:
return Sampler(np.cumsum(pvals)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _correct_p_values(self, p_vals):\r\n num_tests = len([p_val for p_val in p_vals if p_val is not None])\r\n corrected_p_vals = []\r\n for p_val in p_vals:\r\n if p_val is not None:\r\n corrected_p_vals.append(min(p_val * num_tests, 1))\r\n else:\r\n ... | [
"0.62992084",
"0.5945291",
"0.57297397",
"0.55846256",
"0.5577901",
"0.5562105",
"0.54901296",
"0.539993",
"0.5361088",
"0.5338176",
"0.5308725",
"0.53033537",
"0.5288212",
"0.52389336",
"0.52308893",
"0.52133656",
"0.520034",
"0.5190075",
"0.5185366",
"0.5180876",
"0.5169325... | 0.6719965 | 0 |
Sample from the categorical distribution using `pvals`. | def categorical(pvals: np.ndarray) -> int:
return sample_probabilities(pvals)() # faster than: np.argmax(np.random.multinomial(1, normalize(pvals))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample_probabilities(pvals: np.ndarray) -> Callable[[], int]:\n\n return Sampler(np.cumsum(pvals))",
"def sample_categorical(distribution):\n sample = random.random()\n for event, prob in distribution.items():\n if sample < prob:\n return event\n sample -= prob\n raise Va... | [
"0.6776044",
"0.650533",
"0.64588654",
"0.6282057",
"0.6240135",
"0.6240135",
"0.62277555",
"0.6160603",
"0.6149961",
"0.60994315",
"0.60755867",
"0.60755867",
"0.60755867",
"0.6050657",
"0.6038272",
"0.6014659",
"0.5976859",
"0.5965328",
"0.59274614",
"0.5909927",
"0.5828886... | 0.7592371 | 0 |
Convert a population (list of observations) to a CDF. | def population2cdf(population: np.ndarray) -> np.ndarray:
population = np.sort(population)
return np.searchsorted(population, population, side="right") / len(population) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cdf(self,x):\n if hasattr(x,'__len__'):\n returnCdf = np.array([self.cdf(i) for i in x])\n else:\n returnCdf = self._distribution.cdf(x)\n return returnCdf",
"def cdf(self,x):\n coordinate = distribution1D.vectord_cxx(len(x))\n for i in range(len(x)):\n coordinate[i] = x[i]\n ... | [
"0.6000258",
"0.56762284",
"0.56762284",
"0.55965334",
"0.54399467",
"0.54305595",
"0.5391821",
"0.5380843",
"0.53685206",
"0.5361804",
"0.53427804",
"0.5326272",
"0.52933216",
"0.5286579",
"0.5269808",
"0.5198982",
"0.5191929",
"0.5165977",
"0.5149848",
"0.51354104",
"0.5111... | 0.62257254 | 0 |
Convert a discrete PDF into a discrete CDF. | def pmf2cdf(pdf: np.ndarray) -> np.ndarray:
cdf = np.cumsum(pdf)
return cdf / cdf[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cdf_to_pdf(cdf):\n pdf = deepcopy(cdf)\n pdf[1:] -= pdf[:-1].copy()\n return pdf",
"def pdf(self,x):\n return self.categoricalDist.pdf(x)",
"def pdf(self,x):\n if x in self.values:\n pdfValue = self.mapping[x]\n else:\n if self.isFloat:\n vals = sorted(list(self.values))\... | [
"0.69857043",
"0.61699057",
"0.59049094",
"0.5864199",
"0.58318394",
"0.57629466",
"0.573494",
"0.5734838",
"0.56632376",
"0.5655967",
"0.56498164",
"0.56412953",
"0.558819",
"0.55852294",
"0.5578906",
"0.5552537",
"0.5533782",
"0.5533782",
"0.551519",
"0.5459205",
"0.5448148... | 0.6718552 | 1 |
Tests the null hypothesis that both samples belong to the same distribution. | def _two_sample_kolmogorov_smirnov_pmf(
pmf1: np.ndarray, pmf2: np.ndarray, alpha: float = 0.05
) -> Tuple[float, float, bool]:
# note: yields different results as `scipy.stats.ks_2samp`
cdf1 = np.cumsum(pmf1)
cdf2 = np.cumsum(pmf2)
n1 = cdf1[-1]
n2 = cdf2[-1]
# cannot be inplace because of type conversion
cdf1 = cdf1 / n1
cdf2 = cdf2 / n2
statistic, pvalue = _two_sample_kolmogorov_smirnov_same_length(cdf1, cdf2, n1, n2)
reject = pvalue < alpha
return statistic, pvalue, reject | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_mc_t_two_sample_no_mc(self):\r\n x = array([1, 1, 1])\r\n y = array([0, 0, 0])\r\n self.assertEqual(mc_t_two_sample(x, x), (nan, nan, [], nan))",
"def test_t_two_sample_no_variance(self):\r\n # By default should return (None, None) to mimic R's t.test.\r\n x = array([1... | [
"0.6507358",
"0.6455645",
"0.6431785",
"0.6414398",
"0.6348298",
"0.6341265",
"0.633865",
"0.6277656",
"0.6269617",
"0.6268249",
"0.6254944",
"0.6232321",
"0.6192658",
"0.6153703",
"0.6132823",
"0.6105993",
"0.6078335",
"0.6060871",
"0.6044297",
"0.60279286",
"0.60275316",
... | 0.0 | -1 |
Calculate stochastic matrix `pm` to the power of infinity, by finding the eigenvector which corresponds to the eigenvalue 1. | def inf_matrix_power(pm: np.ndarray, dtype=np.float64) -> np.ndarray:
w, v = np.linalg.eig(
pm
) # scipy.linalg.eig would probably by faster as it can return the left and right eigen vectors
if not np.isclose(w[0], 1.0):
raise ValueError("The first eigenvalue is not none. Is this a right stochastic matrix?")
vi = np.linalg.inv(v)
d = np.zeros(pm.shape[0], dtype=dtype)
d[0] = 1.0
return np.matmul(v, np.matmul(np.diag(d), vi)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_E0(self) -> float:\n noisy = self.kernel_eigenvectors_[-1].copy()\n np.random.shuffle(noisy)\n\n kernel_eigenvectors = self.kernel_eigenvectors_[:-1]\n kernel_eigenvectors.append(noisy)\n\n eigenvectors_matrix = scipy.sparse.csr_matrix(\n np.column_stack(... | [
"0.62551945",
"0.60196066",
"0.59203595",
"0.5908042",
"0.589194",
"0.5879424",
"0.5878952",
"0.5874368",
"0.5866997",
"0.5835588",
"0.58008105",
"0.5785766",
"0.5769242",
"0.576087",
"0.5740334",
"0.5668045",
"0.55842084",
"0.5565213",
"0.5563019",
"0.55508184",
"0.55072254"... | 0.763889 | 0 |
Inverse of np.block. Set axis to (2, 1) to modify the order of the result. | def unblock(arr: np.ndarray, n1: int, n2: int, axis1: int = -1, axis2: int = -2, blocksize: bool = False) -> np.ndarray:
""" test (stackoverflow): Ok, so considering I have N block matrices with bm x bn dimension and want to stack them in a m x n matrix, provided N = m x n, I would then have x.reshape(m,n,bm,bn).swapaxes(1,2).reshape(bm*m,-1)
"""
s = np.array(arr.shape)
if s[axis1] % n1 != 0 or s[axis2] % n2 != 0:
raise ValueError(f"{s[axis1]}x{s[axis2]} does not divide by {n1}x{n2}")
if blocksize:
n1 = s[axis1] // n1
n2 = s[axis2] // n2
# this first .split adds a new dimensions on the outside, so if a absolute index
# is given for the second axis it must be moved one to the right
if axis2 >= 0:
_axis2 = axis2 + 1
else:
_axis2 = axis2
arr = np.array(np.split(arr, n1, axis1))
arr = np.array(np.split(arr, n2, _axis2))
inv_blocksize = n1 * n2
total = s[axis1] * s[axis2]
s[axis2] = inv_blocksize
s[axis1] = total // inv_blocksize
return np.reshape(arr, s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inverse(self):\n data = np.linalg.inv(self._data)\n return self.create(self.rows, self.cols, data)",
"def inverse(self, x, y):",
"def inverse(self: Float[LinearOperator, \"*batch N N\"]) -> Float[LinearOperator, \"*batch N N\"]:\n return self.__class__(self._diag.reciprocal())",
"def... | [
"0.67732894",
"0.665631",
"0.65951234",
"0.65613794",
"0.6526042",
"0.6483693",
"0.6445868",
"0.6425579",
"0.6381038",
"0.6379403",
"0.6377041",
"0.6358489",
"0.6346017",
"0.6340541",
"0.6327942",
"0.63209075",
"0.62847763",
"0.6274256",
"0.62589926",
"0.6158384",
"0.61480635... | 0.6248697 | 19 |
Replace colored pixels with a `neutral_color`. The `ratio` defines the 'colorfulness' above which level the pixel should be replace. I.e. if the `ratio` is 1 nothing will be replaced, if `ratio` is 0 only strict greys are kept unmodified. | def remove_color(img: np.ndarray, ratio: float, neutral_color: Tuple[int, int, int] = RGB_WHITE) -> None:
channels = img.shape[-1]
assert channels == 3, "Not a 3 channel color image"
norm = np.std(np.array(RGB_YELLOW)) # this is the same for all pure colors
sd = np.std(img, axis=-1)
img[sd > ratio * norm] = neutral_color | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ratio_to_rgb(ratio):\n b = 0\n if round(ratio, 1) == 0.5:\n r = 255\n g = 255\n elif ratio < 0.5:\n r = int(ratio * 2 * 255.0)\n g = 255\n else:\n r = 255\n g = int((1.0 - ratio) * 2 * 255.0)\n rgb = (r, g, b)\n\n return rgb",
"def set_neutral(self)... | [
"0.4983211",
"0.48789826",
"0.48116347",
"0.4737011",
"0.47265878",
"0.46818957",
"0.4571823",
"0.45462266",
"0.44600105",
"0.4397929",
"0.42731524",
"0.427132",
"0.4269558",
"0.42693788",
"0.42575642",
"0.42499575",
"0.42406985",
"0.42318156",
"0.4226033",
"0.4211065",
"0.41... | 0.7399279 | 0 |
It normalizes the last dimension of an ndarray to sum to 1. It can be used to convert (batches of) vectors to stochastic vectors or (batches of) matrices to right stochastic matrices. Right stochastic matrices are also called transitions matrices. | def stochastic(x: np.ndarray) -> np.ndarray:
n = np.linalg.norm(x, 1, axis=-1, keepdims=True)
# n = np.sum(x, axis=-1, keepdims=True) # todo: same result (except dtype), which is faster?
with np.errstate(invalid="raise"): # see: `normalized`
return x / n | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize(self,matrix):\n for i in range(self.N):\n matrix[self.N-1][i] = 0\n for i in range(self.n):\n matrix[self.N - 1][self.index(i,i)] = 1\n return matrix",
"def normalize(a, axis=None):\n a_sum = a.sum(axis)\n if axis and a.ndim > 1:\n a_sum[a_sum... | [
"0.68129104",
"0.67557216",
"0.6609631",
"0.6585958",
"0.645604",
"0.6451531",
"0.6302512",
"0.62421376",
"0.6205158",
"0.61722827",
"0.6167662",
"0.61229944",
"0.61031413",
"0.6083917",
"0.6082263",
"0.60746324",
"0.6066852",
"0.60581243",
"0.605747",
"0.6040707",
"0.6040707... | 0.59728706 | 31 |
Viterbi algorithm for finding the optimal path. One square transition matrix can be specified. | def viterbi_dense(
p_emit: np.ndarray, p_trans: np.ndarray, p_trans0: Optional[np.ndarray] = None, mask: Optional[np.ndarray] = None
) -> np.ndarray:
batch_size, T, N = p_emit.shape
if mask is None:
mask = np.ones((batch_size, T), dtype=p_trans.dtype)
if p_trans0 is None:
p_trans0 = np.zeros(N, dtype=p_emit.dtype)
return _viterbi_dense_masked(p_emit, p_trans, p_trans0, mask) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def original_solution():\n matrix = get_data()\n # Construct Graph\n G = nx.DiGraph()\n rows, cols = len(matrix), len(matrix[0])\n for r in xrange(rows):\n for c in xrange(cols):\n if 0 < c:\n G.add_edge(r*cols + c, r*cols + c - 1, weight=matrix[r][c-1])\n ... | [
"0.6767159",
"0.67312855",
"0.6485659",
"0.6303362",
"0.62523675",
"0.621314",
"0.617608",
"0.61201537",
"0.60680777",
"0.60667634",
"0.60551065",
"0.6045231",
"0.60280347",
"0.60061914",
"0.59879357",
"0.5987022",
"0.5967305",
"0.59623784",
"0.59502643",
"0.5880169",
"0.5855... | 0.0 | -1 |
Viterbi algorithm for finding the optimal path. The number of emission probabilities per index can vary and a separate matrix can be specified for each transition. | def viterbi_sparse(p_emit: Sequence[np.ndarray], p_trans: Sequence[np.ndarray]) -> np.ndarray:
T = len(p_emit)
assert T - 1 == len(p_trans)
trellis = [p_emit[0]]
states = [None]
for t in range(1, T):
weighted_scores = trellis[-1][:, None] + p_trans[t - 1] # [x, y] # scores and p_trans broadcasted
max_scores = np.amax(weighted_scores, axis=0) # [y]
trellis.append(np.add(max_scores, p_emit[t])) # [y] remember highest score of each path
states.append(np.argmax(weighted_scores, axis=0)) # [y] remember index of best path
assert len(trellis) == T and len(states) == T
tokens = [None] * T # [T]
tokens[-1] = np.argmax(trellis[-1], axis=0) # []
for t in range(T - 1, 0, -1):
tokens[t - 1] = states[t][tokens[t]] # []
return tokens | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def viterbi_path(prior, transmat, observ_likelihood):\n T = observ_likelihood.shape[-1]\n N = observ_likelihood.shape[0]\n\n path = numpy.zeros(T, dtype=numpy.int32)\n global_score = numpy.zeros(shape=(N,T))\n predecessor_state_index = numpy.zeros(shape=(N,T), dtype=numpy.int32)\n\n t = 1\n gl... | [
"0.705838",
"0.6940395",
"0.67826474",
"0.67684615",
"0.67196417",
"0.65749055",
"0.65712386",
"0.6491848",
"0.64757305",
"0.6461549",
"0.64065045",
"0.6359924",
"0.62643",
"0.6219971",
"0.6213666",
"0.6170746",
"0.6034146",
"0.602727",
"0.58137655",
"0.57686436",
"0.57664907... | 0.5941896 | 18 |
np.broadcast_shapes requires `numpy==1.20.0`, which is not available for `python < 3.7`. | def broadcast_shapes(*shapes: Tuple[int, ...]) -> Tuple[int, ...]:
arrays = [np.empty(shape) for shape in shapes]
return np.broadcast(*arrays).shape | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_broadcast_dims():\r\n test((1, 2, 3))\r\n test((2, 1, 3))\r\n test((2, 3, 1))\r\n test2((1, 2, 3))\r\n test2((2, 1, 3))\r\n test2((2, 3, 1))",
"def broadcast_shape(*shapes, **kwargs):\n strict = kwargs.pop(\"strict\", False)\n reversed_shape = []\n for shape in shapes:\n ... | [
"0.63662064",
"0.631577",
"0.6181781",
"0.60380113",
"0.59342825",
"0.5925404",
"0.58053595",
"0.57856745",
"0.57498085",
"0.56896067",
"0.55596524",
"0.55482703",
"0.548472",
"0.548077",
"0.540709",
"0.5397413",
"0.53940207",
"0.5373903",
"0.53049004",
"0.526517",
"0.5237194... | 0.6529921 | 0 |
Batched center of mass calculation of 2d arrays | def center_of_mass_2d(arr: np.ndarray, dtype=np.float32) -> np.ndarray:
total = np.sum(arr, axis=(-1, -2))
grids = np.ogrid[[slice(0, i) for i in arr.shape[-2:]]]
with np.errstate(invalid="ignore"):
results = np.array([np.sum(arr * grid.astype(dtype), axis=(-1, -2)) / total for grid in grids], dtype=dtype)
results = np.moveaxis(results, 0, -1)
return results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def centerOfMass(data):\r\n dd = []\r\n for d in data:\r\n dd.append(d.coordinate)\r\n\r\n data = dd\r\n data = np.array(data)\r\n n = len(data)\r\n x = sum(data[:,0])\r\n y = sum(data[:,1])\r\n z = sum(data[:,2])\r\n x/=n\r\n y/=n\r\n z/=n\r\n return x,y,z,n",
"def _ce... | [
"0.7113222",
"0.6913504",
"0.68147796",
"0.66269344",
"0.6623906",
"0.6605114",
"0.6573181",
"0.6555954",
"0.65233356",
"0.65076435",
"0.6476598",
"0.64425707",
"0.6414334",
"0.6406729",
"0.63674235",
"0.63496435",
"0.6226081",
"0.6160094",
"0.61026037",
"0.6084239",
"0.60666... | 0.74505234 | 0 |
Creates a picture grid (left to right, top to bottom). | def image_grid(images: np.ndarray, nrow: int = 8, fill_value=(0, 0, 0)) -> np.ndarray:
if not images.ndim == 4:
raise ValueError("Input shape must be [n, height, width, channel]")
h, w = images.shape[1:3]
nbatch = images.shape[0]
channels = images.shape[3]
rows = ceildiv(nbatch, nrow)
cols = min(nbatch, nrow)
if channels != len(fill_value):
raise ValueError("fill_value must match number of channels")
out = np.full((h * rows, w * cols, channels), fill_value, dtype=images.dtype)
for i in range(images.shape[0]):
row = i // cols
col = i % cols
out[h * row : h * (row + 1), w * col : w * (col + 1), :] = images[i]
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_grid(images, n_rows=4, n_cols=4):\n k = min(n_rows * n_cols, len(images))\n indices = [i for i in range(k)]\n return _create_grid(images, indices, n_rows, n_cols)",
"def create_grid(grid):\r\n for i in range(4):\r\n grid.append([0,0,0,0])",
"def generate_image_grid(sess, op):\n ... | [
"0.7382325",
"0.7234491",
"0.71866596",
"0.708115",
"0.70502263",
"0.7038171",
"0.6941421",
"0.69232905",
"0.68283314",
"0.6826088",
"0.68064976",
"0.67884314",
"0.6752977",
"0.6732644",
"0.67231864",
"0.6684483",
"0.66807157",
"0.6656162",
"0.66169745",
"0.65663916",
"0.6561... | 0.0 | -1 |
validate_target verifies that target is a valid MAC address, IP address or hostname | def validate_target(target, arp_table):
try:
mac = mac_address(target)
return mac
except TypeError:
pass
try:
ip = ip_address(target)
if ip in arp_table.keys():
return arp_table[ip].mac
except TypeError:
pass
if target in arp_table:
return arp_table[target].mac
else:
raise TypeError('{} is not a valid target'.format(target)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_target(target: str) -> bool:\n try:\n gethostbyname(target)\n except (gaierror, UnicodeError):\n return False\n return True",
"def validateIP():\n try:\n s = socket.inet_aton(args.target)\n except socket.error:\n print(\"\")\n pri... | [
"0.7149191",
"0.64991635",
"0.64354825",
"0.63836634",
"0.62301147",
"0.62007254",
"0.6052976",
"0.6006137",
"0.59964573",
"0.5994269",
"0.59239537",
"0.58881646",
"0.58818513",
"0.5870957",
"0.5835328",
"0.57881117",
"0.575523",
"0.5737461",
"0.57259214",
"0.5655272",
"0.563... | 0.76750195 | 0 |
mac_address checks that a given string is in MAC address format | def mac_address(addr):
mac = addr.upper()
if not _mac_address_pattern.fullmatch(mac):
raise TypeError('{} does not match a MAC address pattern'.format(addr))
return mac | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_valid_mac(address):\n m = \"[0-9a-f]{2}([-:])[0-9a-f]{2}(\\\\1[0-9a-f]{2}){4}$\"\n if isinstance(address, six.string_types) and re.match(m, address.lower()):\n return True\n return False",
"def isMAC(s):\n\n s = s.replace(':', '')\n if len(s) != 12: return 0\n for char... | [
"0.83441114",
"0.7788352",
"0.74661726",
"0.7465587",
"0.74038935",
"0.73613924",
"0.7340942",
"0.73230916",
"0.7296056",
"0.7203996",
"0.7073263",
"0.6936628",
"0.67489415",
"0.6534532",
"0.64768",
"0.64768",
"0.64768",
"0.64768",
"0.6468425",
"0.6463173",
"0.6461584",
"0.... | 0.7487672 | 2 |
ip_address checks that a given string is in IP address format | def ip_address(addr):
parts = addr.split('.')
if len(parts) != 4:
raise TypeError('{} does not match an IP address pattern'.format(addr))
for part in parts:
try:
num = int(part)
if num < 0 or num > 255:
raise TypeError('{} does not match an IP address pattern'.format(addr))
except ValueError:
raise TypeError('{} does not match an IP address pattern'.format(addr))
return addr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_ip(string):\n return ipv4.is_ip(string) or ipv6.is_ip(string)",
"def validate_ip_address(ip_addr):\n try:\n ip_object = ipaddress.ip_address(ip_addr)\n return True\n except ValueError:\n return False",
"def is_valid_ipaddress(str_ip: str) -> bool:\n try:\n ipaddre... | [
"0.8181276",
"0.8099573",
"0.80747545",
"0.80292475",
"0.8022243",
"0.7864434",
"0.78313065",
"0.78308326",
"0.78138804",
"0.7800783",
"0.77667433",
"0.7727927",
"0.7700073",
"0.76853204",
"0.76780635",
"0.76094407",
"0.7527797",
"0.74806803",
"0.74570745",
"0.7426013",
"0.74... | 0.7447207 | 19 |
Do not return anything, modify root inplace instead. | def flatten(self, root) -> None:
if not root:
return None
node = root
while node:
if node.left:
rightmost = node.left
while rightmost.right:
rightmost = rightmost.right
rightmost.right = node.right
node.right = node.left
node.left = None
node = node.right
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uproot(self):\n self.__root__ = self\n return self",
"def root_replace(self,node):\r\n self.feature_index = node.feature_index\r\n self.threshold = node.threshold\r\n self.label = node.label\r\n self.left = node.left\r\n self.right = node.right\r\n self.substit... | [
"0.71672195",
"0.70915145",
"0.7055208",
"0.69615245",
"0.67885584",
"0.66141015",
"0.6551368",
"0.6512747",
"0.6512747",
"0.6512747",
"0.6512747",
"0.6431704",
"0.6411715",
"0.6395968",
"0.6395968",
"0.6368781",
"0.63604164",
"0.6329711",
"0.6324841",
"0.6305654",
"0.6276602... | 0.0 | -1 |
Do not return anything, modify root inplace instead. | def flatten(self, root) -> None:
node = root
stack = []
while node:
if node.left:
if node.right:
stack.append(node.right)
node.right = node.left
node.left = None
if not node.left and not node.right and stack:
node.right = stack.pop()
node = node.right | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uproot(self):\n self.__root__ = self\n return self",
"def root_replace(self,node):\r\n self.feature_index = node.feature_index\r\n self.threshold = node.threshold\r\n self.label = node.label\r\n self.left = node.left\r\n self.right = node.right\r\n self.substit... | [
"0.71672195",
"0.70915145",
"0.7055208",
"0.69615245",
"0.67885584",
"0.66141015",
"0.6551368",
"0.6512747",
"0.6512747",
"0.6512747",
"0.6512747",
"0.6431704",
"0.6411715",
"0.6395968",
"0.6395968",
"0.6368781",
"0.63604164",
"0.6329711",
"0.6324841",
"0.6305654",
"0.6276602... | 0.0 | -1 |
Do not return anything, modify root inplace instead. | def flatten(self, root) -> None:
# 递归出口一定要到叶子节点
if not root: return None
if not root.left and not root.right: return root
lefttail = self.flatten(root.left)
righttail = self.flatten(root.right)
if lefttail:
lefttail.right = root.right
root.right = root.left
root.left = None
return righttail if righttail else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uproot(self):\n self.__root__ = self\n return self",
"def root_replace(self,node):\r\n self.feature_index = node.feature_index\r\n self.threshold = node.threshold\r\n self.label = node.label\r\n self.left = node.left\r\n self.right = node.right\r\n self.substit... | [
"0.71672195",
"0.70915145",
"0.7055208",
"0.69615245",
"0.67885584",
"0.66141015",
"0.6551368",
"0.6512747",
"0.6512747",
"0.6512747",
"0.6512747",
"0.6431704",
"0.6411715",
"0.6395968",
"0.6395968",
"0.6368781",
"0.63604164",
"0.6329711",
"0.6324841",
"0.6305654",
"0.6276602... | 0.0 | -1 |
[initalize spotify class to be used to manage playlists] | def __init__(self):
self.sp, self.user = self.init_auth_client()
self.logger = logging.getLogger(__name__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, API, playlist_uri):\n\n self.API = API\n self.playlist_uri = playlist_uri\n self.metadata = None",
"def __init__(self, username):\n self.spotify = spotipy.Spotify(simple_auth_token(username))",
"def __init__(self, **kwargs):\n self.songs = SongList()\n ... | [
"0.72976667",
"0.7259575",
"0.6638557",
"0.6578827",
"0.6547392",
"0.6536785",
"0.6459842",
"0.6452237",
"0.6372635",
"0.6340433",
"0.6314363",
"0.6273033",
"0.62022495",
"0.61825216",
"0.61784863",
"0.61702627",
"0.6157572",
"0.6012808",
"0.59975034",
"0.59931904",
"0.595047... | 0.0 | -1 |
[authorize and initialize spotify client] | def init_auth_client(self):
with open("config.yml", 'r') as ymlfile:
cfg = yaml.load(ymlfile)
token = util.prompt_for_user_token(
cfg['username'],
scope=cfg['scope'],
client_id=cfg['spotipy_client_id'],
client_secret=cfg['spotipy_client_secret'],
redirect_uri=cfg['spotipy_redirect_uri'])
sp = spotipy.Spotify(auth=token)
return sp, cfg['username'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_user(self) -> Any:\n return \\\n spotipy.Spotify(auth_manager=spotipy.oauth2.SpotifyOAuth(scope=\"playlist-modify-public\",\n client_id=self._public_id, client_secret=self._secret_id,\n redirect_uri=self._redirect_uri))",
"def authe... | [
"0.7275522",
"0.7169035",
"0.7160154",
"0.7054514",
"0.70088327",
"0.6976066",
"0.6880722",
"0.6798923",
"0.6781801",
"0.67027813",
"0.66602165",
"0.6602743",
"0.64574254",
"0.6410066",
"0.6331362",
"0.63175875",
"0.62989295",
"0.6185303",
"0.6183346",
"0.6170306",
"0.6090339... | 0.78885454 | 0 |
[creates a new playlist with given name, desc with given limts] | def create_new_playlist(self, name, desc=''):
pl_names, _, _ = self.list_playlists()
if name in pl_names:
self.logger.debug(
'Playlist Name Already Exists, please use another name')
else:
pl = self.sp.user_playlist_create(
self.user, name, public=False, description=desc)
self.sp.user_playlist_change_details(
self.user, pl['id'], collaborative=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_playlist(self, playlist_name):\n print(\"create_playlist needs implementation\")",
"def create_playlist():\n sp = credentials()\n sp.user_playlist_create('truetiming', name='Billboard Hot 100')",
"def create_playlist(self, data):\n pass",
"def create_playlist(self, playlist_nam... | [
"0.7272547",
"0.68430287",
"0.673538",
"0.6641419",
"0.661609",
"0.65667766",
"0.6543431",
"0.6541754",
"0.6530266",
"0.6512793",
"0.6474164",
"0.64047396",
"0.63702667",
"0.6338417",
"0.6316106",
"0.6193181",
"0.617585",
"0.61417544",
"0.60676473",
"0.6046706",
"0.5912048",
... | 0.7137164 | 1 |
[Will generate a list of 10 songs with given song name] | def search_song(self, name):
self.logger.debug('Searched for Song: {}'.format(name))
results = self.sp.search(q='track:' + name, type='track')
songs = [song for song in results['tracks']['items']]
i = 1
songs_ls = []
table_ls = []
for song in songs:
table_ls.append([i,
song['name'][0:20].strip(),
song['album']['name'][0:20].strip(),
"%0.2f" % (song['duration_ms'] / 60000),
song['popularity']])
songs_ls.append(song['uri'])
i = i + 1
return songs_ls, table_ls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simple_songs_list(name_of_album):\r\n songs = []\r\n data1 = dbase()\r\n data1 = data1[name_of_album][0]\r\n for song in data1.keys():\r\n songs += [song]\r\n return songs",
"def songs_list(name_of_album):\r\n songs = \"\"\r\n data = dbase()\r\n data = data[name_of_album][0]\r\... | [
"0.7061848",
"0.6690603",
"0.65612096",
"0.6520877",
"0.6450587",
"0.64253664",
"0.62649524",
"0.6210138",
"0.61440945",
"0.6127966",
"0.612063",
"0.61182624",
"0.6108939",
"0.60201514",
"0.60189235",
"0.60095435",
"0.597353",
"0.59719634",
"0.59651035",
"0.59640324",
"0.5957... | 0.6639254 | 2 |
[list all spotify playlists on users account] | def list_playlists(self, user=None):
if user:
playlists = self.sp.user_playlists(user)['items']
else:
playlists = self.sp.user_playlists(self.user)['items']
pl_names = [pl['name'] for pl in playlists]
pl_id = [pl['id'] for pl in playlists]
pl_own = [pl['owner']['id'] for pl in playlists]
return pl_names, pl_id, pl_own | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_playlists_for_user(self, request): \n user = Account.find_by_id(request.userid)\n playlists = Playlist.find_by_owner(user.key).fetch(20)\n return self.build_playlist_response(playlists)",
"def current_user_playlists(self, limit: int = 20, offset: int = 0):\n return self._get('... | [
"0.7721551",
"0.76566833",
"0.7571428",
"0.74551755",
"0.74398583",
"0.7157419",
"0.70816904",
"0.7019386",
"0.7003413",
"0.6947375",
"0.69466627",
"0.6937739",
"0.6878575",
"0.67284",
"0.6687034",
"0.6654773",
"0.66512775",
"0.6564396",
"0.63236004",
"0.6259983",
"0.6246766"... | 0.72365195 | 5 |
[list all the songs for a given playlist id] | def list_pl_songs(self, pl_id, user=None):
if user:
res = self.sp.user_playlist_tracks(user, pl_id)
else:
res = self.sp.user_playlist_tracks(self.user, pl_id)
song_uri_ls = [song['track']['uri'] for song in res['items']]
song_ls = []
for i, song in enumerate(res['items']):
song_ls.append([i,
song['track']['name'][0:20].strip(),
song['track']['album']['name'][0:20].strip(),
"%0.2f" % (song['track']['duration_ms'] / 60000),
song['track']['popularity']])
return song_uri_ls, song_ls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_playlist_songs(self, playlist_id):\n url = get_playlist_url(playlist_id)\n result = self.get_request(url)\n return result['result']['tracks'], result['result']['name']",
"def get_playlist_songs(self, playlist_id):\n values = {'action' : 'playlist_songs',\n 'filter... | [
"0.81859416",
"0.8030631",
"0.79889697",
"0.75973374",
"0.75427765",
"0.73269945",
"0.73071337",
"0.7261857",
"0.713018",
"0.7062886",
"0.70463115",
"0.6993529",
"0.6951676",
"0.69032377",
"0.6889015",
"0.6864356",
"0.68641925",
"0.68147",
"0.68029433",
"0.6800521",
"0.679698... | 0.6986906 | 12 |
[adds a song to a playlist] | def add_song_to_playlist(self, song_uri, playlist_id, user=None):
if song_uri[0] in self.list_pl_songs(playlist_id, user=None):
logging.debug('Song already in playlist')
else:
if user:
self.sp.user_playlist_add_tracks(user, playlist_id, song_uri)
else:
self.sp.user_playlist_add_tracks(
self.user, playlist_id, song_uri) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_song(self, song: Song):\n self.playlist.append(song)",
"def add_the_song_to_playlist(self):\n com_util.tap_on(self.driver, element['AddToPlaylist'])\n # com_util.send_to(self.driver, element['EnterThePlaylist'], 'My Songs')\n com_util.tap_on(self.driver, element['ClickMySongs'... | [
"0.8281379",
"0.8122598",
"0.81120324",
"0.77928084",
"0.7633073",
"0.76006603",
"0.73052067",
"0.7280356",
"0.7275825",
"0.72581446",
"0.72479594",
"0.7200695",
"0.7198082",
"0.71816415",
"0.71812034",
"0.70947707",
"0.7091116",
"0.70539707",
"0.7045048",
"0.70189893",
"0.69... | 0.7014243 | 20 |
[would list out friends, not working] | def list_users_friends(self):
user = self.sp.user(self.user)
return user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_friend_list(self):\n self.friends = self.df[['user_id','friends']]",
"def find_friends(request):\n find_list = []\n sent_requests = set()\n rec_requests = set()\n sent_f_requests = FriendRequest.objects.filter(\n from_user=request.user\n )\n rec_f_requests = FriendRequest.... | [
"0.71894276",
"0.7112803",
"0.70884013",
"0.7054558",
"0.7027464",
"0.698504",
"0.6922425",
"0.68556184",
"0.68189013",
"0.67964447",
"0.6792341",
"0.6780698",
"0.6738868",
"0.67151695",
"0.66937727",
"0.6683127",
"0.66392064",
"0.6594076",
"0.65758586",
"0.6565678",
"0.65209... | 0.67554355 | 12 |
onehot encode categorical, normalize scalar/player_id inputs | def preprocess_minimap(minimap):
layers = []
for i in range(len(features.MINIMAP_FEATURES)):
## scalar or to large to do one-hot
if i == _MINIMAP_SELECTED:
layers.append(minimap[i:i+1] / features.MINIMAP_FEATURES[i].scale)
## categorical
elif i == _MINIMAP_PLAYER_RELATIVE:
layer = np.zeros([features.MINIMAP_FEATURES[i].scale, minimap.shape[1], minimap.shape[2]], dtype=np.float32)
for j in range(features.MINIMAP_FEATURES[i].scale):
indy, indx = (minimap[i] == j).nonzero()
layer[j, indy, indx] = 1
layers.append(layer)
return np.concatenate(layers, axis=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __encode_one_hot_util(self):\n for col in self.cat_cols:\n if (\n col in self.train_df\n and col + str(\"Encoded\") not in self.ord_cols\n ):\n if self.test_df is not None:\n self.test_df = pd.concat(\n ... | [
"0.75467926",
"0.71732116",
"0.7166452",
"0.7154489",
"0.71511304",
"0.71498376",
"0.7130969",
"0.71149933",
"0.7075103",
"0.70738035",
"0.7065001",
"0.70538414",
"0.70359933",
"0.70098567",
"0.7004153",
"0.6951065",
"0.69328225",
"0.69303125",
"0.6927022",
"0.692566",
"0.691... | 0.0 | -1 |
onehot encode categorical, normalize scalar/player_id inputs | def preprocess_screen(screen):
layers = []
for i in range(len(features.SCREEN_FEATURES)):
if i == _SCREEN_UNIT_TYPE:
layers.append(screen[i:i + 1] / features.SCREEN_FEATURES[i].scale)
elif i == _SCREEN_SELECTED:
layers.append(screen[i:i + 1] / features.SCREEN_FEATURES[i].scale)
elif i == _SCREEN_PLAYER_RELATIVE:
layer = np.zeros([features.SCREEN_FEATURES[i].scale, screen.shape[1], screen.shape[2]], dtype=np.float32)
for j in range(features.SCREEN_FEATURES[i].scale):
indy, indx = (screen[i] == j).nonzero()
layer[j, indy, indx] = 1
layers.append(layer)
return np.concatenate(layers, axis=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __encode_one_hot_util(self):\n for col in self.cat_cols:\n if (\n col in self.train_df\n and col + str(\"Encoded\") not in self.ord_cols\n ):\n if self.test_df is not None:\n self.test_df = pd.concat(\n ... | [
"0.75467926",
"0.71732116",
"0.7166452",
"0.7154489",
"0.71511304",
"0.71498376",
"0.7130969",
"0.71149933",
"0.7075103",
"0.70738035",
"0.7065001",
"0.70538414",
"0.70359933",
"0.70098567",
"0.7004153",
"0.6951065",
"0.69328225",
"0.69303125",
"0.6927022",
"0.692566",
"0.691... | 0.0 | -1 |
Plot a line from slope and intercept | def abline(slope, intercept):
axes = plt.gca()
x_vals = np.array(axes.get_xlim())
y_vals = intercept + slope * x_vals
plt.plot(x_vals, y_vals, '--') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_regression_line():\r\n axes = plt.gca()\r\n x_vals = np.array(axes.get_xlim())\r\n y_vals = y_intercept() + slope() * x_vals\r\n plt.plot(x_vals, y_vals)",
"def abline(slope, intercept):\n axes = plt.gca()\n x_vals = np.array(axes.get_xlim())\n y_vals = intercept + s... | [
"0.8633385",
"0.837906",
"0.8353659",
"0.8208162",
"0.80252755",
"0.7704604",
"0.76632464",
"0.6855364",
"0.6737687",
"0.6706104",
"0.6655756",
"0.66362876",
"0.6601379",
"0.65816593",
"0.6529675",
"0.64858264",
"0.6483495",
"0.64728135",
"0.6463536",
"0.64627045",
"0.6454128... | 0.83326244 | 3 |
Only for human genome. If this is applied to other species, futher modification is needed. | def mapChrForVersion(c):
if c.startswith('chrM'):
return 998
elif c == 'chrX':
return 999
elif c == 'chrY':
return 1000
else:
return int(c[3:]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_species(self):\n warn(f\"Default Update Species Called for Mechanism = {self.name}.\")\n return []",
"def update_species_frames(self):\n pass",
"def speciate(self):\n\n\n # Clear out the previous generation\n for spec in self.species.values():\n spec.cha... | [
"0.63167685",
"0.63009715",
"0.62039506",
"0.60391605",
"0.5989629",
"0.580947",
"0.5797044",
"0.5579908",
"0.5506126",
"0.5501652",
"0.5439127",
"0.54250365",
"0.5421335",
"0.5421209",
"0.5415419",
"0.5400045",
"0.5384445",
"0.53612787",
"0.5360659",
"0.5338628",
"0.5326598"... | 0.0 | -1 |
return 0 if they equal, 1 if snp1 less, else 1 | def compare(chr1, pos1, chr2, pos2):
pos1 = int(pos1)
pos2 = int(pos2)
if chrsort == 'version':
chr1 = mapChrForVersion(chr1)
chr2 = mapChrForVersion(chr2)
elif chrsort == 'natural':
pass # use original chr1, chr2
else:
chr1 = chrsort.get(chr1, chr1)
chr2 = chrsort.get(chr2, chr2)
return -1 if (chr1, pos1) < (chr2, pos2) else 1 if (chr1, pos1) > (chr2, pos2) else 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def judge(n1: List[int], n2: List[int]) -> int:\n\tmin_length = min(len(n1),len(n2))\n\tpass_count = 0\n\tfor i in range(min_length):\n\t\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\n\n\treturn pass_count",
"def compareones_c(w1,w2,tn):\n nw1 = np.int_(np.copy(w1))\n nw2 = np.int_(np.copy(w... | [
"0.6195848",
"0.61714214",
"0.5978105",
"0.59495175",
"0.58783364",
"0.58137816",
"0.5750367",
"0.57387525",
"0.56986475",
"0.56565875",
"0.5649709",
"0.55772007",
"0.55763227",
"0.557493",
"0.55728525",
"0.5571845",
"0.557098",
"0.5570138",
"0.5562759",
"0.55625623",
"0.5560... | 0.0 | -1 |
Method which calculus game score through pss (player standard stats) | def set_game_score(self):
bx = self.get_standard_stats()
tcInt = bx["t2p_int"] + bx["t3p_int"]
tcConv = bx["t2p_conv"] + bx["t3p_conv"]
ft = bx["tl_int"] - bx["tl_conv"]
ptos = bx["t2p_conv"]*2 + bx["t3p_conv"]*3 + bx["tl_conv"]
#Con "%.2f" % round(x, 2) además de redondear a dos decimales, nos quedamos con los ceros finales
result = "%.2f" % round(float(ptos) + (float(0.4)*float(tcConv)) - (float(0.7)*float(tcInt)) - (float(0.4)*float(ft)) + (float(0.7)*float(bx["reb_of"]))
+ (float(0.3)*float(bx["reb_def"])) + float(bx["steals"]) + (float(0.7)*float(bx["assists"])) + (float(0.7)*float(bx["block_shots"]))
- (float(0.4)*float(bx["fouls_cm"])) - float(bx["turnovers"]), 2)
self.game_score = "%.2f" % round(Decimal(result)/bx["games"], 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scoreEvaluationFunction(gameState):\n return gameState.getScore()",
"def scoreEvaluationFunction(currentGameState):\r\n return currentGameState.getScore()",
"def scoreEvaluationFunction(currentGameState):\n return currentGameState.getScore()",
"def scoreEvaluationFunction(currentGameState):\n ret... | [
"0.68148273",
"0.68119067",
"0.6762667",
"0.6762667",
"0.6762667",
"0.6762667",
"0.6762667",
"0.6762667",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0.67188406",
"0... | 0.6767508 | 2 |
Method which calculate DRE metric | def set_dre(self):
bx = self.get_standard_stats()
ptos = float(bx["t2p_conv"]*2 + bx["t3p_conv"]*3 + bx["tl_conv"])
fga = float(bx["t2p_int"] + bx["t3p_int"])
trb = float(bx["reb_def"] + bx["reb_of"])
d1 = ptos + (0.2*trb) + (1.7*float(bx["steals"])) + (0.535*float(bx["block_shots"])) + (0.5*float(bx["assists"]))
d2 = (0.9*fga) + (0.35*float(bx["tl_int"])) + (1.4*float(bx["turnovers"])) + (0.136*float(bx["minutes"]))
result = "%.2f" % round(d1-d2, 2)
self.dre = "%.2f" % round(Decimal(result)/bx["games"], 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_metrics(self):\n pass",
"def calculate(self) -> float:",
"def calculate(self):",
"def calculate_dataset_metrics(self):\n pass",
"def calculateDataRate(self):\n pass",
"def getMeasures():",
"def denominator(self, ???):",
"def calculate(self):\r\n\r\n pass",
"d... | [
"0.6594812",
"0.65652555",
"0.647981",
"0.647346",
"0.63362116",
"0.62262213",
"0.6224595",
"0.618598",
"0.61559206",
"0.6152622",
"0.61477774",
"0.6140981",
"0.61260253",
"0.61076653",
"0.6089313",
"0.60319406",
"0.60208917",
"0.59696853",
"0.5940918",
"0.59328157",
"0.59270... | 0.56650126 | 49 |
Method which calculates TS Percentage metric for a player | def set_ts_percentage(self):
bx = self.get_standard_stats()
ptos = float(bx["t2p_conv"]*2 + bx["t3p_conv"]*3 + bx["tl_conv"])
tcInt = float(bx["t2p_int"] + bx["t3p_int"])
tsAttempts = float(tcInt + (0.44*float(bx["tl_int"])))
result = 0.00
if tsAttempts > 0.00:
result = (ptos/(2*tsAttempts))*100
self.ts_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pct(self):\n\t\treturn self.bottle.pct()",
"def percentCheck(currentTimeLabel, totalTimeLabel):\n # Updated 11/19/16\n try:\n progPercent = float(currentTimeLabel) / float(totalTimeLabel) * 100\n except (ValueError , ZeroDivisionError):\n progPercent = 0\n \n return progPerce... | [
"0.67912775",
"0.67874295",
"0.66820705",
"0.6615735",
"0.6549017",
"0.65139776",
"0.65139776",
"0.6465816",
"0.64634633",
"0.6446837",
"0.64173675",
"0.64117974",
"0.6390257",
"0.63858217",
"0.6356354",
"0.6316925",
"0.6298419",
"0.62818795",
"0.6281119",
"0.6268235",
"0.622... | 0.745896 | 0 |
Method which calculate USG% for each player from each team | def set_usg_percentage(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
tcInt = bx["t2p_int"] + bx["t3p_int"]
a = tcInt + (Decimal('0.44')*bx["tl_int"]) + bx["turnovers"]
b = team["minutes"]/5
c = (team["t2p_int"] + team["t3p_int"]) + (Decimal('0.44')*team["tl_int"]) + team["turnovers"]
result = 0.00
if bx["minutes"] > 0:
result = ((Decimal(a)*Decimal(b))/(bx["minutes"]*c))*100
self.usg_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_player_score():\n\n progress_bar = ProgressBar(label=\"Computing universes\")\n\n survivals_count = 0\n for i in range(PARALLEL_UNIVERSES_COUNT):\n if simulate_universe():\n survivals_count += 1\n progress_bar.set_progression((i + 1) / PARALLEL_UNIVERSES_COUNT)\n\n ... | [
"0.67434204",
"0.6500815",
"0.6359718",
"0.63065845",
"0.63019216",
"0.6301762",
"0.6299715",
"0.6148283",
"0.6126874",
"0.6103746",
"0.59502584",
"0.59436804",
"0.59398586",
"0.5932481",
"0.58808863",
"0.58741057",
"0.58336693",
"0.58299714",
"0.57860583",
"0.5785277",
"0.57... | 0.6911841 | 0 |
Method which calculate Total Rebound Percentage | def set_total_reb_percentage(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
opp_team = self.get_opp_team_stats()
player_rebounds = bx["reb_def"] + bx["reb_of"]
team_rebounds = team["reb_def"] + team["reb_of"]
opp_team_rebounds = opp_team["reb_def"] + opp_team["reb_of"]
result = 0.00
try:
if bx["minutes"] > 0 and bx["minutes"] > 0:
result = ((player_rebounds * (team["minutes"]/5)) / (bx["minutes"] * (team_rebounds + opp_team_rebounds)))*100
except ZeroDivisionError:
print(BCOLORS.FAIL + "Error: División por cero" + BCOLORS.ENDC)
except InvalidOperation:
print(BCOLORS.FAIL + "Error: Invalid Operation" + BCOLORS.ENDC)
self.total_reb_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_total_reb_of_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n result = 0.00\n try:\n if bx[\"reb_of\"] > 0 and bx[\"minutes\"] > 0:\n result = ((bx[\"reb_of\"] * (team[\"mi... | [
"0.6523484",
"0.6491968",
"0.63697445",
"0.6303792",
"0.6300233",
"0.62549525",
"0.6121597",
"0.6087575",
"0.60844654",
"0.6044818",
"0.6027688",
"0.6009361",
"0.5989413",
"0.5969596",
"0.59609574",
"0.59609574",
"0.59606254",
"0.5904455",
"0.5899307",
"0.58770585",
"0.584258... | 0.6903449 | 0 |
Method which calculate Total Rebound Defensive Percentage | def set_total_reb_def_percentage(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
opp_team = self.get_opp_team_stats()
result = 0.00
try:
if bx["minutes"] > 0 and bx["minutes"] > 0:
result = ((bx["reb_def"] * (team["minutes"]/5)) / (bx["minutes"] * (team["reb_def"] + opp_team["reb_of"])))*100
except ZeroDivisionError:
print(BCOLORS.FAIL + "Error: División por cero" + BCOLORS.ENDC)
except InvalidOperation:
print(BCOLORS.FAIL + "Error: Invalid Operation" + BCOLORS.ENDC)
self.total_reb_def_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_real_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_real_rating() / self.field.range)",
"def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_te... | [
"0.6720814",
"0.65615296",
"0.64223516",
"0.63799196",
"0.63289535",
"0.63207704",
"0.63154423",
"0.62732965",
"0.6261528",
"0.6167289",
"0.6124796",
"0.61081874",
"0.6068133",
"0.60473025",
"0.5999613",
"0.5988745",
"0.59840715",
"0.5983306",
"0.5973883",
"0.59696484",
"0.59... | 0.6653622 | 1 |
Method which calculate Total Rebound Ofensive Percentage | def set_total_reb_of_percentage(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
opp_team = self.get_opp_team_stats()
result = 0.00
try:
if bx["reb_of"] > 0 and bx["minutes"] > 0:
result = ((bx["reb_of"] * (team["minutes"]/5)) / (bx["minutes"] * (team["reb_of"] + opp_team["reb_def"])))*100
except ZeroDivisionError:
print(BCOLORS.FAIL + "Error: División por cero" + BCOLORS.ENDC)
self.total_reb_of_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_total_reb_percentage(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n player_rebounds = bx[\"reb_def\"] + bx[\"reb_of\"]\n team_rebounds = team[\"reb_def\"] + team[\"reb_of\"]\n opp_team_rebounds = opp... | [
"0.68673694",
"0.66328514",
"0.65427613",
"0.64778984",
"0.64688313",
"0.64383364",
"0.63684523",
"0.6308236",
"0.6169081",
"0.6124151",
"0.60928077",
"0.60605025",
"0.6027442",
"0.60271585",
"0.60221356",
"0.60200536",
"0.6008577",
"0.6006814",
"0.5980527",
"0.5972647",
"0.5... | 0.65185946 | 3 |
Method which calculate Steals Percentage of a player | def set_steals_percentage(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
opp_team = self.get_opp_team_stats()
poss = self.get_team_possessions()
result = 0.00
if bx["minutes"] > 0:
result = ((bx["steals"] * (team["minutes"]/Decimal('5'))) / Decimal(float(bx["minutes"]) * poss)) * 100
self.steals_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)",
"def winning_percentage(self):\n return fl... | [
"0.6973858",
"0.68804467",
"0.68694776",
"0.6837882",
"0.6696774",
"0.65600723",
"0.6460961",
"0.6452967",
"0.64353186",
"0.6403429",
"0.6403429",
"0.6369753",
"0.6368016",
"0.63537014",
"0.63537014",
"0.63495165",
"0.6336215",
"0.632231",
"0.62704694",
"0.6268536",
"0.626853... | 0.77550447 | 0 |
Method which calculate Effective Field Goal (eTC) of a player | def set_effective_field_goal_percentage(self):
bx = self.get_standard_stats()
tcInt = float(bx["t2p_int"] + bx["t3p_int"])
tcConv = float(bx["t2p_conv"] + bx["t3p_conv"])
result = 0.00
if tcInt > 0:
result = ((tcConv + (0.5 * float(bx["t3p_conv"]))) / tcInt) * 100
self.effective_field_goal_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getETA():",
"def getETA():",
"def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))",
"def calculate_utility(state, player):\n thisPlayer = player\n \n ... | [
"0.5827492",
"0.5827492",
"0.5789208",
"0.5724517",
"0.5719123",
"0.5719123",
"0.5719123",
"0.56517696",
"0.5605782",
"0.55988175",
"0.5591225",
"0.55509675",
"0.55410445",
"0.5514421",
"0.5474888",
"0.54631376",
"0.54623526",
"0.5455384",
"0.54417086",
"0.5441079",
"0.543202... | 0.5157421 | 68 |
Method which calculate Assists Percentage of a player | def set_assists_percentage(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
team_tc_conv = team["t2p_conv"] + team["t3p_conv"]
player_tc_conv = bx["t2p_conv"] + bx["t3p_conv"]
result = 0.00
try:
if bx["minutes"] > 0:
result = (bx["assists"] / (((bx["minutes"] / (team["minutes"] / 5)) * team_tc_conv) - player_tc_conv))*100
result = result if result <= 100 and result >= 0 else 0
except ZeroDivisionError:
print(BCOLORS.WARNING + "Error: División por cero" + BCOLORS.ENDC)
except InvalidOperation:
print(BCOLORS.WARNING + "Error: Invalid Operation" + BCOLORS.ENDC)
self.assists_percentage = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_percent(self):\n if not (self.votes and self.score):\n return 0\n return 100 * (self.get_rating() / self.field.range)",
"def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n... | [
"0.7001746",
"0.68421483",
"0.6813",
"0.67631215",
"0.67387015",
"0.6656908",
"0.6627645",
"0.6627645",
"0.6618226",
"0.6604493",
"0.66013306",
"0.6542234",
"0.6510403",
"0.64416814",
"0.64405453",
"0.64405453",
"0.64318055",
"0.64273596",
"0.63814425",
"0.63652843",
"0.63540... | 0.767859 | 0 |
Method which calculate Ratio Assists Per Turnover of a player | def set_assists_per_turnover(self):
bx = self.get_standard_stats()
ratio = bx["assists"]
if bx["turnovers"] > 0:
ratio = bx["assists"] / bx["turnovers"]
self.assists_per_turnover = "%.2f" % round(ratio, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&loc... | [
"0.69899476",
"0.66916925",
"0.66868806",
"0.661133",
"0.64811707",
"0.63243896",
"0.62888366",
"0.62563837",
"0.623092",
"0.6226826",
"0.6220208",
"0.62145406",
"0.6178597",
"0.6162016",
"0.6135676",
"0.6127374",
"0.6116254",
"0.60962725",
"0.60838556",
"0.6064083",
"0.60435... | 0.7008181 | 0 |
Method which calculate Assists Ratio of a player | def set_assists_ratio(self):
bx = self.get_standard_stats()
tcInt = float(bx["t2p_int"] + bx["t3p_int"])
denominador = tcInt + (0.44 * float(bx["tl_int"])) + float(bx["assists"]) +float(bx["turnovers"])
numerador = float(bx["assists"])
result = 0.00
if denominador > 0:
result = (numerador / denominador) * 100
self.assists_ratio = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&loc... | [
"0.72646964",
"0.64316165",
"0.6352074",
"0.6281999",
"0.6247194",
"0.6209247",
"0.6207199",
"0.61734754",
"0.61600745",
"0.61037296",
"0.609562",
"0.607315",
"0.60665053",
"0.60465765",
"0.6046293",
"0.60187536",
"0.6009164",
"0.59791255",
"0.5958189",
"0.59420407",
"0.58815... | 0.7257836 | 1 |
Method which calculate Defensive Ratio of a player. The total points received in 100 possessions | def set_defensive_ratio(self):
bx = self.get_standard_stats()
team = self.get_team_stats()
opp_team = self.get_opp_team_stats()
if bx["minutes"] > 0:
opp_fga = opp_team["t2p_int"] + opp_team["t3p_int"]
opp_fgm = opp_team["t2p_conv"] + opp_team["t3p_conv"]
try:
dor = Decimal(opp_team["reb_of"] / (opp_team["reb_of"] + team["reb_def"]))
except ZeroDivisionError:
print(BCOLORS.FAIL + "Error: División por cero" + BCOLORS.ENDC)
dor = 0
except InvalidOperation:
print(BCOLORS.FAIL + "Error: Invalid Operation" + BCOLORS.ENDC)
dor = 0
try:
dfg = Decimal(opp_fgm / opp_fga)
except ZeroDivisionError:
print(BCOLORS.WARNING + "Error: División por cero" + BCOLORS.ENDC)
dfg = 0
try:
fmwt = Decimal((dfg * (1 - dor)) / (dfg * (1 - dor) + (1 - dfg) * dor))
except:
fmwt = 0
stops1 = bx["steals"] + bx["block_shots"] * fmwt * (1 - Decimal('1.07') * dor) + bx["reb_def"] * (1 - fmwt)
try:
stops2 = (Decimal((opp_fga - opp_fgm - team["block_shots"]) / team["minutes"]) * fmwt * (1 - Decimal('1.07') * dor) + Decimal((opp_team["turnovers"] - team["steals"]) / team["minutes"])) * bx["minutes"] + Decimal(bx["fouls_cm"] / team["fouls_cm"]) * Decimal('0.4') * opp_team["tl_int"] * (1 - Decimal(opp_team["tl_conv"] / opp_team["tl_int"]))**2
except ZeroDivisionError:
print(BCOLORS.WARNING + "Error: División por cero" + BCOLORS.ENDC)
stops2 = 0
except InvalidOperation:
print(BCOLORS.WARNING + "Error: Invalid Operation" + BCOLORS.ENDC)
stops2 = 0
stops = stops1 + stops2
poss = self.get_team_possessions()
if bx["minutes"] > 0:
stop_percentage = (float(stops) * float(opp_team["minutes"])) / (float(poss) * float(bx["minutes"]))
else:
stop_percentage = 0.00
opp_points = opp_team["t2p_conv"] * 2 + opp_team["t3p_conv"] * 3 + opp_team["tl_conv"]
team_defensive_rating = 100 * (float(opp_points) / poss)
try:
d_pts_per_scposs = float(opp_points) / (float(opp_fgm) + (1 - (1 - (float(opp_team["tl_conv"]) / float(opp_team["tl_int"])))**2) * float(opp_team["tl_int"])*0.4)
result = Decimal(team_defensive_rating) + Decimal('0.2') * (100 * Decimal(d_pts_per_scposs) * (1 - Decimal(stop_percentage)) - Decimal(team_defensive_rating))
except ZeroDivisionError:
print(BCOLORS.WARNING + "Error: División por cero" + BCOLORS.ENDC)
d_pts_per_scposs = 0
result = 0.00
# print("dor: " + str(dor))
# print("dfg: " + str(dfg))
# print("fmwt: " + str(fmwt))
# print("stops1: " + str(stops1))
# print("stops2: " + str(stops2))
# print("stops: " + str(stops))
# print("poss: " + str(poss))
# print("stop_percentage: " + str(stop_percentage))
# print("opp_points: " + str(opp_points))
# print("team_defensive_rating: " + str(team_defensive_rating))
# print("d_pts_per_scposs: " + str(d_pts_per_scposs))
# print("drtg: " + str(result) + "\n")
else:
result = 0.00
self.drtg = "%.2f" % round(result, 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def player_ratio(self, ctx):\r\n player = ctx.message.content.split(' ')[1]\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with aiohttp.ClientSession().get('https://us.api.battle.net/wow/character/zul\\'jin/' + player + '?fields=pvp&loc... | [
"0.6531963",
"0.6401618",
"0.61817557",
"0.6132738",
"0.6081823",
"0.6071461",
"0.60199296",
"0.5966795",
"0.5962311",
"0.59621847",
"0.5957963",
"0.59393156",
"0.59319943",
"0.5922137",
"0.5918801",
"0.5913682",
"0.5907549",
"0.58991516",
"0.5896585",
"0.5889761",
"0.5885497... | 0.65123755 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.